?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
HAMMER Utilities: MFC work to date.
[dragonfly.git] / sys / netproto / atm / uni / unisig_msg.c
blob0995a5044ec606bf22b06cedd541da133e3f3d81
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/uni/unisig_msg.c,v 1.6 2000/01/17 20:49:56 mks Exp $
27 * @(#) $DragonFly: src/sys/netproto/atm/uni/unisig_msg.c,v 1.7 2006/01/14 13:36:39 swildner Exp $
28 */
29
30 /*
31 * ATM Forum UNI 3.0/3.1 Signalling Manager
32 * ----------------------------------------
33 *
34 * Message handling module
35 *
36 */
37
38 #include <netproto/atm/kern_include.h>
39
40 #include "unisig_var.h"
41 #include "unisig_msg.h"
42 #include "unisig_mbuf.h"
43 #include "unisig_print.h"
44
45 /*
46 * Local functions
47 */
48 static void unisig_rcv_restart (struct unisig *, struct unisig_msg *);
49 static void unisig_rcv_setup (struct unisig *, struct unisig_msg *);
50
51
52 /*
53 * Local variables
54 */
55 #ifdef DIAGNOSTIC
56 static int unisig_print_msg = 0;
57 #endif
58
59
60 /*
61 * Set a Cause IE based on information in an ATM attribute block
62 *
63 * Arguments:
64 * iep pointer to a cause IE
65 * aap pointer to attribute block
66 *
67 * Returns:
68 * 0 message sent OK
69 * errno error encountered
70 *
71 */
72 void
73 unisig_cause_from_attr(struct ie_generic *iep, Atm_attributes *aap)
74 {
75 /*
76 * Copy cause info from attribute block to IE
77 */
78 iep->ie_ident = UNI_IE_CAUS;
79 iep->ie_coding = aap->cause.v.coding_standard;
80 iep->ie_caus_loc = aap->cause.v.location;
81 iep->ie_caus_cause = aap->cause.v.cause_value;
82 }
83
84
85 /*
86 * Set a Cause IE based on information in a UNI signalling message
87 *
88 * Arguments:
89 * iep pointer to a cause IE
90 * msg pointer to message
91 * cause cause code for the error
92 *
93 * Returns:
94 * 0 message sent OK
95 * errno error encountered
96 *
97 */
98 void
99 unisig_cause_from_msg(struct ie_generic *iep, struct unisig_msg *msg,
100 int cause)
101 {
102 struct ie_generic *ie1;
103 int i;
104
105 /*
106 * Fill out the cause IE fixed fields
107 */
108 iep->ie_ident = UNI_IE_CAUS;
109 iep->ie_caus_loc = UNI_IE_CAUS_LOC_USER;
110 iep->ie_caus_cause = cause;
111
112 /*
113 * Set diagnostics if indicated
114 */
115 switch(cause) {
116 case UNI_IE_CAUS_IECONTENT:
117 iep->ie_caus_diag_len = 0;
118 for (i = 0, ie1 = msg->msg_ie_err;
119 ie1 && i < UNI_IE_CAUS_MAX_ID;
120 ie1 = ie1->ie_next) {
121 if (ie1->ie_err_cause == UNI_IE_CAUS_IECONTENT) {
122 iep->ie_caus_diagnostic[i] =
123 ie1->ie_ident;
124 iep->ie_caus_diag_len++;
125 i++;
126 }
127 }
128 break;
129 case UNI_IE_CAUS_REJECT:
130 iep->ie_caus_diag_len = 2;
131 iep->ie_caus_diagnostic[0] = UNI_IE_EXT_BIT +
132 (UNI_IE_CAUS_RR_USER << UNI_IE_CAUS_RR_SHIFT) +
133 UNI_IE_CAUS_RC_TRANS;
134 iep->ie_caus_diagnostic[1] = 0;
135 break;
136 case UNI_IE_CAUS_MISSING:
137 iep->ie_caus_diag_len = 0;
138 for (i = 0, ie1 = msg->msg_ie_err;
139 ie1 && i < UNI_IE_CAUS_MAX_ID;
140 ie1 = ie1->ie_next) {
141 if (ie1->ie_err_cause == UNI_IE_CAUS_MISSING) {
142 iep->ie_caus_diagnostic[i] =
143 ie1->ie_ident;
144 iep->ie_caus_diag_len++;
145 i++;
146 }
147 }
148 }
149 }
150
151
152 /*
153 * Send a UNISIG signalling message
154 *
155 * Called to send a Q.2931 message. This routine encodes the message
156 * and hands it to SSCF for transmission.
157 *
158 * Arguments:
159 * usp pointer to UNISIG protocol instance block
160 * msg pointer to message
161 *
162 * Returns:
163 * 0 message sent OK
164 * errno error encountered
165 *
166 */
167 int
168 unisig_send_msg(struct unisig *usp, struct unisig_msg *msg)
169 {
170 int err = 0;
171 struct usfmt usf;
172
173 ATM_DEBUG2("unisig_send_msg: msg=%p, type=%d\n", msg,
174 msg->msg_type);
175
176 /*
177 * Make sure the network is up
178 */
179 if (usp->us_state != UNISIG_ACTIVE)
180 return(ENETDOWN);
181
182 #ifdef DIAGNOSTIC
183 /*
184 * Print the message we're sending.
185 */
186 if (unisig_print_msg)
187 usp_print_msg(msg, UNISIG_MSG_OUT);
188 #endif
189
190 /*
191 * Convert message to network order
192 */
193 err = usf_init(&usf, usp, (KBuffer *) 0, USF_ENCODE,
194 usp->us_headout);
195 if (err)
196 return(err);
197
198 err = usf_enc_msg(&usf, msg);
199 if (err) {
200 ATM_DEBUG1("unisig_send_msg: encode failed with %d\n",
201 err);
202 KB_FREEALL(usf.usf_m_base);
203 return(EIO);
204 }
205
206 #ifdef DIAGNOSTIC
207 /*
208 * Print the converted message
209 */
210 if (unisig_print_msg > 1)
211 unisig_print_mbuf(usf.usf_m_base);
212 #endif
213
214 /*
215 * Send the message
216 */
217 err = atm_cm_saal_data(usp->us_conn, usf.usf_m_base);
218 if (err)
219 KB_FREEALL(usf.usf_m_base);
220
221 return(err);
222 }
223
224
225 /*
226 * Send a SETUP request
227 *
228 * Build and send a Q.2931 SETUP message.
229 *
230 * Arguments:
231 * usp pointer to UNISIG protocol instance block
232 * uvp pointer to VCCB for which the request is being sent
233 *
234 * Returns:
235 * none
236 *
237 */
238 int
239 unisig_send_setup(struct unisig *usp, struct unisig_vccb *uvp)
240 {
241 int err = 0;
242 struct unisig_msg *setup;
243 Atm_attributes *ap = &uvp->uv_connvc->cvc_attr;
244
245 ATM_DEBUG1("unisig_send_setup: uvp=%p\n", uvp);
246
247 /*
248 * Make sure required connection attriutes are set
249 */
250 if (ap->aal.tag != T_ATM_PRESENT ||
251 ap->traffic.tag != T_ATM_PRESENT ||
252 ap->bearer.tag != T_ATM_PRESENT ||
253 ap->called.tag != T_ATM_PRESENT ||
254 ap->qos.tag != T_ATM_PRESENT) {
255 err = EINVAL;
256 setup = NULL;
257 goto done;
258 }
259
260 /*
261 * Get memory for a SETUP message
262 */
263 setup = (struct unisig_msg *)atm_allocate(&unisig_msgpool);
264 if (setup == NULL) {
265 err = ENOMEM;
266 goto done;
267 }
268
269 /*
270 * Fill in the SETUP message
271 */
272 if (!uvp->uv_call_ref)
273 uvp->uv_call_ref = unisig_alloc_call_ref(usp);
274 setup->msg_call_ref = uvp->uv_call_ref;
275 setup->msg_type = UNI_MSG_SETU;
276
277 /*
278 * Set IEs from connection attributes
279 */
280 err = unisig_set_attrs(usp, setup, ap);
281 if (err)
282 goto done;
283
284 /*
285 * Attach a Calling Party Number IE if the user didn't
286 * specify one in the attribute block
287 */
288 if (ap->calling.tag != T_ATM_PRESENT) {
289 setup->msg_ie_cgad = (struct ie_generic *)
290 atm_allocate(&unisig_iepool);
291 if (setup->msg_ie_cgad == NULL) {
292 err = ENOMEM;
293 goto done;
294 }
295 setup->msg_ie_cgad->ie_ident = UNI_IE_CGAD;
296 ATM_ADDR_COPY(&usp->us_addr,
297 &setup->msg_ie_cgad->ie_cgad_addr);
298 ATM_ADDR_SEL_COPY(&usp->us_addr,
299 uvp->uv_nif ? uvp->uv_nif->nif_sel : 0,
300 &setup->msg_ie_cgad->ie_cgad_addr);
301 }
302
303 /*
304 * Send the SETUP message
305 */
306 err = unisig_send_msg(usp, setup);
307
308 done:
309 if (setup)
310 unisig_free_msg(setup);
311
312 return(err);
313 }
314
315
316 /*
317 * Send a RELEASE message
318 *
319 * Arguments:
320 * usp pointer to UNISIG protocol instance block
321 * uvp pointer to VCCB for which the RELEASE is being sent
322 * msg pointer to UNI signalling message that the RELEASE
323 * responds to (may be NULL)
324 * cause the reason for the RELEASE; a value of
325 * T_ATM_ABSENT indicates that the cause code is
326 * in the VCC's ATM attributes block
327 *
328 * Returns:
329 * none
330 *
331 */
332 int
333 unisig_send_release(struct unisig *usp, struct unisig_vccb *uvp,
334 struct unisig_msg *msg, int cause)
335 {
336 int err = 0;
337 struct unisig_msg *rls_msg;
338 struct ie_generic *cause_ie;
339
340 ATM_DEBUG2("unisig_send_release: usp=%p, uvp=%p\n",
341 usp, uvp);
342
343 /*
344 * Get memory for a RELEASE message
345 */
346 rls_msg = (struct unisig_msg *) atm_allocate(&unisig_msgpool);
347 if (rls_msg == NULL) {
348 return(ENOMEM);
349 }
350 cause_ie = (struct ie_generic *) atm_allocate(&unisig_iepool);
351 if (cause_ie == NULL) {
352 atm_free(rls_msg);
353 return(ENOMEM);
354 }
355
356 /*
357 * Fill in the RELEASE message
358 */
359 rls_msg->msg_call_ref = uvp->uv_call_ref;
360 rls_msg->msg_type = UNI_MSG_RLSE;
361 rls_msg->msg_type_flag = 0;
362 rls_msg->msg_type_action = 0;
363 rls_msg->msg_ie_caus = cause_ie;
364
365 /*
366 * Fill out the cause IE
367 */
368 cause_ie->ie_ident = UNI_IE_CAUS;
369 if (cause == T_ATM_ABSENT) {
370 unisig_cause_from_attr(cause_ie,
371 &uvp->uv_connvc->cvc_attr);
372 } else {
373 cause_ie->ie_caus_loc = UNI_IE_CAUS_LOC_USER;
374 unisig_cause_from_msg(cause_ie, msg, cause);
375 }
376
377 /*
378 * Send the RELEASE
379 */
380 err = unisig_send_msg(usp, rls_msg);
381 unisig_free_msg(rls_msg);
382
383 return(err);
384 }
385
386
387 /*
388 * Send a RELEASE COMPLETE message
389 *
390 * Arguments:
391 * usp pointer to UNISIG protocol instance block
392 * uvp pointer to VCCB for which the RELEASE is being sent.
393 * NULL indicates that a VCCB wasn't found for a call
394 * reference value.
395 * msg pointer to the message which triggered the send
396 * cause the cause code for the message; a value of
397 * T_ATM_ABSENT indicates that the cause code is
398 * in the VCC's ATM attributes block
399 *
400 * Returns:
401 * 0 success
402 * errno error encountered
403 *
404 */
405 int
406 unisig_send_release_complete(struct unisig *usp, struct unisig_vccb *uvp,
407 struct unisig_msg *msg, int cause)
408 {
409 int err = 0;
410 struct unisig_msg *rls_cmp;
411 struct ie_generic *cause_ie;
412
413 ATM_DEBUG4("unisig_send_release_complete usp=%p, uvp=%p, msg=%p, cause=%d\n",
414 usp, uvp, msg, cause);
415
416 /*
417 * Get memory for a RELEASE COMPLETE message
418 */
419 rls_cmp = (struct unisig_msg *) atm_allocate(&unisig_msgpool);
420 if (rls_cmp == NULL) {
421 return(ENOMEM);
422 }
423 cause_ie = (struct ie_generic *) atm_allocate(&unisig_iepool);
424 if (cause_ie == NULL) {
425 atm_free(rls_cmp);
426 return(ENOMEM);
427 }
428
429 /*
430 * Fill in the RELEASE COMPLETE message
431 */
432 if (uvp) {
433 rls_cmp->msg_call_ref = uvp->uv_call_ref;
434 } else if (msg) {
435 rls_cmp->msg_call_ref = EXTRACT_CREF(msg->msg_call_ref);
436 } else {
437 rls_cmp->msg_call_ref = UNI_MSG_CALL_REF_GLOBAL;
438 }
439 rls_cmp->msg_type = UNI_MSG_RLSC;
440 rls_cmp->msg_type_flag = 0;
441 rls_cmp->msg_type_action = 0;
442 rls_cmp->msg_ie_caus = cause_ie;
443
444 /*
445 * Fill out the cause IE
446 */
447 cause_ie->ie_ident = UNI_IE_CAUS;
448 if (cause == T_ATM_ABSENT) {
449 unisig_cause_from_attr(cause_ie,
450 &uvp->uv_connvc->cvc_attr);
451 } else {
452 cause_ie->ie_caus_loc = UNI_IE_CAUS_LOC_USER;
453 unisig_cause_from_msg(cause_ie, msg, cause);
454 }
455
456 /*
457 * Send the RELEASE COMPLETE
458 */
459 err = unisig_send_msg(usp, rls_cmp);
460 unisig_free_msg(rls_cmp);
461
462 return(err);
463 }
464
465
466 /*
467 * Send a STATUS message
468 *
469 * Arguments:
470 * usp pointer to UNISIG protocol instance block
471 * uvp pointer to VCCB for which the STATUS is being sent.
472 * NULL indicates that a VCCB wasn't found for a call
473 * reference value.
474 * msg pointer to the message which triggered the send
475 * cause the cause code to include in the message
476 *
477 * Returns:
478 * none
479 *
480 */
481 int
482 unisig_send_status(struct unisig *usp, struct unisig_vccb *uvp,
483 struct unisig_msg *msg, int cause)
484 {
485 int err = 0, i;
486 struct unisig_msg *stat_msg;
487 struct ie_generic *cause_ie, *clst_ie, *iep;
488
489 ATM_DEBUG4("unisig_send_status: usp=%p, uvp=%p, msg=%p, cause=%d\n",
490 usp, uvp, msg, cause);
491
492 /*
493 * Get memory for a STATUS message
494 */
495 stat_msg = (struct unisig_msg *) atm_allocate(&unisig_msgpool);
496 if (stat_msg == NULL) {
497 return(ENOMEM);
498 }
499 cause_ie = (struct ie_generic *) atm_allocate(&unisig_iepool);
500 if (cause_ie == NULL) {
501 atm_free(stat_msg);
502 return(ENOMEM);
503 }
504 clst_ie = (struct ie_generic *) atm_allocate(&unisig_iepool);
505 if (clst_ie == NULL) {
506 atm_free(stat_msg);
507 atm_free(cause_ie);
508 return(ENOMEM);
509 }
510
511 /*
512 * Fill in the STATUS message
513 */
514 if (uvp) {
515 stat_msg->msg_call_ref = uvp->uv_call_ref;
516 } else if (msg) {
517 stat_msg->msg_call_ref =
518 EXTRACT_CREF(msg->msg_call_ref);
519 } else {
520 stat_msg->msg_call_ref = UNI_MSG_CALL_REF_GLOBAL;
521 }
522 stat_msg->msg_type = UNI_MSG_STAT;
523 stat_msg->msg_type_flag = 0;
524 stat_msg->msg_type_action = 0;
525 stat_msg->msg_ie_clst = clst_ie;
526 stat_msg->msg_ie_caus = cause_ie;
527
528 /*
529 * Fill out the call state IE
530 */
531 clst_ie->ie_ident = UNI_IE_CLST;
532 clst_ie->ie_coding = 0;
533 clst_ie->ie_flag = 0;
534 clst_ie->ie_action = 0;
535 if (uvp) {
536 clst_ie->ie_clst_state = uvp->uv_sstate;
537 } else {
538 clst_ie->ie_clst_state = UNI_NULL;
539 }
540
541 /*
542 * Fill out the cause IE
543 */
544 cause_ie->ie_ident = UNI_IE_CAUS;
545 cause_ie->ie_coding = 0;
546 cause_ie->ie_flag = 0;
547 cause_ie->ie_action = 0;
548 cause_ie->ie_caus_loc = UNI_IE_CAUS_LOC_USER;
549 cause_ie->ie_caus_cause = cause;
550 switch (cause) {
551 case UNI_IE_CAUS_MTEXIST:
552 case UNI_IE_CAUS_STATE:
553 if (msg) {
554 cause_ie->ie_caus_diagnostic[0] = msg->msg_type;
555 }
556 break;
557 case UNI_IE_CAUS_MISSING:
558 case UNI_IE_CAUS_IECONTENT:
559 case UNI_IE_CAUS_IEEXIST:
560 for (i=0, iep=msg->msg_ie_err;
561 iep && i<UNI_MSG_IE_CNT;
562 i++, iep = iep->ie_next) {
563 if (iep->ie_err_cause == cause) {
564 cause_ie->ie_caus_diagnostic[i] =
565 iep->ie_ident;
566 }
567 }
568 }
569
570 /*
571 * Send the STATUS message
572 */
573 err = unisig_send_msg(usp, stat_msg);
574 unisig_free_msg(stat_msg);
575
576 return(err);
577 }
578
579
580 /*
581 * Process a RESTART message
582 *
583 * Arguments:
584 * usp pointer to UNISIG protocol instance block
585 * msg pointer to the RESTART message
586 *
587 * Returns:
588 * none
589 *
590 */
591 static void
592 unisig_rcv_restart(struct unisig *usp, struct unisig_msg *msg)
593 {
594 struct unisig_vccb *uvp, *uvnext;
595 struct unisig_msg *rsta_msg;
596
597 ATM_DEBUG2("unisig_rcv_restart: usp=%p, msg=%p\n",
598 usp, msg);
599
600 /*
601 * Check what class of VCCs we're supposed to restart
602 */
603 if (msg->msg_ie_rsti->ie_rsti_class == UNI_IE_RSTI_IND_VC) {
604 /*
605 * Just restart the indicated VCC
606 */
607 if (msg->msg_ie_cnid) {
608 uvp = unisig_find_vpvc(usp,
609 msg->msg_ie_cnid->ie_cnid_vpci,
610 msg->msg_ie_cnid->ie_cnid_vci,
611 0);
612 if (uvp && uvp->uv_type & VCC_SVC) {
613 unisig_clear_vcc(usp, uvp,
614 T_ATM_CAUSE_NORMAL_CALL_CLEARING);
615 }
616 }
617 } else {
618 /*
619 * Restart all VCCs
620 */
621 crit_enter();
622 for (uvp=Q_HEAD(usp->us_vccq, struct unisig_vccb); uvp;
623 uvp=uvnext) {
624 uvnext = Q_NEXT(uvp, struct unisig_vccb,
625 uv_sigelem);
626 if (uvp->uv_type & VCC_SVC) {
627 unisig_clear_vcc(usp, uvp,
628 T_ATM_CAUSE_NORMAL_CALL_CLEARING);
629 }
630 }
631 crit_exit();
632 }
633
634 /*
635 * Get memory for a RESTART ACKNOWLEDGE message
636 */
637 rsta_msg = (struct unisig_msg *) atm_allocate(&unisig_msgpool);
638 if (rsta_msg == NULL) {
639 return;
640 }
641
642 /*
643 * Fill out the message
644 */
645 rsta_msg->msg_call_ref = EXTRACT_CREF(msg->msg_call_ref);
646 rsta_msg->msg_type = UNI_MSG_RSTA;
647 rsta_msg->msg_type_flag = 0;
648 rsta_msg->msg_type_action = 0;
649 rsta_msg->msg_ie_rsti = msg->msg_ie_rsti;
650 if (msg->msg_ie_cnid) {
651 rsta_msg->msg_ie_cnid = msg->msg_ie_cnid;
652 }
653
654 /*
655 * Send the message
656 */
657 unisig_send_msg(usp, rsta_msg);
658 rsta_msg->msg_ie_rsti = NULL;
659 rsta_msg->msg_ie_cnid = NULL;
660 unisig_free_msg(rsta_msg);
661
662 return;
663 }
664
665
666 /*
667 * Process a SETUP message
668 *
669 * Arguments:
670 * usp pointer to UNISIG protocol instance block
671 * msg pointer to the SETUP message
672 *
673 * Returns:
674 * none
675 *
676 */
677 static void
678 unisig_rcv_setup(struct unisig *usp, struct unisig_msg *msg)
679 {
680 struct unisig_vccb *uvp = NULL;
681 struct ie_generic *iep;
682
683 ATM_DEBUG2("unisig_rcv_setup: usp=%p, msg=%p\n", usp, msg);
684
685 /*
686 * If we already have a VCC with the call reference,
687 * ignore the SETUP message
688 */
689 uvp = unisig_find_conn(usp, EXTRACT_CREF(msg->msg_call_ref));
690 if (uvp)
691 return;
692
693 /*
694 * If the call reference flag is incorrectly set,
695 * ignore the SETUP message
696 */
697 if (msg->msg_call_ref & UNI_MSG_CALL_REF_RMT)
698 return;
699
700 /*
701 * If there are missing mandatory IEs, send a
702 * RELEASE COMPLETE message and ignore the SETUP
703 */
704 for (iep = msg->msg_ie_err; iep; iep = iep->ie_next) {
705 if (iep->ie_err_cause == UNI_IE_CAUS_MISSING) {
706 unisig_send_release_complete(usp,
707 uvp, msg, UNI_IE_CAUS_MISSING);
708 return;
709 }
710 }
711
712 /*
713 * If there are mandatory IEs with invalid content, send a
714 * RELEASE COMPLETE message and ignore the SETUP
715 */
716 for (iep = msg->msg_ie_err; iep; iep = iep->ie_next) {
717 if (iep->ie_err_cause == UNI_IE_CAUS_IECONTENT) {
718 unisig_send_release_complete(usp,
719 uvp, msg,
720 UNI_IE_CAUS_IECONTENT);
721 return;
722 }
723 }
724
725 /*
726 * Get a new VCCB for the connection
727 */
728 uvp = (struct unisig_vccb *)atm_allocate(&unisig_vcpool);
729 if (uvp == NULL) {
730 return;
731 }
732
733 /*
734 * Put the VCCB on the UNISIG queue
735 */
736 ENQUEUE(uvp, struct unisig_vccb, uv_sigelem, usp->us_vccq);
737
738 /*
739 * Set the state and call reference value
740 */
741 uvp->uv_sstate = UNI_NULL;
742 uvp->uv_call_ref = EXTRACT_CREF(msg->msg_call_ref);
743
744 /*
745 * Pass the VCCB and message to the VC state machine
746 */
747 unisig_vc_state(usp, uvp, UNI_VC_SETUP_MSG, msg);
748
749 /*
750 * If the VCCB state is NULL, the open failed and the
751 * VCCB should be released
752 */
753 if (uvp->uv_sstate == UNI_NULL) {
754 DEQUEUE(uvp, struct unisig_vccb, uv_sigelem,
755 usp->us_vccq);
756 atm_free(uvp);
757 }
758
759 return;
760 }
761
762
763 /*
764 * Process a UNISIG signalling message
765 *
766 * Called when a UNISIG message is received. The message is decoded
767 * and passed to the UNISIG state machine. Unrecognized and
768 * unexpected messages are logged.
769 *
770 * Arguments:
771 * usp pointer to UNISIG protocol instance block
772 * m pointer to a buffer chain containing the UNISIG message
773 *
774 * Returns:
775 * none
776 *
777 */
778 int
779 unisig_rcv_msg(struct unisig *usp, KBuffer *m)
780 {
781 int err;
782 u_int cref;
783 struct usfmt usf;
784 struct unisig_msg *msg = 0;
785 struct unisig_vccb *uvp = 0;
786 struct ie_generic *iep;
787
788 ATM_DEBUG2("unisig_rcv_msg: bfr=%p, len=%d\n", m, KB_LEN(m));
789
790 #ifdef NOTDEF
791 unisig_print_mbuf(m);
792 #endif
793
794 /*
795 * Get storage for the message
796 */
797 msg = (struct unisig_msg *)atm_allocate(&unisig_msgpool);
798 if (msg == NULL) {
799 err = ENOMEM;
800 goto done;
801 }
802
803 /*
804 * Convert the message from network order to internal format
805 */
806 err = usf_init(&usf, usp, m, USF_DECODE, 0);
807 if (err) {
808 if (err == EINVAL)
809 panic("unisig_rcv_msg: invalid parameter\n");
810 ATM_DEBUG1("unisig_rcv_msg: decode init failed with %d\n",
811 err);
812 goto done;
813 }
814
815 err = usf_dec_msg(&usf, msg);
816 if (err) {
817 ATM_DEBUG1("unisig_rcv_msg: decode failed with %d\n",
818 err);
819 goto done;
820 }
821
822 #ifdef DIAGNOSTIC
823 /*
824 * Debug--print some information about the message
825 */
826 if (unisig_print_msg)
827 usp_print_msg(msg, UNISIG_MSG_IN);
828 #endif
829
830 /*
831 * Get the call reference value
832 */
833 cref = EXTRACT_CREF(msg->msg_call_ref);
834
835 /*
836 * Any message with the global call reference value except
837 * RESTART, RESTART ACK, or STATUS is in error
838 */
839 if (GLOBAL_CREF(cref) &&
840 msg->msg_type != UNI_MSG_RSTR &&
841 msg->msg_type != UNI_MSG_RSTA &&
842 msg->msg_type != UNI_MSG_STAT) {
843 /*
844 * Send STATUS message indicating the error
845 */
846 err = unisig_send_status(usp, (struct unisig_vccb *) 0,
847 msg, UNI_IE_CAUS_CREF);
848 goto done;
849 }
850
851 /*
852 * Check for missing mandatory IEs. Checks for SETUP,
853 * RELEASE, and RELEASE COMPLETE are handled elsewhere.
854 */
855 if (msg->msg_type != UNI_MSG_SETU &&
856 msg->msg_type != UNI_MSG_RLSE &&
857 msg->msg_type != UNI_MSG_RLSC) {
858 for (iep = msg->msg_ie_err; iep; iep = iep->ie_next) {
859 if (iep->ie_err_cause == UNI_IE_CAUS_MISSING) {
860 err = unisig_send_status(usp,
861 uvp, msg,
862 UNI_IE_CAUS_MISSING);
863 goto done;
864 }
865 }
866 }
867
868 /*
869 * Find the VCCB associated with the message
870 */
871 uvp = unisig_find_conn(usp, cref);
872
873 /*
874 * Process the message based on its type
875 */
876 switch(msg->msg_type) {
877 case UNI_MSG_CALP:
878 unisig_vc_state(usp, uvp,
879 UNI_VC_CALLP_MSG, msg);
880 break;
881 case UNI_MSG_CONN:
882 unisig_vc_state(usp, uvp,
883 UNI_VC_CONNECT_MSG, msg);
884 break;
885 case UNI_MSG_CACK:
886 unisig_vc_state(usp, uvp,
887 UNI_VC_CNCTACK_MSG, msg);
888 break;
889 case UNI_MSG_SETU:
890 unisig_rcv_setup(usp, msg);
891 break;
892 case UNI_MSG_RLSE:
893 unisig_vc_state(usp, uvp,
894 UNI_VC_RELEASE_MSG, msg);
895 break;
896 case UNI_MSG_RLSC:
897 /*
898 * Ignore a RELEASE COMPLETE with an unrecognized
899 * call reference value
900 */
901 if (uvp) {
902 unisig_vc_state(usp, uvp,
903 UNI_VC_RLSCMP_MSG, msg);
904 }
905 break;
906 case UNI_MSG_RSTR:
907 unisig_rcv_restart(usp, msg);
908 break;
909 case UNI_MSG_RSTA:
910 break;
911 case UNI_MSG_STAT:
912 unisig_vc_state(usp, uvp,
913 UNI_VC_STATUS_MSG, msg);
914 break;
915 case UNI_MSG_SENQ:
916 unisig_vc_state(usp, uvp,
917 UNI_VC_STATUSENQ_MSG, msg);
918 break;
919 case UNI_MSG_ADDP:
920 unisig_vc_state(usp, uvp,
921 UNI_VC_ADDP_MSG, msg);
922 break;
923 case UNI_MSG_ADPA:
924 unisig_vc_state(usp, uvp,
925 UNI_VC_ADDPACK_MSG, msg);
926 break;
927 case UNI_MSG_ADPR:
928 unisig_vc_state(usp, uvp,
929 UNI_VC_ADDPREJ_MSG, msg);
930 break;
931 case UNI_MSG_DRPP:
932 unisig_vc_state(usp, uvp,
933 UNI_VC_DROP_MSG, msg);
934 break;
935 case UNI_MSG_DRPA:
936 unisig_vc_state(usp, uvp,
937 UNI_VC_DROPACK_MSG, msg);
938 break;
939 default:
940 /*
941 * Message size didn't match size received
942 */
943 err = unisig_send_status(usp, uvp, msg,
944 UNI_IE_CAUS_MTEXIST);
945 }
946
947 done:
948 /*
949 * Handle message errors that require a response
950 */
951 switch(err) {
952 case EMSGSIZE:
953 /*
954 * Message size didn't match size received
955 */
956 err = unisig_send_status(usp, uvp, msg,
957 UNI_IE_CAUS_LEN);
958 break;
959 }
960
961 /*
962 * Free the incoming message (both buffer and internal format)
963 * if necessary.
964 */
965 if (msg)
966 unisig_free_msg(msg);
967 if (m)
968 KB_FREEALL(m);
969
970 return (err);
971 }
DragonFly BSD