?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bring in a transport-independent RPC (TI-RPC).
[dragonfly.git] / sys / netproto / atm / spans / spans_msg.c
blob1f8993537574eb30d5d1878758b9a740070de83e
1 /*
2 *
3 * ===================================
4 * HARP | Host ATM Research Platform
5 * ===================================
6 *
7 *
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.
12 *
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.
20 *
21 * Copyright 1994-1998 Network Computing Services, Inc.
22 *
23 * Copies of this Software may be made, however, the above copyright
24 * notice must be reproduced on all copies.
25 *
26 * @(#) $FreeBSD: src/sys/netatm/spans/spans_msg.c,v 1.5 1999/08/28 00:48:50 peter Exp $
27 * @(#) $DragonFly: src/sys/netproto/atm/spans/spans_msg.c,v 1.7 2006/12/22 23:57:54 swildner Exp $
28 */
29
30 /*
31 * SPANS Signalling Manager
32 * ---------------------------
33 *
34 * SPANS signalling message processing.
35 *
36 */
37
38 #include <netproto/atm/kern_include.h>
39
40 #include "spans_xdr.h"
41 #include "spans_var.h"
42
43 /*
44 * External functions
45 */
46 void xdrmbuf_init (XDR *, KBuffer *, enum xdr_op);
47
48 /*
49 * Local functions
50 */
51 static void spans_host_link (struct spans *, long);
52 static void spans_status_ind (struct spans *, spans_msg *);
53 static void spans_status_rsp (struct spans *, spans_msg *);
54 static void spans_open_req (struct spans *, spans_msg *);
55 static void spans_open_rsp (struct spans *, spans_msg *);
56 static void spans_close_req (struct spans *, spans_msg *);
57 static void spans_close_rsp (struct spans *, spans_msg *);
58 static void spans_multi_req (struct spans *, spans_msg *);
59 static void spans_add_req (struct spans *, spans_msg *);
60 static void spans_join_req (struct spans *, spans_msg *);
61 static void spans_leave_req (struct spans *, spans_msg *);
62 static void spans_vcir_ind (struct spans *, spans_msg *);
63 static void spans_query_req (struct spans *, spans_msg *);
64
65
66 /*
67 * Called to set status when a status message comes in from a host
68 * connected back-to-back with us. Check the epoch and, if it has
69 * changed, set the appropriate state and save updated state
70 * information.
71 *
72 * Arguments:
73 * spp pointer to SPANS protocol instance block
74 * host_epoch epoch of host at far end of link
75 *
76 * Returns:
77 * 0 message sent OK
78 * errno error encountered
79 *
80 */
81 static void
82 spans_host_link(struct spans *spp, long host_epoch)
83 {
84 struct atm_pif *pip = spp->sp_pif;
85
86 /*
87 * There's a host at the other end of the link. If its
88 * epoch has changed, clean up our state and save the
89 * new information.
90 */
91 if (spp->sp_s_epoch != host_epoch) {
92 spp->sp_s_epoch = host_epoch;
93 spans_switch_reset(spp, SPANS_UNI_UP);
94 spp->sp_addr.address_format = T_ATM_SPANS_ADDR;
95 spp->sp_addr.address_length = sizeof(spans_addr);
96 KM_COPY(&pip->pif_macaddr.ma_data[2],
97 &spp->sp_addr.address[4],
98 4);
99 log(LOG_INFO,
100 "spans: using SPANS address of %s on interface %s%d\n",
101 spans_addr_print((spans_addr *)spp->sp_addr.address),
102 pip->pif_name,
103 pip->pif_unit);
104 }
105 }
106
107 /*
108 * Send a SPANS signalling message
109 *
110 * Called to send a SPANS message. This routine gets a buffer, performs
111 * XDR processing, and hands the message to the AAL for transmission.
112 *
113 * Arguments:
114 * spp pointer to SPANS protocol instance block
115 * msg pointer to status message
116 *
117 * Returns:
118 * 0 message sent OK
119 * errno error encountered
120 *
121 */
122 int
123 spans_send_msg(struct spans *spp, spans_msg *msg)
124 {
125 int err = 0;
126 KBuffer *m;
127 XDR xdrs;
128
129 #ifdef NOTDEF
130 ATM_DEBUG2("spans_send_msg: msg=%p, type=%d\n", msg,
131 msg->sm_type);
132 if (msg->sm_type != SPANS_STAT_REQ &&
133 msg->sm_type != SPANS_STAT_IND &&
134 msg->sm_type != SPANS_STAT_RSP) {
135 kprintf("spans_send_msg: sending ");
136 spans_print_msg(msg);
137 }
138 #endif
139
140 /*
141 * If the signalling channel has been closed, don't do anything
142 */
143 if (!spp->sp_conn)
144 return(ECONNABORTED);
145
146 /*
147 * Get a buffer
148 */
149 KB_ALLOCPKT(m, sizeof(spans_msg), KB_F_NOWAIT, KB_T_DATA);
150 if (m == NULL) {
151 /* No buffer available */
152 return(ENOBUFS);
153 }
154
155 /*
156 * Convert message to network order
157 */
158 KB_LEN(m) = KB_BFRLEN(m);
159 xdrmbuf_init(&xdrs, m, XDR_ENCODE);
160 if (!xdr_spans_msg(&xdrs, msg)) {
161 log(LOG_ERR, "spans_send_msg: XDR encode failed\n");
162 KB_LEN(m) = XDR_GETPOS(&xdrs);
163 spans_dump_buffer(m);
164 KB_FREEALL(m);
165 return(EIO);
166 }
167 KB_LEN(m) = XDR_GETPOS(&xdrs);
168
169 /*
170 * Send the message
171 */
172 err = atm_cm_cpcs_data(spp->sp_conn, m);
173 if (err)
174 KB_FREEALL(m);
175
176 return(err);
177 }
178
179
180 /*
181 * Send an open request
182 *
183 * Build and send an open request.
184 *
185 * Arguments:
186 * spp pointer to SPANS protocol instance block
187 * svp pointer to VCCB for which the request is being sent
188 *
189 * Returns:
190 * none
191 *
192 */
193 int
194 spans_send_open_req(struct spans *spp, struct spans_vccb *svp)
195 {
196 spans_msg *req;
197 int err = 0;
198
199 ATM_DEBUG1("spans_send_open_req: svp=%p\n", svp);
200
201 /*
202 * Get memory for a request message
203 */
204 req = (spans_msg *)atm_allocate(&spans_msgpool);
205 if (req == NULL) {
206 err = ENOBUFS;
207 goto done;
208 }
209
210 /*
211 * Fill in the request
212 */
213 req->sm_vers = SPANS_VERS_1_0;
214 req->sm_type = SPANS_OPEN_REQ;
215 req->sm_open_req.opreq_conn = svp->sv_conn;
216 req->sm_open_req.opreq_aal = svp->sv_spans_aal;
217 req->sm_open_req.opreq_desrsrc = svp->sv_spans_qos;
218 req->sm_open_req.opreq_minrsrc.rsc_peak = 0;
219 req->sm_open_req.opreq_minrsrc.rsc_mean = 0;
220 req->sm_open_req.opreq_minrsrc.rsc_burst = 0;
221 req->sm_open_req.opreq_vpvc.vpf_valid = FALSE;
222
223 /*
224 * Send the request
225 */
226 err = spans_send_msg(spp, req);
227 atm_free(req);
228
229 done:
230 return(err);
231 }
232
233
234 /*
235 * Send an open response
236 *
237 * Build and send a response to an open request or open indication.
238 *
239 * Arguments:
240 * spp pointer to SPANS protocol instance block
241 * svp pointer to VCCB for which the response is being sent
242 * result result code to include in the response
243 *
244 * Returns:
245 * none
246 *
247 */
248 int
249 spans_send_open_rsp(struct spans *spp, struct spans_vccb *svp,
250 spans_result result)
251 {
252 spans_msg *rsp;
253 int rc;
254
255 ATM_DEBUG2("spans_send_open_rsp: svp=%p, result=%d\n", svp,
256 result);
257
258 /*
259 * Get memory for a response message
260 */
261 rsp = (spans_msg *)atm_allocate(&spans_msgpool);
262 if (rsp == NULL)
263 return(ENOBUFS);
264
265 /*
266 * Fill in the response
267 */
268 rsp->sm_vers = SPANS_VERS_1_0;
269 rsp->sm_type = SPANS_OPEN_RSP;
270 rsp->sm_open_rsp.oprsp_conn = svp->sv_conn;
271 rsp->sm_open_rsp.oprsp_result = result;
272 rsp->sm_open_rsp.oprsp_rsrc = svp->sv_spans_qos;
273 rsp->sm_open_rsp.oprsp_vpvc =
274 SPANS_PACK_VPIVCI(svp->sv_vpi, svp->sv_vci);
275
276 /*
277 * Send the response
278 */
279 rc = spans_send_msg(spp, rsp);
280 atm_free(rsp);
281
282 return(rc);
283 }
284
285
286 /*
287 * Send a close request
288 *
289 * Called to send a close request.
290 *
291 * Arguments:
292 * spp pointer to SPANS protocol instance block
293 * svp pointer to VCCB for which the close is being sent
294 *
295 * Returns:
296 * none
297 *
298 */
299 int
300 spans_send_close_req(struct spans *spp, struct spans_vccb *svp)
301 {
302 spans_msg *req;
303 int err = 0;
304
305 ATM_DEBUG1("spans_send_close_req: svp=%p\n", svp);
306
307 /*
308 * Get memory for a close request
309 */
310 req = (spans_msg *)atm_allocate(&spans_msgpool);
311 if (req == NULL) {
312 err = ENOBUFS;
313 goto done;
314 }
315
316 /*
317 * Fill in the request
318 */
319 req->sm_vers = SPANS_VERS_1_0;
320 if (svp->sv_type & VCC_OUT) {
321 req->sm_type = SPANS_CLOSE_REQ;
322 } else if (svp->sv_type & VCC_IN) {
323 req->sm_type = SPANS_RCLOSE_REQ;
324 } else {
325 err = EINVAL;
326 ATM_DEBUG1(
327 "spans_send_close_req: invalid VCCB type 0x%x\n",
328 svp->sv_type);
329 goto done;
330 }
331 req->sm_close_req.clreq_conn = svp->sv_conn;
332
333 /*
334 * Send the close request
335 */
336 err = spans_send_msg(spp, req);
337
338 done:
339 if (req)
340 atm_free(req);
341
342 return(err);
343 }
344
345
346
347 /*
348 * Process a status indication or status request
349 *
350 * Called when a status indication or status request is received.
351 * Processing will be based on the current SPANS state.
352 *
353 * Arguments:
354 * spp pointer to SPANS protocol instance block
355 * msg pointer to the status message
356 *
357 * Returns:
358 * none
359 *
360 */
361 static void
362 spans_status_ind(struct spans *spp, spans_msg *msg)
363 {
364 spans_msg *rsp_msg;
365 struct atm_pif *pip = spp->sp_pif;
366
367 /*
368 * Reset the probe count.
369 */
370 spp->sp_probe_ct = 0;
371
372 switch (spp->sp_state) {
373 case SPANS_PROBE:
374 /*
375 * Interface just came up, update signalling state
376 */
377 spp->sp_state = SPANS_ACTIVE;
378 break;
379
380 case SPANS_ACTIVE:
381 break;
382
383 default:
384 log(LOG_ERR, "spans: received status msg in state %d\n",
385 spp->sp_state);
386 }
387
388 /*
389 * Process the message
390 */
391 switch (msg->sm_type) {
392
393 case SPANS_STAT_REQ:
394 /*
395 * Handle a request from a host at the other end of
396 * the link.
397 */
398 spans_host_link(spp, msg->sm_stat_req.streq_es_epoch);
399 break;
400
401 case SPANS_STAT_IND:
402
403 /*
404 * There's a switch at the other end of the link. If
405 * its epoch has changed, reset the SPANS state and save
406 * the new information.
407 */
408 if (spp->sp_s_epoch !=
409 msg->sm_stat_ind.stind_sw_epoch) {
410 spans_switch_reset(spp, SPANS_UNI_UP);
411 spp->sp_s_epoch =
412 msg->sm_stat_ind.stind_sw_epoch;
413 spp->sp_addr.address_format = T_ATM_SPANS_ADDR;
414 spp->sp_addr.address_length =
415 sizeof(spans_addr);
416 spans_addr_copy(&msg->sm_stat_ind.stind_es_addr,
417 spp->sp_addr.address);
418 log(LOG_INFO,
419 "spans: received SPANS address %s from switch for interface %s%d\n",
420 spans_addr_print((spans_addr *)spp->sp_addr.address),
421 pip->pif_name,
422 pip->pif_unit);
423 }
424 break;
425
426 default:
427 ATM_DEBUG1("spans_status_ind: Invalid message type %d\n",
428 msg->sm_type);
429 return;
430 }
431
432 /*
433 * Respond to the status request or indication with a
434 * status response
435 */
436 rsp_msg = (spans_msg *)atm_allocate(&spans_msgpool);
437 if (rsp_msg == NULL)
438 return;
439 rsp_msg->sm_vers = SPANS_VERS_1_0;
440 rsp_msg->sm_type = SPANS_STAT_RSP;
441 rsp_msg->sm_stat_rsp.strsp_es_epoch = spp->sp_h_epoch;
442 spans_addr_copy(spp->sp_addr.address,
443 &rsp_msg->sm_stat_rsp.strsp_es_addr);
444 spans_send_msg(spp, rsp_msg);
445 atm_free(rsp_msg);
446 }
447
448
449
450 /*
451 * Process a status response
452 *
453 * Called when a status response is received.
454 * Processing will be based on the current SPANS state.
455 *
456 * Arguments:
457 * spp pointer to SPANS protocol instance block
458 * msg pointer to the status response message
459 *
460 * Returns:
461 * none
462 *
463 */
464 static void
465 spans_status_rsp(struct spans *spp, spans_msg *msg)
466 {
467
468 /*
469 * Reset the probe count.
470 */
471 spp->sp_probe_ct = 0;
472
473 switch (spp->sp_state) {
474 case SPANS_PROBE:
475 /*
476 * Interface just came up, update signalling state
477 */
478 spp->sp_state = SPANS_ACTIVE;
479 break;
480
481 case SPANS_ACTIVE:
482 break;
483
484 default:
485 log(LOG_ERR, "spans: received status msg in state %d\n",
486 spp->sp_state);
487 }
488
489 /*
490 * Process the message
491 */
492 spans_host_link(spp, msg->sm_stat_req.streq_es_epoch);
493 }
494
495
496 /*
497 * Process an open indication or open request
498 *
499 * Called when an open indication or open request is received.
500 * Processing will be based on the state of the requested connection.
501 *
502 * Arguments:
503 * spp pointer to SPANS protocol instance block
504 * msg pointer to the open message
505 *
506 * Returns:
507 * none
508 *
509 */
510 static void
511 spans_open_req(struct spans *spp, spans_msg *msg)
512 {
513 spans_result result = SPANS_OK;
514 spans_msg *rsp_msg;
515 struct spans_vccb *svp = NULL;
516 struct atm_pif *pip;
517 spans_vpvc vpvc;
518 int err = 0, vpi, vci;
519 Aal_t aal;
520 Atm_attributes call_attrs;
521
522 ATM_DEBUG2("spans_open_req: spp=%p, msg=%p\n", spp, msg);
523
524 /*
525 * See if the connection is new
526 */
527 if ((svp = spans_find_conn(spp, &msg->sm_open_req.opreq_conn)) != NULL) {
528 /*
529 * We already have a VCCB that matches the connection in
530 * the request
531 */
532 vpi = SPANS_EXTRACT_VPI(msg->sm_open_req.opreq_vpvc.vpf_vpvc);
533 vci = SPANS_EXTRACT_VCI(msg->sm_open_req.opreq_vpvc.vpf_vpvc);
534 if (msg->sm_open_req.opreq_aal == svp->sv_spans_aal &&
535 (!msg->sm_open_req.opreq_vpvc.vpf_valid ||
536 (vpi == svp->sv_vpi &&
537 vci == svp->sv_vci))) {
538 /*
539 * VCCB already exists, process depending on
540 * state
541 */
542 switch (svp->sv_sstate) {
543 case SPANS_VC_R_POPEN:
544 /* I'm still thinking about it */
545 return;
546 case SPANS_VC_OPEN:
547 /* Retransmit the open_rsp */
548 break;
549 case SPANS_VC_POPEN:
550 case SPANS_VC_CLOSE:
551 case SPANS_VC_ABORT:
552 ATM_DEBUG0("spans_open_req: bad VCCB state\n");
553 result = SPANS_FAIL;
554 break;
555 }
556 } else {
557 /*
558 * VCCB is for same connection, but other
559 * parameters don't match
560 */
561 ATM_DEBUG0("spans_open_req: VCCB confusion\n");
562 result = SPANS_FAIL;
563 }
564 svp = NULL;
565 goto response;
566 }
567
568 /*
569 * Verify that the request is for our ATM addres
570 */
571 if (spans_addr_cmp(spp->sp_addr.address,
572 &msg->sm_open_req.opreq_conn.con_dst)) {
573 ATM_DEBUG0("spans_open_req: bad destination\n");
574 result = SPANS_BADDEST;
575 goto response;
576 }
577
578 /*
579 * See if we recognize the specified AAL
580 */
581 if (!spans_get_local_aal(msg->sm_open_req.opreq_aal, &aal)) {
582 ATM_DEBUG0("spans_open_req: bad AAL\n");
583 result = SPANS_FAIL;
584 goto response;
585 }
586
587 /*
588 * Should verify that we can handle requested connection QOS
589 */
590
591 /*
592 * Select a VPI/VCI for the new connection
593 */
594 if (msg->sm_open_req.opreq_vpvc.vpf_valid) {
595 /*
596 * Requestor asked for a certain VPI/VCI. Make sure we
597 * aren't already using the pair that was asked for.
598 */
599 vpi = SPANS_EXTRACT_VPI(msg->sm_open_req.opreq_vpvc.vpf_vpvc);
600 vci = SPANS_EXTRACT_VCI(msg->sm_open_req.opreq_vpvc.vpf_vpvc);
601 if (spans_find_vpvc(spp, vci, vpi, VCC_IN)) {
602 ATM_DEBUG0("spans_open_req: VPI, VCI busy\n");
603 result = SPANS_NOVPVC;
604 goto response;
605 }
606 vpvc = msg->sm_open_req.opreq_vpvc.vpf_vpvc;
607 } else {
608 /*
609 * Allocate a VPI/VCI for this end of the VCC
610 */
611 vpvc = spans_alloc_vpvc(spp);
612 if (vpvc == 0) {
613 ATM_DEBUG0("spans_open_req: no VPI, VCI available\n");
614 result = SPANS_NOVPVC;
615 goto response;
616 }
617 }
618
619 /*
620 * Get a new VCCB for the connection
621 */
622 svp = (struct spans_vccb *)atm_allocate(&spans_vcpool);
623 if (svp == NULL) {
624 ATM_DEBUG0("spans_open_req: VCCB pool empty\n");
625 result = SPANS_NORSC;
626 goto response;
627 }
628
629 /*
630 * Find the physical interface structure
631 */
632 pip = spp->sp_pif;
633
634 /*
635 * Fill in the VCCB fields that we can at this point
636 */
637 svp->sv_type = VCC_SVC | VCC_IN;
638 svp->sv_proto = ATM_SIG_SPANS;
639 svp->sv_sstate = SPANS_VC_R_POPEN;
640 svp->sv_ustate = VCCU_POPEN;
641 svp->sv_pif = pip;
642 svp->sv_nif = pip->pif_nif;
643 svp->sv_conn = msg->sm_open_req.opreq_conn;
644 svp->sv_spans_qos = msg->sm_open_req.opreq_desrsrc;
645 svp->sv_spans_aal = msg->sm_open_req.opreq_aal;
646 svp->sv_tstamp = time_second;
647
648 svp->sv_vpi = SPANS_EXTRACT_VPI(vpvc);
649 svp->sv_vci = SPANS_EXTRACT_VCI(vpvc);
650
651 /*
652 * Put the VCCB on the SPANS queue
653 */
654 ENQUEUE(svp, struct spans_vccb, sv_sigelem, spp->sp_vccq);
655
656 /*
657 * Set up the ATM attributes block
658 */
659 KM_ZERO(&call_attrs, sizeof(call_attrs));
660 call_attrs.nif = svp->sv_nif;
661 call_attrs.api = CMAPI_CPCS;
662
663 call_attrs.aal.tag = T_ATM_PRESENT;
664 call_attrs.aal.type = aal;
665 switch(aal) {
666 case ATM_AAL3_4:
667 call_attrs.aal.v.aal4.forward_max_SDU_size =
668 ATM_NIF_MTU;
669 call_attrs.aal.v.aal4.backward_max_SDU_size =
670 ATM_NIF_MTU;
671 call_attrs.aal.v.aal4.SSCS_type =
672 T_ATM_NULL;
673 call_attrs.aal.v.aal4.mid_low = 0;
674 call_attrs.aal.v.aal4.mid_high = 1023;
675 break;
676 case ATM_AAL5:
677 call_attrs.aal.v.aal5.forward_max_SDU_size =
678 ATM_NIF_MTU;
679 call_attrs.aal.v.aal5.backward_max_SDU_size =
680 ATM_NIF_MTU;
681 call_attrs.aal.v.aal5.SSCS_type =
682 T_ATM_NULL;
683 break;
684 }
685
686 call_attrs.traffic.tag = T_ATM_PRESENT;
687 call_attrs.traffic.v.forward.PCR_high_priority = T_ATM_ABSENT;
688 call_attrs.traffic.v.forward.PCR_all_traffic =
689 msg->sm_open_req.opreq_desrsrc.rsc_peak *
690 1000 / 53;
691 call_attrs.traffic.v.forward.SCR_high_priority = T_ATM_ABSENT;
692 call_attrs.traffic.v.forward.SCR_all_traffic = T_ATM_ABSENT;
693 call_attrs.traffic.v.forward.MBS_high_priority = T_ATM_ABSENT;
694 call_attrs.traffic.v.forward.MBS_all_traffic = T_ATM_ABSENT;
695 call_attrs.traffic.v.forward.tagging = T_NO;
696 call_attrs.traffic.v.backward.PCR_high_priority = T_ATM_ABSENT;
697 call_attrs.traffic.v.backward.PCR_all_traffic =
698 call_attrs.traffic.v.forward.PCR_all_traffic;
699 call_attrs.traffic.v.backward.SCR_high_priority = T_ATM_ABSENT;
700 call_attrs.traffic.v.backward.SCR_all_traffic = T_ATM_ABSENT;
701 call_attrs.traffic.v.backward.MBS_high_priority = T_ATM_ABSENT;
702 call_attrs.traffic.v.backward.MBS_all_traffic = T_ATM_ABSENT;
703 call_attrs.traffic.v.backward.tagging = T_NO;
704 call_attrs.traffic.v.best_effort = T_YES;
705
706 call_attrs.bearer.tag = T_ATM_PRESENT;
707 call_attrs.bearer.v.bearer_class = T_ATM_CLASS_X;
708 call_attrs.bearer.v.traffic_type = T_ATM_NULL;
709 call_attrs.bearer.v.timing_requirements = T_ATM_NULL;
710 call_attrs.bearer.v.clipping_susceptibility = T_NO;
711 call_attrs.bearer.v.connection_configuration = T_ATM_1_TO_1;
712
713
714 call_attrs.bhli.tag = T_ATM_ABSENT;
715 call_attrs.blli.tag_l2 = T_ATM_ABSENT;
716 call_attrs.blli.tag_l3 = T_ATM_ABSENT;
717 call_attrs.llc.tag = T_ATM_ABSENT;
718
719 call_attrs.called.tag = T_ATM_PRESENT;
720 spans_addr_copy(&msg->sm_open_req.opreq_conn.con_dst,
721 call_attrs.called.addr.address);
722 call_attrs.called.addr.address_format = T_ATM_SPANS_ADDR;
723 call_attrs.called.addr.address_length = sizeof(spans_addr);
724 call_attrs.called.subaddr.address_format = T_ATM_ABSENT;
725 call_attrs.called.subaddr.address_length = 0;
726
727 call_attrs.calling.tag = T_ATM_PRESENT;
728 spans_addr_copy(&msg->sm_open_req.opreq_conn.con_src,
729 call_attrs.calling.addr.address);
730 call_attrs.calling.addr.address_format = T_ATM_SPANS_ADDR;
731 call_attrs.calling.addr.address_length = sizeof(spans_addr);
732 call_attrs.calling.subaddr.address_format = T_ATM_ABSENT;
733 call_attrs.calling.subaddr.address_length = 0;
734
735 call_attrs.qos.tag = T_ATM_PRESENT;
736 call_attrs.qos.v.coding_standard = T_ATM_NETWORK_CODING;
737 call_attrs.qos.v.forward.qos_class = T_ATM_QOS_CLASS_0;
738 call_attrs.qos.v.backward.qos_class = T_ATM_QOS_CLASS_0;
739
740 call_attrs.transit.tag = T_ATM_ABSENT;
741 call_attrs.cause.tag = T_ATM_ABSENT;
742
743 /*
744 * Notify the connection manager that it has a new channel
745 */
746 err = atm_cm_incoming((struct vccb *)svp, &call_attrs);
747 if (err) {
748 ATM_DEBUG0("spans_open_req: atm_cm_incoming returned error\n");
749 result = SPANS_FAIL;
750 goto response;
751 }
752
753 /*
754 * Wait for the connection recipient to issue an accept
755 */
756 return;
757
758 response:
759 /*
760 * Clean up the VCCB and the atm_conn block if we got them
761 */
762 if (svp) {
763 DEQUEUE(svp, struct spans_vccb, sv_sigelem,
764 spp->sp_vccq);
765 atm_free(svp);
766 }
767
768 /*
769 * Some problem was detected with the request. Send a SPANS
770 * message rejecting the connection.
771 */
772 rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool);
773 if (rsp_msg == NULL)
774 return;
775
776 /*
777 * Fill out the response
778 */
779 rsp_msg->sm_vers = SPANS_VERS_1_0;
780 rsp_msg->sm_type = SPANS_OPEN_RSP;
781 rsp_msg->sm_open_rsp.oprsp_conn = msg->sm_open_req.opreq_conn;
782 rsp_msg->sm_open_rsp.oprsp_result = result;
783 rsp_msg->sm_open_rsp.oprsp_vpvc = 0;
784
785 /*
786 * Send the Open Response
787 */
788 spans_send_msg(spp, rsp_msg);
789 atm_free(rsp_msg);
790 }
791
792
793 /*
794 * Process an open response or open confirmation
795 *
796 * Called when an open response or open confirmation is received.
797 * Processing will be based on the state of the requested connection and
798 * the status returned.
799 *
800 * Arguments:
801 * spp pointer to SPANS protocol instance block
802 * msg pointer to the open response or confirmation message
803 *
804 * Returns:
805 * none
806 *
807 */
808 static void
809 spans_open_rsp(struct spans *spp, spans_msg *msg)
810 {
811 struct spans_vccb *svp;
812
813 ATM_DEBUG2("spans_open_rsp: spp=%p, msg=%p\n", spp, msg);
814
815 /*
816 * Locate the VCCB for the connection
817 */
818 svp = spans_find_conn(spp, &msg->sm_open_rsp.oprsp_conn);
819 if (svp == NULL)
820 return;
821
822 /*
823 * Check the connection state
824 */
825 if ((svp->sv_sstate != SPANS_VC_POPEN &&
826 svp->sv_sstate != SPANS_VC_R_POPEN) ||
827 svp->sv_ustate != VCCU_POPEN) {
828 ATM_DEBUG2(
829 "spans_open_rsp: invalid VCCB state, sstate=%d, ustate=%d\n",
830 svp->sv_sstate, svp->sv_ustate);
831 return;
832 }
833
834 /*
835 * Cancel the retransmission timer
836 */
837 SPANS_VC_CANCEL((struct vccb *) svp);
838
839 /*
840 * Check the result
841 */
842 switch (msg->sm_open_rsp.oprsp_result) {
843
844 case SPANS_OK:
845 /*
846 * Save the assigned VPI and VCI
847 */
848 svp->sv_vpi = SPANS_EXTRACT_VPI(msg->sm_open_rsp.oprsp_vpvc);
849 svp->sv_vci = SPANS_EXTRACT_VCI(msg->sm_open_rsp.oprsp_vpvc);
850
851 /*
852 * Update the VCC state and notify the VCC owner
853 */
854 svp->sv_sstate = SPANS_VC_OPEN;
855 svp->sv_ustate = VCCU_OPEN;
856 svp->sv_tstamp = time_second;
857 atm_cm_connected(svp->sv_connvc);
858 break;
859
860 case SPANS_FAIL:
861 case SPANS_NOVPVC:
862 case SPANS_NORSC:
863 case SPANS_BADDEST:
864 /*
865 * Close out the VCCB and notify the user
866 */
867 svp->sv_sstate = SPANS_VC_FREE;
868 svp->sv_ustate = VCCU_CLOSED;
869 svp->sv_connvc->cvc_attr.cause.tag = T_ATM_PRESENT;
870 svp->sv_connvc->cvc_attr.cause.v.coding_standard =
871 T_ATM_ITU_CODING;
872 svp->sv_connvc->cvc_attr.cause.v.location =
873 T_ATM_LOC_USER;
874 svp->sv_connvc->cvc_attr.cause.v.cause_value =
875 T_ATM_CAUSE_CALL_REJECTED;
876 KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics,
877 sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics));
878 atm_cm_cleared(svp->sv_connvc);
879 break;
880
881 default:
882 log(LOG_ERR, "spans: unknown result %d in open rsp\n",
883 msg->sm_open_rsp.oprsp_result);
884 break;
885 }
886 }
887
888
889 /*
890 * Process a close request from the network
891 *
892 * Called when a close request, close indication, rclose request, or
893 * rclose indication is received. Processing will be based on the
894 * state of the connection.
895 *
896 * Arguments:
897 * spp pointer to SPANS protocol instance block
898 * msg pointer to the close request message
899 *
900 * Returns:
901 * none
902 *
903 */
904 static void
905 spans_close_req(struct spans *spp, spans_msg *msg)
906 {
907 struct spans_vccb *svp;
908 spans_result result;
909 spans_msg *rsp_msg;
910 u_char outstate;
911 Atm_connvc *cvp;
912
913 ATM_DEBUG2("spans_close_req: spp=%p, msg=%p\n", spp, msg);
914
915 /*
916 * Locate the VCCB for the connection
917 */
918 svp = spans_find_conn(spp, &msg->sm_close_req.clreq_conn);
919 if (svp == NULL) {
920 result = SPANS_BADDEST;
921 goto response;
922 }
923
924 /*
925 * Check the connection type
926 */
927 if (!(svp->sv_type & VCC_SVC)) {
928 result = SPANS_FAIL;
929 goto response;
930 }
931
932 /*
933 * Check the connection state
934 */
935 switch (svp->sv_sstate) {
936 case SPANS_VC_OPEN:
937 case SPANS_VC_R_POPEN:
938 case SPANS_VC_POPEN:
939 /*
940 * VCC is open or opening--continue
941 */
942 break;
943 case SPANS_VC_CLOSE:
944 case SPANS_VC_FREE:
945 case SPANS_VC_ABORT:
946 /*
947 * We're already closing--give a response, since this
948 * is probably a retransmission
949 */
950 result = SPANS_OK;
951 goto response;
952 case SPANS_VC_NULL:
953 result = SPANS_FAIL;
954 goto response;
955 }
956
957 /*
958 * Cancel the retransmission timer
959 */
960 SPANS_VC_CANCEL((struct vccb *) svp);
961
962 /*
963 * Close out the VCCB and notify the user
964 */
965 outstate = svp->sv_sstate;
966 svp->sv_ustate = VCCU_CLOSED;
967 svp->sv_sstate = SPANS_VC_FREE;
968 cvp = svp->sv_connvc;
969 switch (outstate) {
970 case SPANS_VC_R_POPEN:
971 spans_free((struct vccb *)svp);
972 /* FALLTHRU */
973
974 case SPANS_VC_POPEN:
975 case SPANS_VC_OPEN:
976 cvp->cvc_attr.cause.tag = T_ATM_PRESENT;
977 cvp->cvc_attr.cause.v.coding_standard =
978 T_ATM_ITU_CODING;
979 cvp->cvc_attr.cause.v.location = T_ATM_LOC_USER;
980 cvp->cvc_attr.cause.v.cause_value =
981 T_ATM_CAUSE_NORMAL_CALL_CLEARING;
982 KM_ZERO(cvp->cvc_attr.cause.v.diagnostics,
983 sizeof(cvp->cvc_attr.cause.v.diagnostics));
984 atm_cm_cleared(svp->sv_connvc);
985 break;
986 }
987
988 result = SPANS_OK;
989
990 response:
991 /*
992 * Respond to the SPANS_CLOSE_IND with a SPANS_CLOSE_RSP
993 */
994 rsp_msg = (spans_msg *)atm_allocate(&spans_msgpool);
995 if (rsp_msg == NULL)
996 return;
997 rsp_msg->sm_vers = SPANS_VERS_1_0;
998 if (msg->sm_type == SPANS_RCLOSE_REQ ||
999 msg->sm_type == SPANS_RCLOSE_IND) {
1000 rsp_msg->sm_type = SPANS_RCLOSE_RSP;
1001 } else {
1002 rsp_msg->sm_type = SPANS_CLOSE_RSP;
1003 }
1004 rsp_msg->sm_close_rsp.clrsp_conn = msg->sm_close_req.clreq_conn;
1005 rsp_msg->sm_close_rsp.clrsp_result = result;
1006 spans_send_msg(spp, rsp_msg);
1007 atm_free(rsp_msg);
1008 }
1009
1010
1011 /*
1012 * Process a close response or close confirmation
1013 *
1014 * Called when an close response or close confirmation is received.
1015 * Processing will be based on the state of the requested connection and
1016 * the returned status.
1017 *
1018 * Arguments:
1019 * spp pointer to SPANS protocol instance block
1020 * msg pointer to the close response or confirmation message
1021 *
1022 * Returns:
1023 * none
1024 *
1025 */
1026 static void
1027 spans_close_rsp(struct spans *spp, spans_msg *msg)
1028 {
1029 struct spans_vccb *svp;
1030
1031 ATM_DEBUG2("spans_close_rsp: spp=%p, msg=%p\n", spp, msg);
1032
1033 /*
1034 * Locate the VCCB for the connection
1035 */
1036 svp = spans_find_conn(spp, &msg->sm_close_rsp.clrsp_conn);
1037 if (svp == NULL) {
1038 return;
1039 }
1040
1041 /*
1042 * Check the VCCB state
1043 */
1044 if (svp->sv_sstate != SPANS_VC_CLOSE) {
1045 return;
1046 }
1047
1048 /*
1049 * Cancel the retransmission timer
1050 */
1051 SPANS_VC_CANCEL((struct vccb *) svp);
1052
1053 /*
1054 * Check the response from the remote end
1055 */
1056 switch (msg->sm_close_rsp.clrsp_result) {
1057
1058 case SPANS_OK:
1059 /*
1060 * Mark the VCCB as closed and notify the owner
1061 */
1062 svp->sv_sstate = SPANS_VC_FREE;
1063 svp->sv_connvc->cvc_attr.cause.tag = T_ATM_PRESENT;
1064 svp->sv_connvc->cvc_attr.cause.v.coding_standard =
1065 T_ATM_ITU_CODING;
1066 svp->sv_connvc->cvc_attr.cause.v.location =
1067 T_ATM_LOC_USER;
1068 svp->sv_connvc->cvc_attr.cause.v.cause_value =
1069 T_ATM_CAUSE_NORMAL_CALL_CLEARING;
1070 KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics,
1071 sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics));
1072 atm_cm_cleared(svp->sv_connvc);
1073 break;
1074
1075 case SPANS_NOVPVC:
1076 case SPANS_BADDEST:
1077 case SPANS_FAIL:
1078 case SPANS_NORSC:
1079 /*
1080 * Mark the VCCB as closed and notify the owner
1081 */
1082 svp->sv_sstate = SPANS_VC_FREE;
1083 svp->sv_connvc->cvc_attr.cause.tag = T_ATM_PRESENT;
1084 svp->sv_connvc->cvc_attr.cause.v.coding_standard =
1085 T_ATM_ITU_CODING;
1086 svp->sv_connvc->cvc_attr.cause.v.location =
1087 T_ATM_LOC_USER;
1088 svp->sv_connvc->cvc_attr.cause.v.cause_value =
1089 T_ATM_CAUSE_UNSPECIFIED_NORMAL;
1090 KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics,
1091 sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics));
1092 atm_cm_cleared(svp->sv_connvc);
1093 break;
1094
1095 default:
1096 log(LOG_ERR, "spans: unknown result %d in close rsp\n",
1097 msg->sm_close_rsp.clrsp_result);
1098 break;
1099 }
1100 }
1101
1102
1103 /*
1104 * Process a multi request or multi indication
1105 *
1106 * Called when a multi response or multi confirmation is received. We
1107 * don't support multicast channels, so we just reject the request.
1108 *
1109 * Arguments:
1110 * spp pointer to SPANS protocol instance block
1111 * msg pointer to the multi request or indication message
1112 *
1113 * Returns:
1114 * none
1115 *
1116 */
1117 static void
1118 spans_multi_req(struct spans *spp, spans_msg *msg)
1119 {
1120 spans_msg *rsp_msg;
1121
1122 /*
1123 * Get memory for a SPANS_MULTI_RSP message.
1124 */
1125 rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool);
1126 if (rsp_msg == NULL)
1127 return;
1128
1129 /*
1130 * Fill out the response.
1131 */
1132 rsp_msg->sm_vers = SPANS_VERS_1_0;
1133 rsp_msg->sm_type = SPANS_MULTI_RSP;
1134 rsp_msg->sm_multi_rsp.mursp_conn = msg->sm_multi_req.mureq_conn;
1135 rsp_msg->sm_multi_rsp.mursp_result = SPANS_FAIL;
1136 rsp_msg->sm_multi_rsp.mursp_rsrc = msg->sm_multi_req.mureq_desrsrc;
1137 rsp_msg->sm_multi_rsp.mursp_vpvc = 0;
1138
1139 /*
1140 * Send the response and free the message.
1141 */
1142 spans_send_msg(spp, rsp_msg);
1143 atm_free(rsp_msg);
1144 }
1145
1146
1147 /*
1148 * Process an add request or add indication
1149 *
1150 * Called when an add response or add confirmation is received. We
1151 * don't support multicast channels, so we just reject the request.
1152 *
1153 * Arguments:
1154 * spp pointer to SPANS protocol instance block
1155 * msg pointer to the add request or indication message
1156 *
1157 * Returns:
1158 * none
1159 *
1160 */
1161 static void
1162 spans_add_req(struct spans *spp, spans_msg *msg)
1163 {
1164 spans_msg *rsp_msg;
1165
1166 /*
1167 * Get memory for a SPANS_ADD_RSP message.
1168 */
1169 rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool);
1170 if (rsp_msg == NULL)
1171 return;
1172
1173 /*
1174 * Fill out the response.
1175 */
1176 rsp_msg->sm_vers = SPANS_VERS_1_0;
1177 rsp_msg->sm_type = SPANS_ADD_RSP;
1178 rsp_msg->sm_add_rsp.adrsp_conn = msg->sm_add_req.adreq_desconn;
1179 rsp_msg->sm_add_rsp.adrsp_result = SPANS_FAIL;
1180 rsp_msg->sm_add_rsp.adrsp_rsrc.rsc_peak = 0;
1181 rsp_msg->sm_add_rsp.adrsp_rsrc.rsc_mean = 0;
1182 rsp_msg->sm_add_rsp.adrsp_rsrc.rsc_burst = 0;
1183
1184 /*
1185 * Send the response and free the message.
1186 */
1187 spans_send_msg(spp, rsp_msg);
1188 atm_free(rsp_msg);
1189 }
1190
1191
1192 /*
1193 * Process a join request
1194 *
1195 * Called when an join request is received. We don't support group
1196 * addresses, so we just reject the request.
1197 *
1198 * Arguments:
1199 * spp pointer to SPANS protocol instance block
1200 * msg pointer to the join request message
1201 *
1202 * Returns:
1203 * none
1204 *
1205 */
1206 static void
1207 spans_join_req(struct spans *spp, spans_msg *msg)
1208 {
1209 spans_msg *rsp_msg;
1210
1211 /*
1212 * Get memory for a SPANS_JOIN_CNF message.
1213 */
1214 rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool);
1215 if (rsp_msg == NULL)
1216 return;
1217
1218 /*
1219 * Fill out the response.
1220 */
1221 rsp_msg->sm_vers = SPANS_VERS_1_0;
1222 rsp_msg->sm_type = SPANS_JOIN_CNF;
1223 spans_addr_copy(&msg->sm_join_req.jnreq_addr,
1224 &rsp_msg->sm_join_cnf.jncnf_addr);
1225 rsp_msg->sm_join_cnf.jncnf_result = SPANS_FAIL;
1226
1227 /*
1228 * Send the response and free the message.
1229 */
1230 spans_send_msg(spp, rsp_msg);
1231 atm_free(rsp_msg);
1232 }
1233
1234
1235 /*
1236 * Process a leave request
1237 *
1238 * Called when an leave request is received. We don't support group
1239 * addresses, so we just reject the request.
1240 *
1241 * Arguments:
1242 * spp pointer to SPANS protocol instance block
1243 * msg pointer to the leave request message
1244 *
1245 * Returns:
1246 * none
1247 *
1248 */
1249 static void
1250 spans_leave_req(struct spans *spp, spans_msg *msg)
1251 {
1252 spans_msg *rsp_msg;
1253
1254 /*
1255 * Get memory for a SPANS_LEAVE_CNF message.
1256 */
1257 rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool);
1258 if (rsp_msg == NULL)
1259 return;
1260
1261 /*
1262 * Fill out the response.
1263 */
1264 rsp_msg->sm_vers = SPANS_VERS_1_0;
1265 rsp_msg->sm_type = SPANS_LEAVE_CNF;
1266 spans_addr_copy(&msg->sm_leave_req.lvreq_addr,
1267 &rsp_msg->sm_leave_cnf.lvcnf_addr);
1268 rsp_msg->sm_leave_cnf.lvcnf_result = SPANS_FAIL;
1269
1270 /*
1271 * Send the response and free the message.
1272 */
1273 spans_send_msg(spp, rsp_msg);
1274 atm_free(rsp_msg);
1275 }
1276
1277
1278 /*
1279 * Process a VCI range indication
1280 *
1281 * Called when a VCI range indication is received. Adjust the VCI
1282 * bounds if they have changed.
1283 *
1284 * Arguments:
1285 * spp pointer to SPANS protocol instance block
1286 * msg pointer to the VCI range indication message
1287 *
1288 * Returns:
1289 * none
1290 *
1291 */
1292 static void
1293 spans_vcir_ind(struct spans *spp, spans_msg *msg)
1294 {
1295 /*
1296 * Adjust the limits if they have changed
1297 */
1298 if (msg->sm_vcir_ind.vrind_min != spp->sp_min_vci) {
1299 spp->sp_min_vci =
1300 (msg->sm_vcir_ind.vrind_min <
1301 SPANS_MIN_VCI ?
1302 SPANS_MIN_VCI :
1303 msg->sm_vcir_ind.vrind_min);
1304 }
1305 if (msg->sm_vcir_ind.vrind_max != spp->sp_max_vci) {
1306 spp->sp_max_vci =
1307 (msg->sm_vcir_ind.vrind_max >
1308 SPANS_MAX_VCI ?
1309 SPANS_MAX_VCI :
1310 msg->sm_vcir_ind.vrind_max);
1311 }
1312 }
1313
1314
1315 /*
1316 * Process a query request
1317 *
1318 * Called when a query request is received. Respond with the
1319 * appropriate query response.
1320 *
1321 * Arguments:
1322 * spp pointer to SPANS protocol instance block
1323 * msg pointer to the VCI range indication message
1324 *
1325 * Returns:
1326 * none
1327 *
1328 */
1329 static void
1330 spans_query_req(struct spans *spp, spans_msg *msg)
1331 {
1332 struct spans_vccb *svp = NULL;
1333 spans_msg *rsp_msg;
1334
1335 ATM_DEBUG1("spans_query_req: msg=%p\n", msg);
1336
1337 /*
1338 * Ignore an end-to-end query
1339 */
1340 if (msg->sm_query_req.qyreq_type == SPANS_QUERY_END_TO_END) {
1341 return;
1342 }
1343
1344 /*
1345 * Get memory for a SPANS_QUERY_RSP message.
1346 */
1347 rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool);
1348 if (rsp_msg == NULL)
1349 return;
1350
1351 /*
1352 * Fill out the response.
1353 */
1354 rsp_msg->sm_vers = SPANS_VERS_1_0;
1355 rsp_msg->sm_type = SPANS_QUERY_RSP;
1356 rsp_msg->sm_query_rsp.qyrsp_conn = msg->sm_query_req.qyreq_conn;
1357 rsp_msg->sm_query_rsp.qyrsp_type = msg->sm_query_req.qyreq_type;
1358 rsp_msg->sm_query_rsp.qyrsp_data = 0;
1359
1360 /*
1361 * Get the state of the requested connection
1362 */
1363 svp = spans_find_conn(spp, &msg->sm_query_req.qyreq_conn);
1364 if (svp) {
1365 switch(svp->sv_sstate) {
1366 case SPANS_VC_NULL:
1367 case SPANS_VC_FREE:
1368 rsp_msg->sm_query_rsp.qyrsp_state =
1369 SPANS_CONN_CLOSED;
1370 break;
1371 case SPANS_VC_OPEN:
1372 rsp_msg->sm_query_rsp.qyrsp_state =
1373 SPANS_CONN_OPEN;
1374 break;
1375 case SPANS_VC_POPEN:
1376 case SPANS_VC_R_POPEN:
1377 rsp_msg->sm_query_rsp.qyrsp_state =
1378 SPANS_CONN_OPEN_PEND;
1379 break;
1380 case SPANS_VC_CLOSE:
1381 case SPANS_VC_ABORT:
1382 rsp_msg->sm_query_rsp.qyrsp_state =
1383 SPANS_CONN_CLOSE_PEND;
1384 break;
1385 case SPANS_VC_ACTIVE:
1386 case SPANS_VC_ACT_DOWN:
1387 /*
1388 * VCCB is for a PVC (shouldn't happen)
1389 */
1390 atm_free(rsp_msg);
1391 return;
1392 }
1393 } else {
1394 /*
1395 * No VCCB found--connection doesn't exist
1396 */
1397 rsp_msg->sm_query_rsp.qyrsp_state = SPANS_CONN_CLOSED;
1398 }
1399
1400 /*
1401 * Send the response and free the message.
1402 */
1403 spans_send_msg(spp, rsp_msg);
1404 atm_free(rsp_msg);
1405 }
1406
1407
1408 /*
1409 * Process a SPANS signalling message
1410 *
1411 * Called when a SPANS message is received. The message is converted
1412 * into internal format with XDR and decoded by calling the appropriate
1413 * mesage handling routine. Unrecognized and unexpected messages are
1414 * logged.
1415 *
1416 * Arguments:
1417 * spp pointer to SPANS protocol instance block
1418 * m pointer to a buffer chain containing the SPANS message
1419 *
1420 * Returns:
1421 * none
1422 *
1423 */
1424 void
1425 spans_rcv_msg(struct spans *spp, KBuffer *m)
1426 {
1427 XDR xdrs;
1428 spans_msg *msg;
1429
1430 /*
1431 * Get storage for the message
1432 */
1433 msg = (spans_msg *)atm_allocate(&spans_msgpool);
1434 if (msg == NULL) {
1435 return;
1436 }
1437
1438 /*
1439 * Convert the message from network order to internal format
1440 */
1441 xdrmbuf_init(&xdrs, m, XDR_DECODE);
1442 if (!xdr_spans_msg(&xdrs, msg)) {
1443 log(LOG_ERR, "spans_rcv_msg: XDR decode failed\n");
1444 spans_dump_buffer(m);
1445 goto done;
1446 }
1447
1448 #ifdef NOTDEF
1449 /*
1450 * Debug--print some information about the message
1451 */
1452 if (msg->sm_type != SPANS_STAT_REQ &&
1453 msg->sm_type != SPANS_STAT_IND &&
1454 msg->sm_type != SPANS_STAT_RSP) {
1455 kprintf("spans_rcv_msg: got ");
1456 spans_print_msg(msg);
1457 }
1458 #endif
1459
1460 /*
1461 * Verify the message sm_vers
1462 */
1463 if (msg->sm_vers != SPANS_VERS_1_0) {
1464 log(LOG_ERR, "spans: invalid message version 0x%x\n",
1465 msg->sm_vers);
1466 }
1467
1468 /*
1469 * Ignore the message if SPANS isn't up yet
1470 */
1471 if (spp->sp_state != SPANS_ACTIVE &&
1472 (spp->sp_state != SPANS_PROBE ||
1473 (msg->sm_type != SPANS_STAT_REQ &&
1474 msg->sm_type != SPANS_STAT_RSP &&
1475 msg->sm_type != SPANS_STAT_IND))) {
1476 goto done;
1477 }
1478
1479 /*
1480 * Process the message based on its type
1481 */
1482 switch(msg->sm_type) {
1483 case SPANS_STAT_REQ:
1484 spans_status_ind(spp, msg);
1485 break;
1486 case SPANS_STAT_IND:
1487 spans_status_ind(spp, msg);
1488 break;
1489 case SPANS_STAT_RSP:
1490 spans_status_rsp(spp, msg);
1491 break;
1492 case SPANS_OPEN_REQ:
1493 spans_open_req(spp, msg);
1494 break;
1495 case SPANS_OPEN_IND:
1496 spans_open_req(spp, msg);
1497 break;
1498 case SPANS_OPEN_RSP:
1499 spans_open_rsp(spp, msg);
1500 break;
1501 case SPANS_OPEN_CNF:
1502 spans_open_rsp(spp, msg);
1503 break;
1504 case SPANS_CLOSE_REQ:
1505 spans_close_req(spp, msg);
1506 break;
1507 case SPANS_CLOSE_IND:
1508 spans_close_req(spp, msg);
1509 break;
1510 case SPANS_CLOSE_RSP:
1511 spans_close_rsp(spp, msg);
1512 break;
1513 case SPANS_CLOSE_CNF:
1514 spans_close_rsp(spp, msg);
1515 break;
1516 case SPANS_RCLOSE_REQ:
1517 spans_close_req(spp, msg);
1518 break;
1519 case SPANS_RCLOSE_IND:
1520 spans_close_req(spp, msg);
1521 break;
1522 case SPANS_RCLOSE_RSP:
1523 spans_close_rsp(spp, msg);
1524 break;
1525 case SPANS_RCLOSE_CNF:
1526 spans_close_rsp(spp, msg);
1527 break;
1528 case SPANS_MULTI_REQ:
1529 spans_multi_req(spp, msg);
1530 break;
1531 case SPANS_MULTI_IND:
1532 spans_multi_req(spp, msg);
1533 break;
1534 case SPANS_MULTI_RSP:
1535 log(LOG_ERR,
1536 "spans: unexpected message (multi_rsp)\n");
1537 break;
1538 case SPANS_MULTI_CNF:
1539 log(LOG_ERR,
1540 "spans: unexpected message (multi_conf)\n");
1541 break;
1542 case SPANS_ADD_REQ:
1543 spans_add_req(spp, msg);
1544 break;
1545 case SPANS_ADD_IND:
1546 spans_add_req(spp, msg);
1547 break;
1548 case SPANS_ADD_RSP:
1549 log(LOG_ERR,
1550 "spans: unexpected message (add_rsp)\n");
1551 break;
1552 case SPANS_ADD_CNF:
1553 log(LOG_ERR, "spans: unexpected message (add_conf)\n");
1554 break;
1555 case SPANS_JOIN_REQ:
1556 spans_join_req(spp, msg);
1557 break;
1558 case SPANS_JOIN_CNF:
1559 log(LOG_ERR, "spans: unexpected message (join_conf)\n");
1560 break;
1561 case SPANS_LEAVE_REQ:
1562 spans_leave_req(spp, msg);
1563 break;
1564 case SPANS_LEAVE_CNF:
1565 log(LOG_ERR,
1566 "spans: unexpected message (leave_conf)\n");
1567 break;
1568 case SPANS_VCIR_IND:
1569 spans_vcir_ind(spp, msg);
1570 break;
1571 case SPANS_QUERY_REQ:
1572 spans_query_req(spp, msg);
1573 break;
1574 case SPANS_QUERY_RSP:
1575 log(LOG_ERR,
1576 "spans: unexpected message (query_rsp)\n");
1577 break;
1578 default:
1579 log(LOG_ERR, "spans: unknown SPANS message type %d\n",
1580 msg->sm_type);
1581 }
1582
1583 done:
1584 /*
1585 * Free the incoming message (both buffer and internal format) if
1586 * necessary.
1587 */
1588 if (msg)
1589 atm_free(msg);
1590 if (m)
1591 KB_FREEALL(m);
1592 }
DragonFly BSD