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 $
31 * SPANS Signalling Manager
32 * ---------------------------
34 * SPANS protocol processing module.
38 #include <netatm/kern_include.h>
40 #include "spans_xdr.h"
41 #include <netatm/spans/spans_var.h>
44 __RCSID("@(#) $FreeBSD: src/sys/netatm/spans/spans_proto.c,v 1.4 1999/08/28 00:48:51 peter Exp $");
50 caddr_t spans_getname __P((void *));
51 void spans_connected __P((void *));
52 void spans_cleared __P((void *, struct t_atm_cause *));
53 void spans_cpcs_data __P((void *, KBuffer *));
57 * ATM endpoint for SPANS signalling channel
59 static Atm_endpoint spans_endpt = {
61 ENDPT_SPANS_SIG, /* ep_id */
63 spans_getname, /* ep_getname */
64 spans_connected, /* ep_connected */
65 spans_cleared, /* ep_cleared */
66 NULL, /* ep_incoming */
67 NULL, /* ep_addparty */
68 NULL, /* ep_dropparty */
69 NULL, /* ep_cpcs_ctl */
70 spans_cpcs_data, /* ep_cpcs_data */
71 NULL, /* ep_saal_ctl */
72 NULL, /* ep_saal_data */
73 NULL, /* ep_sscop_ctl */
74 NULL /* ep_sscop_data */
79 * ATM connection attributes for UNI signalling channel
81 static Atm_attributes spans_attr = {
88 T_ATM_PRESENT, /* aal.tag */
89 ATM_AAL3_4 /* aal.aal_type */
92 T_ATM_PRESENT, /* traffic.tag */
94 { /* traffic.v.forward */
95 T_ATM_ABSENT, /* PCR_high */
97 T_ATM_ABSENT, /* SCR_high */
98 T_ATM_ABSENT, /* SCR_all */
99 T_ATM_ABSENT, /* MBS_high */
100 T_ATM_ABSENT, /* MBS_all */
103 { /* traffic.v.backward */
104 T_ATM_ABSENT, /* PCR_high */
106 T_ATM_ABSENT, /* SCR_high */
107 T_ATM_ABSENT, /* SCR_all */
108 T_ATM_ABSENT, /* MBS_high */
109 T_ATM_ABSENT, /* MBS_all */
112 T_YES, /* best_effort */
116 T_ATM_PRESENT, /* bearer.tag */
118 T_ATM_CLASS_X, /* class */
119 T_ATM_NULL, /* traffic_type */
120 T_ATM_NO_END_TO_END, /* timing_req */
122 T_ATM_1_TO_1, /* conn_conf */
126 T_ATM_ABSENT, /* bhli.tag */
129 T_ATM_ABSENT, /* blli.tag_l2 */
130 T_ATM_ABSENT, /* blli.tag_l3 */
133 T_ATM_ABSENT, /* llc.tag */
136 T_ATM_PRESENT, /* called.tag */
139 T_ATM_ABSENT, /* calling.tag */
142 T_ATM_PRESENT, /* qos.tag */
144 T_ATM_NETWORK_CODING, /* coding_standard */
145 { /* qos.v.forward */
146 T_ATM_QOS_CLASS_0, /* class */
148 { /* qos.v.backward */
149 T_ATM_QOS_CLASS_0, /* class */
154 T_ATM_ABSENT, /* transit.tag */
157 T_ATM_ABSENT, /* cause.tag */
163 * SPANS cause structre
165 struct t_atm_cause spans_cause = {
166 T_ATM_ITU_CODING, /* coding_standard */
167 T_ATM_LOC_USER, /* location */
168 T_ATM_CAUSE_UNSPECIFIED_NORMAL, /* cause_value */
169 { 0, 0, 0, 0 } /* diagnostics */
174 * Process a SPANS timeout
176 * Called when a previously scheduled spans control block timer expires.
177 * Processing will based on the current SPANS state.
182 * tip pointer to spans timer control block
190 struct atm_time *tip;
198 * Back-off to SPANS control block
200 spp = (struct spans *)
201 ((caddr_t)tip - (int)(&((struct spans *)0)->sp_time));
203 ATM_DEBUG2("spans_timer: spp=%p,state=%d\n",
207 * Process timeout based on protocol state
209 switch (spp->sp_state) {
214 * Open signalling channel
216 spans_attr.nif = spp->sp_pif->pif_nif;
218 spans_attr.aal.v.aal4.forward_max_SDU_size =
220 spans_attr.aal.v.aal4.backward_max_SDU_size =
222 spans_attr.aal.v.aal4.SSCS_type =
223 T_ATM_SSCS_SSCOP_UNREL;
224 spans_attr.aal.v.aal4.mid_low = 0;
225 spans_attr.aal.v.aal4.mid_high = 0;
227 spans_attr.called.tag = T_ATM_PRESENT;
228 spans_attr.called.addr.address_format = T_ATM_PVC_ADDR;
229 spans_attr.called.addr.address_length =
230 sizeof(Atm_addr_pvc);
231 pvcp = (Atm_addr_pvc *)spans_attr.called.addr.address;
232 ATM_PVC_SET_VPI(pvcp, SPANS_SIG_VPI);
233 ATM_PVC_SET_VCI(pvcp, SPANS_SIG_VCI);
234 spans_attr.called.subaddr.address_format = T_ATM_ABSENT;
235 spans_attr.called.subaddr.address_length = 0;
237 spans_attr.traffic.v.forward.PCR_all_traffic =
238 spp->sp_pif->pif_pcr;
239 spans_attr.traffic.v.backward.PCR_all_traffic =
240 spp->sp_pif->pif_pcr;
242 err = atm_cm_connect(&spans_endpt, spp, &spans_attr,
245 log(LOG_CRIT, "spans: signalling channel setup failed\n");
250 * Signalling channel open, start probing
252 spp->sp_state = SPANS_PROBE;
260 * Send out SPANS_STAT_REQ message
262 msg = (spans_msg *)atm_allocate(&spans_msgpool);
264 /* Retry later if no memory */
265 SPANS_TIMER(spp, SPANS_PROBE_ERR_WAIT);
268 msg->sm_vers = SPANS_VERS_1_0;
269 msg->sm_type = SPANS_STAT_REQ;
270 msg->sm_stat_req.streq_es_epoch = spp->sp_h_epoch;
271 if (spans_send_msg(spp, msg)) {
272 /* Retry later if send fails */
273 SPANS_TIMER(spp, SPANS_PROBE_ERR_WAIT);
281 * Check whether we're getting an answer to our probes
283 if (spp->sp_state == SPANS_ACTIVE &&
284 spp->sp_probe_ct > SPANS_PROBE_THRESH) {
286 * Interface is down, notify VCC owners
288 spans_switch_reset(spp, SPANS_UNI_DOWN);
291 * Set new state and increment host epoch so
292 * switch knows we reset everyting.
294 spp->sp_state = SPANS_PROBE;
300 * Keep sending status requests
302 SPANS_TIMER(spp, SPANS_PROBE_INTERVAL);
308 * Try to terminate the SPANS signalling PVC
310 err = atm_cm_release(spp->sp_conn, &spans_cause);
312 log(LOG_ERR, "spans: can't close signalling channel\n");
317 log(LOG_ERR, "spans: timer state: spp=%p, state=%d\n",
324 * Process a SPANS VCC timeout
326 * Called when a previously scheduled SPANS VCCB timer expires.
327 * Processing will based on the current VCC state.
332 * tip pointer to vccb timer control block
340 struct atm_time *tip;
344 struct spans_vccb *svp;
347 * Get VCCB and SPANS control block addresses
349 svp = (struct spans_vccb *) ((caddr_t)tip -
350 (int)(&((struct vccb *)0)->vc_time));
351 spp = (struct spans *)svp->sv_pif->pif_siginst;
353 ATM_DEBUG3("spans_vctimer: svp=%p, sstate=%d, ustate=%d\n",
354 svp, svp->sv_sstate, svp->sv_ustate);
357 * Process timeout based on protocol state
359 switch (svp->sv_sstate) {
363 * Kill the VCCB and notify the owner
365 err = spans_clear_vcc(spp, svp);
372 svp->sv_ustate = VCCU_CLOSED;
373 svp->sv_sstate = SPANS_VC_FREE;
374 spans_free((struct vccb *)svp);
379 * Issued open request, but didn't get response.
381 if (svp->sv_retry < SV_MAX_RETRY) {
383 * Retransmit the open request
385 err = spans_send_open_req(spp, svp);
387 SPANS_VC_TIMER((struct vccb *) svp, SV_TIMEOUT);
390 * Retry limit exceeded--report the open failed
392 svp->sv_ustate = VCCU_CLOSED;
393 svp->sv_sstate = SPANS_VC_FREE;
394 svp->sv_connvc->cvc_attr.cause.tag =
396 svp->sv_connvc->cvc_attr.cause.v.coding_standard =
398 svp->sv_connvc->cvc_attr.cause.v.location =
400 svp->sv_connvc->cvc_attr.cause.v.cause_value =
401 T_ATM_CAUSE_NO_USER_RESPONDING;
402 KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics,
403 sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics));
404 atm_cm_cleared(svp->sv_connvc);
410 * Issued close request, but didn't get response.
412 if (svp->sv_retry < SV_MAX_RETRY) {
414 * Retransmit the close request
416 err = spans_send_close_req(spp, svp);
418 SPANS_VC_TIMER((struct vccb *) svp, SV_TIMEOUT);
421 * Retry limit exceeded--just finish the close
423 svp->sv_sstate = SPANS_VC_FREE;
424 svp->sv_connvc->cvc_attr.cause.tag = T_ATM_PRESENT;
425 svp->sv_connvc->cvc_attr.cause.v.coding_standard =
427 svp->sv_connvc->cvc_attr.cause.v.location =
429 svp->sv_connvc->cvc_attr.cause.v.cause_value =
430 T_ATM_CAUSE_NO_USER_RESPONDING;
431 KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics,
432 sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics));
433 atm_cm_cleared(svp->sv_connvc);
437 case SPANS_VC_ACTIVE:
438 case SPANS_VC_ACT_DOWN:
442 log(LOG_ERR, "spans_vctimer: unexpected state %d\n",
447 log(LOG_ERR, "spans: vctimer state: svp=%p, sstate=%d\n",
448 svp, svp->sv_sstate);
457 * tok SPANS signalling channel token (ignored)
460 * pointer to a string identifying the SPANS signalling manager
472 * Process a VCC connection notification
474 * Should never be called
477 * tok user's connection token (SPANS protocol block)
487 struct spans *spp = (struct spans *)tok;
489 ATM_DEBUG2("spans_connected: spp=%p,state=%d\n",
493 * Connected routine shouldn't ever get called for a PVC
495 log(LOG_ERR, "spans: connected function called, tok=%p\n", spp);
500 * Process a VCC close notification
502 * Called when the SPANS signalling channel is closed
505 * tok user's connection token (spans protocol block)
506 * cp pointer to cause structure
513 spans_cleared(tok, cp)
515 struct t_atm_cause *cp;
517 struct spans *spp = (struct spans *)tok;
520 * VCC has been closed.
522 log(LOG_ERR, "spans: signalling channel closed\n");
529 * SPANS CPCS data handler
531 * This is the module which receives data on the SPANS signalling
532 * channel. Processing is based on the indication received from the
533 * AAL and the protocol state.
536 * tok session token (pointer to spans protocol control block)
537 * m pointer to buffer with data
544 spans_cpcs_data(tok, m)
548 struct spans *spp = tok;
550 ATM_DEBUG3("spans_cpcs_data: spp=%p,state=%d,m=%p,\n",
551 spp, spp->sp_state, m);
556 spans_rcv_msg(spp, m);