3 * ===================================
4 * HARP | Host ATM Research Platform
5 * ===================================
8 * This Host ATM Research Platform ("HARP") file (the "Software") is
9 * made available by Network Computing Services, Inc. ("NetworkCS")
10 * "AS IS". NetworkCS does not provide maintenance, improvements or
11 * support of any kind.
13 * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
14 * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
15 * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
16 * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
17 * In no event shall NetworkCS be responsible for any damages, including
18 * but not limited to consequential damages, arising from or relating to
19 * any use of the Software or related support.
21 * Copyright 1994-1998 Network Computing Services, Inc.
23 * Copies of this Software may be made, however, the above copyright
24 * notice must be reproduced on all copies.
26 * @(#) $FreeBSD: src/sys/netatm/spans/spans_proto.c,v 1.4 1999/08/28 00:48:51 peter Exp $
27 * @(#) $DragonFly: src/sys/netproto/atm/spans/spans_proto.c,v 1.5 2003/08/23 10:06:22 rob Exp $
31 * SPANS Signalling Manager
32 * ---------------------------
34 * SPANS protocol processing module.
38 #include <netproto/atm/kern_include.h>
40 #include "spans_xdr.h"
41 #include "spans_var.h"
46 caddr_t spans_getname (void *);
47 void spans_connected (void *);
48 void spans_cleared (void *, struct t_atm_cause *);
49 void spans_cpcs_data (void *, KBuffer *);
53 * ATM endpoint for SPANS signalling channel
55 static Atm_endpoint spans_endpt = {
57 ENDPT_SPANS_SIG, /* ep_id */
59 spans_getname, /* ep_getname */
60 spans_connected, /* ep_connected */
61 spans_cleared, /* ep_cleared */
62 NULL, /* ep_incoming */
63 NULL, /* ep_addparty */
64 NULL, /* ep_dropparty */
65 NULL, /* ep_cpcs_ctl */
66 spans_cpcs_data, /* ep_cpcs_data */
67 NULL, /* ep_saal_ctl */
68 NULL, /* ep_saal_data */
69 NULL, /* ep_sscop_ctl */
70 NULL /* ep_sscop_data */
75 * ATM connection attributes for UNI signalling channel
77 static Atm_attributes spans_attr = {
84 T_ATM_PRESENT, /* aal.tag */
85 ATM_AAL3_4 /* aal.aal_type */
88 T_ATM_PRESENT, /* traffic.tag */
90 { /* traffic.v.forward */
91 T_ATM_ABSENT, /* PCR_high */
93 T_ATM_ABSENT, /* SCR_high */
94 T_ATM_ABSENT, /* SCR_all */
95 T_ATM_ABSENT, /* MBS_high */
96 T_ATM_ABSENT, /* MBS_all */
99 { /* traffic.v.backward */
100 T_ATM_ABSENT, /* PCR_high */
102 T_ATM_ABSENT, /* SCR_high */
103 T_ATM_ABSENT, /* SCR_all */
104 T_ATM_ABSENT, /* MBS_high */
105 T_ATM_ABSENT, /* MBS_all */
108 T_YES, /* best_effort */
112 T_ATM_PRESENT, /* bearer.tag */
114 T_ATM_CLASS_X, /* class */
115 T_ATM_NULL, /* traffic_type */
116 T_ATM_NO_END_TO_END, /* timing_req */
118 T_ATM_1_TO_1, /* conn_conf */
122 T_ATM_ABSENT, /* bhli.tag */
125 T_ATM_ABSENT, /* blli.tag_l2 */
126 T_ATM_ABSENT, /* blli.tag_l3 */
129 T_ATM_ABSENT, /* llc.tag */
132 T_ATM_PRESENT, /* called.tag */
135 T_ATM_ABSENT, /* calling.tag */
138 T_ATM_PRESENT, /* qos.tag */
140 T_ATM_NETWORK_CODING, /* coding_standard */
141 { /* qos.v.forward */
142 T_ATM_QOS_CLASS_0, /* class */
144 { /* qos.v.backward */
145 T_ATM_QOS_CLASS_0, /* class */
150 T_ATM_ABSENT, /* transit.tag */
153 T_ATM_ABSENT, /* cause.tag */
159 * SPANS cause structre
161 struct t_atm_cause spans_cause = {
162 T_ATM_ITU_CODING, /* coding_standard */
163 T_ATM_LOC_USER, /* location */
164 T_ATM_CAUSE_UNSPECIFIED_NORMAL, /* cause_value */
165 { 0, 0, 0, 0 } /* diagnostics */
170 * Process a SPANS timeout
172 * Called when a previously scheduled spans control block timer expires.
173 * Processing will based on the current SPANS state.
178 * tip pointer to spans timer control block
186 struct atm_time *tip;
194 * Back-off to SPANS control block
196 spp = (struct spans *)
197 ((caddr_t)tip - (int)(&((struct spans *)0)->sp_time));
199 ATM_DEBUG2("spans_timer: spp=%p,state=%d\n",
203 * Process timeout based on protocol state
205 switch (spp->sp_state) {
210 * Open signalling channel
212 spans_attr.nif = spp->sp_pif->pif_nif;
214 spans_attr.aal.v.aal4.forward_max_SDU_size =
216 spans_attr.aal.v.aal4.backward_max_SDU_size =
218 spans_attr.aal.v.aal4.SSCS_type =
219 T_ATM_SSCS_SSCOP_UNREL;
220 spans_attr.aal.v.aal4.mid_low = 0;
221 spans_attr.aal.v.aal4.mid_high = 0;
223 spans_attr.called.tag = T_ATM_PRESENT;
224 spans_attr.called.addr.address_format = T_ATM_PVC_ADDR;
225 spans_attr.called.addr.address_length =
226 sizeof(Atm_addr_pvc);
227 pvcp = (Atm_addr_pvc *)spans_attr.called.addr.address;
228 ATM_PVC_SET_VPI(pvcp, SPANS_SIG_VPI);
229 ATM_PVC_SET_VCI(pvcp, SPANS_SIG_VCI);
230 spans_attr.called.subaddr.address_format = T_ATM_ABSENT;
231 spans_attr.called.subaddr.address_length = 0;
233 spans_attr.traffic.v.forward.PCR_all_traffic =
234 spp->sp_pif->pif_pcr;
235 spans_attr.traffic.v.backward.PCR_all_traffic =
236 spp->sp_pif->pif_pcr;
238 err = atm_cm_connect(&spans_endpt, spp, &spans_attr,
241 log(LOG_CRIT, "spans: signalling channel setup failed\n");
246 * Signalling channel open, start probing
248 spp->sp_state = SPANS_PROBE;
256 * Send out SPANS_STAT_REQ message
258 msg = (spans_msg *)atm_allocate(&spans_msgpool);
260 /* Retry later if no memory */
261 SPANS_TIMER(spp, SPANS_PROBE_ERR_WAIT);
264 msg->sm_vers = SPANS_VERS_1_0;
265 msg->sm_type = SPANS_STAT_REQ;
266 msg->sm_stat_req.streq_es_epoch = spp->sp_h_epoch;
267 if (spans_send_msg(spp, msg)) {
268 /* Retry later if send fails */
269 SPANS_TIMER(spp, SPANS_PROBE_ERR_WAIT);
277 * Check whether we're getting an answer to our probes
279 if (spp->sp_state == SPANS_ACTIVE &&
280 spp->sp_probe_ct > SPANS_PROBE_THRESH) {
282 * Interface is down, notify VCC owners
284 spans_switch_reset(spp, SPANS_UNI_DOWN);
287 * Set new state and increment host epoch so
288 * switch knows we reset everyting.
290 spp->sp_state = SPANS_PROBE;
296 * Keep sending status requests
298 SPANS_TIMER(spp, SPANS_PROBE_INTERVAL);
304 * Try to terminate the SPANS signalling PVC
306 err = atm_cm_release(spp->sp_conn, &spans_cause);
308 log(LOG_ERR, "spans: can't close signalling channel\n");
313 log(LOG_ERR, "spans: timer state: spp=%p, state=%d\n",
320 * Process a SPANS VCC timeout
322 * Called when a previously scheduled SPANS VCCB timer expires.
323 * Processing will based on the current VCC state.
328 * tip pointer to vccb timer control block
336 struct atm_time *tip;
340 struct spans_vccb *svp;
343 * Get VCCB and SPANS control block addresses
345 svp = (struct spans_vccb *) ((caddr_t)tip -
346 (int)(&((struct vccb *)0)->vc_time));
347 spp = (struct spans *)svp->sv_pif->pif_siginst;
349 ATM_DEBUG3("spans_vctimer: svp=%p, sstate=%d, ustate=%d\n",
350 svp, svp->sv_sstate, svp->sv_ustate);
353 * Process timeout based on protocol state
355 switch (svp->sv_sstate) {
359 * Kill the VCCB and notify the owner
361 err = spans_clear_vcc(spp, svp);
368 svp->sv_ustate = VCCU_CLOSED;
369 svp->sv_sstate = SPANS_VC_FREE;
370 spans_free((struct vccb *)svp);
375 * Issued open request, but didn't get response.
377 if (svp->sv_retry < SV_MAX_RETRY) {
379 * Retransmit the open request
381 err = spans_send_open_req(spp, svp);
383 SPANS_VC_TIMER((struct vccb *) svp, SV_TIMEOUT);
386 * Retry limit exceeded--report the open failed
388 svp->sv_ustate = VCCU_CLOSED;
389 svp->sv_sstate = SPANS_VC_FREE;
390 svp->sv_connvc->cvc_attr.cause.tag =
392 svp->sv_connvc->cvc_attr.cause.v.coding_standard =
394 svp->sv_connvc->cvc_attr.cause.v.location =
396 svp->sv_connvc->cvc_attr.cause.v.cause_value =
397 T_ATM_CAUSE_NO_USER_RESPONDING;
398 KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics,
399 sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics));
400 atm_cm_cleared(svp->sv_connvc);
406 * Issued close request, but didn't get response.
408 if (svp->sv_retry < SV_MAX_RETRY) {
410 * Retransmit the close request
412 err = spans_send_close_req(spp, svp);
414 SPANS_VC_TIMER((struct vccb *) svp, SV_TIMEOUT);
417 * Retry limit exceeded--just finish the close
419 svp->sv_sstate = SPANS_VC_FREE;
420 svp->sv_connvc->cvc_attr.cause.tag = T_ATM_PRESENT;
421 svp->sv_connvc->cvc_attr.cause.v.coding_standard =
423 svp->sv_connvc->cvc_attr.cause.v.location =
425 svp->sv_connvc->cvc_attr.cause.v.cause_value =
426 T_ATM_CAUSE_NO_USER_RESPONDING;
427 KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics,
428 sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics));
429 atm_cm_cleared(svp->sv_connvc);
433 case SPANS_VC_ACTIVE:
434 case SPANS_VC_ACT_DOWN:
438 log(LOG_ERR, "spans_vctimer: unexpected state %d\n",
443 log(LOG_ERR, "spans: vctimer state: svp=%p, sstate=%d\n",
444 svp, svp->sv_sstate);
453 * tok SPANS signalling channel token (ignored)
456 * pointer to a string identifying the SPANS signalling manager
468 * Process a VCC connection notification
470 * Should never be called
473 * tok user's connection token (SPANS protocol block)
483 struct spans *spp = (struct spans *)tok;
485 ATM_DEBUG2("spans_connected: spp=%p,state=%d\n",
489 * Connected routine shouldn't ever get called for a PVC
491 log(LOG_ERR, "spans: connected function called, tok=%p\n", spp);
496 * Process a VCC close notification
498 * Called when the SPANS signalling channel is closed
501 * tok user's connection token (spans protocol block)
502 * cp pointer to cause structure
509 spans_cleared(tok, cp)
511 struct t_atm_cause *cp;
513 struct spans *spp = (struct spans *)tok;
516 * VCC has been closed.
518 log(LOG_ERR, "spans: signalling channel closed\n");
525 * SPANS CPCS data handler
527 * This is the module which receives data on the SPANS signalling
528 * channel. Processing is based on the indication received from the
529 * AAL and the protocol state.
532 * tok session token (pointer to spans protocol control block)
533 * m pointer to buffer with data
540 spans_cpcs_data(tok, m)
544 struct spans *spp = tok;
546 ATM_DEBUG3("spans_cpcs_data: spp=%p,state=%d,m=%p,\n",
547 spp, spp->sp_state, m);
552 spans_rcv_msg(spp, m);