?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fetch.9: Minor fixes.
[dragonfly.git] / sys / netproto / atm / uni / sscop_pdu.c
blob374f000c0dc86022d2b95221394c8ad010513159
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/sscop_pdu.c,v 1.5 2000/01/17 20:49:52 mks Exp $
27 * @(#) $DragonFly: src/sys/netproto/atm/uni/sscop_pdu.c,v 1.7 2006/12/20 18:14:43 dillon Exp $
28 */
29
30 /*
31 * ATM Forum UNI Support
32 * ---------------------
33 *
34 * SSCOP - PDU subroutines
35 *
36 */
37
38 #include <netproto/atm/kern_include.h>
39
40 #include "sscop.h"
41 #include "sscop_misc.h"
42 #include "sscop_pdu.h"
43 #include "sscop_var.h"
44
45 /*
46 * Local functions
47 */
48 static KBuffer * sscop_stat_init (struct sscop *);
49 static KBuffer * sscop_stat_add (sscop_seq, KBuffer *);
50 static int sscop_stat_end (struct sscop *, sscop_seq,
51 KBuffer *, KBuffer *);
52 static int sscop_recv_locate (struct sscop *, sscop_seq,
53 struct pdu_hdr **);
54
55
56 /*
57 * Build and send BGN PDU
58 *
59 * A BGN PDU will be constructed and passed down the protocol stack.
60 * The SSCOP-UU/N(UU) field is not supported.
61 *
62 * Arguments:
63 * sop pointer to sscop connection control block
64 * source originator of BGN PDU (Q.SAAL1 only)
65 *
66 * Returns:
67 * 0 PDU successfully built and passed down the stack
68 * else unable to build or send pdu
69 *
70 */
71 int
72 sscop_send_bgn(struct sscop *sop, int source)
73 {
74 KBuffer *m;
75 struct bgn_pdu *bp;
76 int err;
77
78
79 /*
80 * Get buffer for PDU
81 */
82 KB_ALLOCPKT(m, sizeof(struct bgn_pdu), KB_F_NOWAIT, KB_T_HEADER);
83 if (m == NULL)
84 return (1);
85
86 /*
87 * Setup buffer controls
88 */
89 KB_HEADSET(m, MIN(sop->so_headout,
90 KB_BFRLEN(m) - sizeof(struct bgn_pdu)));
91 KB_LEN(m) = sizeof(struct bgn_pdu);
92
93 /*
94 * Build PDU
95 */
96 KB_DATASTART(m, bp, struct bgn_pdu *);
97 *(int *)&bp->bgn_rsvd[0] = 0;
98 if (sop->so_vers != SSCOP_VERS_QSAAL)
99 bp->bgn_nsq = sop->so_sendconn;
100 bp->bgn_nmr =
101 htonl((PT_BGN << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_rcvmax));
102 if ((sop->so_vers == SSCOP_VERS_QSAAL) &&
103 (source == SSCOP_SOURCE_SSCOP))
104 bp->bgn_type |= PT_SOURCE_SSCOP;
105
106 /*
107 * Send PDU towards peer
108 */
109 STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
110 sop->so_connvc, (int)m, 0, err);
111
112 if (err)
113 KB_FREEALL(m);
114
115 return (err);
116 }
117
118
119 /*
120 * Build and send BGAK PDU
121 *
122 * A BGAK PDU will be constructed and passed down the protocol stack.
123 * The SSCOP-UU/N(UU) field is not supported.
124 *
125 * Arguments:
126 * sop pointer to sscop connection control block
127 *
128 * Returns:
129 * 0 PDU successfully built and passed down the stack
130 * else unable to build or send pdu
131 *
132 */
133 int
134 sscop_send_bgak(struct sscop *sop)
135 {
136 KBuffer *m;
137 struct bgak_pdu *bp;
138 int err;
139
140
141 /*
142 * Get buffer for PDU
143 */
144 KB_ALLOCPKT(m, sizeof(struct bgak_pdu), KB_F_NOWAIT, KB_T_HEADER);
145 if (m == NULL)
146 return (1);
147
148 /*
149 * Setup buffer controls
150 */
151 KB_HEADSET(m, MIN(sop->so_headout,
152 KB_BFRLEN(m) - sizeof(struct bgak_pdu)));
153 KB_LEN(m) = sizeof(struct bgak_pdu);
154
155 /*
156 * Build PDU
157 */
158 KB_DATASTART(m, bp, struct bgak_pdu *);
159 bp->bgak_rsvd = 0;
160 bp->bgak_nmr =
161 htonl((PT_BGAK << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_rcvmax));
162
163 /*
164 * Send PDU towards peer
165 */
166 STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
167 sop->so_connvc, (int)m, 0, err);
168
169 if (err)
170 KB_FREEALL(m);
171
172 return (err);
173 }
174
175
176 /*
177 * Build and send BGREJ PDU
178 *
179 * A BGREJ PDU will be constructed and passed down the protocol stack.
180 * The SSCOP-UU/N(UU) field is not supported.
181 *
182 * Arguments:
183 * sop pointer to sscop connection control block
184 *
185 * Returns:
186 * 0 PDU successfully built and passed down the stack
187 * else unable to build or send pdu
188 *
189 */
190 int
191 sscop_send_bgrej(struct sscop *sop)
192 {
193 KBuffer *m;
194 struct bgrej_pdu *bp;
195 int err;
196
197
198 /*
199 * Get buffer for PDU
200 */
201 KB_ALLOCPKT(m, sizeof(struct bgrej_pdu), KB_F_NOWAIT, KB_T_HEADER);
202 if (m == NULL)
203 return (1);
204
205 /*
206 * Setup buffer controls
207 */
208 KB_HEADSET(m, MIN(sop->so_headout,
209 KB_BFRLEN(m) - sizeof(struct bgrej_pdu)));
210 KB_LEN(m) = sizeof(struct bgrej_pdu);
211
212 /*
213 * Build PDU
214 */
215 KB_DATASTART(m, bp, struct bgrej_pdu *);
216 bp->bgrej_rsvd2 = 0;
217 *(u_int *)&bp->bgrej_type = htonl((PT_BGREJ << PT_TYPE_SHIFT) | 0);
218
219 /*
220 * Send PDU towards peer
221 */
222 STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
223 sop->so_connvc, (int)m, 0, err);
224
225 if (err)
226 KB_FREEALL(m);
227
228 return (err);
229 }
230
231
232 /*
233 * Build and send END PDU
234 *
235 * An END PDU will be constructed and passed down the protocol stack.
236 * The SSCOP-UU/N(UU) field is not supported.
237 *
238 * Arguments:
239 * sop pointer to sscop connection control block
240 * source originator of END PDU
241 *
242 * Returns:
243 * 0 PDU successfully built and passed down the stack
244 * else unable to build or send pdu
245 *
246 */
247 int
248 sscop_send_end(struct sscop *sop, int source)
249 {
250 KBuffer *m;
251 struct end_pdu *ep;
252 int err;
253
254
255 /*
256 * Get buffer for PDU
257 */
258 KB_ALLOCPKT(m, sizeof(struct end_pdu), KB_F_NOWAIT, KB_T_HEADER);
259 if (m == NULL)
260 return (1);
261
262 /*
263 * Setup buffer controls
264 */
265 KB_HEADSET(m, MIN(sop->so_headout,
266 KB_BFRLEN(m) - sizeof(struct end_pdu)));
267 KB_LEN(m) = sizeof(struct end_pdu);
268
269 /*
270 * Build PDU
271 */
272 KB_DATASTART(m, ep, struct end_pdu *);
273 ep->end_rsvd2 = 0;
274 *(u_int *)&ep->end_type = htonl((PT_END << PT_TYPE_SHIFT) | 0);
275 if (source == SSCOP_SOURCE_SSCOP) {
276 ep->end_type |= PT_SOURCE_SSCOP;
277 sop->so_flags |= SOF_ENDSSCOP;
278 } else if (source == SSCOP_SOURCE_USER)
279 sop->so_flags &= ~SOF_ENDSSCOP;
280 else if ((source == SSCOP_SOURCE_LAST) &&
281 (sop->so_flags & SOF_ENDSSCOP))
282 ep->end_type |= PT_SOURCE_SSCOP;
283
284 /*
285 * Send PDU towards peer
286 */
287 STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
288 sop->so_connvc, (int)m, 0, err);
289
290 if (err)
291 KB_FREEALL(m);
292
293 return (err);
294 }
295
296
297 /*
298 * Build and send ENDAK PDU
299 *
300 * An ENDAK PDU will be constructed and passed down the protocol stack.
301 *
302 * Arguments:
303 * sop pointer to sscop connection control block
304 *
305 * Returns:
306 * 0 PDU successfully built and passed down the stack
307 * else unable to build or send pdu
308 *
309 */
310 int
311 sscop_send_endak(struct sscop *sop)
312 {
313 KBuffer *m;
314 struct endak_q2110_pdu *e2p;
315 struct endak_qsaal_pdu *esp;
316 int err, size;
317
318
319 /*
320 * Get size of PDU
321 */
322 if (sop->so_vers == SSCOP_VERS_QSAAL)
323 size = sizeof(struct endak_qsaal_pdu);
324 else
325 size = sizeof(struct endak_q2110_pdu);
326
327 /*
328 * Get buffer for PDU
329 */
330 KB_ALLOCPKT(m, size, KB_F_NOWAIT, KB_T_HEADER);
331 if (m == NULL)
332 return (1);
333
334 /*
335 * Setup buffer controls
336 */
337 KB_HEADSET(m, MIN(sop->so_headout, KB_BFRLEN(m) - size));
338 KB_LEN(m) = size;
339
340 /*
341 * Build PDU
342 */
343 if (sop->so_vers == SSCOP_VERS_QSAAL) {
344 KB_DATASTART(m, esp, struct endak_qsaal_pdu *);
345 *(u_int *)&esp->endak_type =
346 htonl((PT_ENDAK << PT_TYPE_SHIFT) | 0);
347 } else {
348 KB_DATASTART(m, e2p, struct endak_q2110_pdu *);
349 e2p->endak_rsvd2 = 0;
350 *(u_int *)&e2p->endak_type =
351 htonl((PT_ENDAK << PT_TYPE_SHIFT) | 0);
352 }
353
354 /*
355 * Send PDU towards peer
356 */
357 STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
358 sop->so_connvc, (int)m, 0, err);
359
360 if (err)
361 KB_FREEALL(m);
362
363 return (err);
364 }
365
366
367 /*
368 * Build and send RS PDU
369 *
370 * A RS PDU will be constructed and passed down the protocol stack.
371 * The SSCOP-UU/N(UU) field is not supported.
372 *
373 * Arguments:
374 * sop pointer to sscop connection control block
375 *
376 * Returns:
377 * 0 PDU successfully built and passed down the stack
378 * else unable to build or send pdu
379 *
380 */
381 int
382 sscop_send_rs(struct sscop *sop)
383 {
384 KBuffer *m;
385 struct rs_pdu *rp;
386 int err;
387
388
389 /*
390 * Get buffer for PDU
391 */
392 KB_ALLOCPKT(m, sizeof(struct rs_pdu), KB_F_NOWAIT, KB_T_HEADER);
393 if (m == NULL)
394 return (1);
395
396 /*
397 * Setup buffer controls
398 */
399 KB_HEADSET(m, MIN(sop->so_headout,
400 KB_BFRLEN(m) - sizeof(struct rs_pdu)));
401 KB_LEN(m) = sizeof(struct rs_pdu);
402
403 /*
404 * Build PDU
405 */
406 KB_DATASTART(m, rp, struct rs_pdu *);
407 *(int *)&rp->rs_rsvd[0] = 0;
408 if (sop->so_vers != SSCOP_VERS_QSAAL) {
409 rp->rs_nsq = sop->so_sendconn;
410 rp->rs_nmr = htonl((PT_RS << PT_TYPE_SHIFT) |
411 SEQ_VAL(sop->so_rcvmax));
412 } else {
413 rp->rs_nmr = htonl((PT_RS << PT_TYPE_SHIFT) | 0);
414 }
415
416 /*
417 * Send PDU towards peer
418 */
419 STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
420 sop->so_connvc, (int)m, 0, err);
421
422 if (err)
423 KB_FREEALL(m);
424
425 return (err);
426 }
427
428
429 /*
430 * Build and send RSAK PDU
431 *
432 * An RSAK PDU will be constructed and passed down the protocol stack.
433 *
434 * Arguments:
435 * sop pointer to sscop connection control block
436 *
437 * Returns:
438 * 0 PDU successfully built and passed down the stack
439 * else unable to build or send pdu
440 *
441 */
442 int
443 sscop_send_rsak(struct sscop *sop)
444 {
445 KBuffer *m;
446 struct rsak_q2110_pdu *r2p;
447 struct rsak_qsaal_pdu *rsp;
448 int err, size;
449
450
451 /*
452 * Get size of PDU
453 */
454 if (sop->so_vers == SSCOP_VERS_QSAAL)
455 size = sizeof(struct rsak_qsaal_pdu);
456 else
457 size = sizeof(struct rsak_q2110_pdu);
458
459 /*
460 * Get buffer for PDU
461 */
462 KB_ALLOCPKT(m, size, KB_F_NOWAIT, KB_T_HEADER);
463 if (m == NULL)
464 return (1);
465
466 /*
467 * Setup buffer controls
468 */
469 KB_HEADSET(m, MIN(sop->so_headout, KB_BFRLEN(m) - size));
470 KB_LEN(m) = size;
471
472 /*
473 * Build PDU
474 */
475 if (sop->so_vers == SSCOP_VERS_QSAAL) {
476 KB_DATASTART(m, rsp, struct rsak_qsaal_pdu *);
477 *(u_int *)&rsp->rsaks_type =
478 htonl((PT_RSAK << PT_TYPE_SHIFT) | 0);
479 } else {
480 KB_DATASTART(m, r2p, struct rsak_q2110_pdu *);
481 r2p->rsak_rsvd = 0;
482 r2p->rsak_nmr = htonl((PT_RSAK << PT_TYPE_SHIFT) |
483 SEQ_VAL(sop->so_rcvmax));
484 }
485
486 /*
487 * Send PDU towards peer
488 */
489 STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
490 sop->so_connvc, (int)m, 0, err);
491
492 if (err)
493 KB_FREEALL(m);
494
495 return (err);
496 }
497
498
499 /*
500 * Build and send ER PDU
501 *
502 * An ER PDU will be constructed and passed down the protocol stack.
503 *
504 * Arguments:
505 * sop pointer to sscop connection control block
506 *
507 * Returns:
508 * 0 PDU successfully built and passed down the stack
509 * else unable to build or send pdu
510 *
511 */
512 int
513 sscop_send_er(struct sscop *sop)
514 {
515 KBuffer *m;
516 struct er_pdu *ep;
517 int err;
518
519
520 /*
521 * Get buffer for PDU
522 */
523 KB_ALLOCPKT(m, sizeof(struct er_pdu), KB_F_NOWAIT, KB_T_HEADER);
524 if (m == NULL)
525 return (1);
526
527 /*
528 * Setup buffer controls
529 */
530 KB_HEADSET(m, MIN(sop->so_headout,
531 KB_BFRLEN(m) - sizeof(struct er_pdu)));
532 KB_LEN(m) = sizeof(struct er_pdu);
533
534 /*
535 * Build PDU
536 */
537 KB_DATASTART(m, ep, struct er_pdu *);
538 *(int *)&ep->er_rsvd[0] = 0;
539 ep->er_nsq = sop->so_sendconn;
540 ep->er_nmr = htonl((PT_ER << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_rcvmax));
541
542 /*
543 * Send PDU towards peer
544 */
545 STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
546 sop->so_connvc, (int)m, 0, err);
547
548 if (err)
549 KB_FREEALL(m);
550
551 return (err);
552 }
553
554
555 /*
556 * Build and send ERAK PDU
557 *
558 * An ERAK PDU will be constructed and passed down the protocol stack.
559 *
560 * Arguments:
561 * sop pointer to sscop connection control block
562 *
563 * Returns:
564 * 0 PDU successfully built and passed down the stack
565 * else unable to build or send pdu
566 *
567 */
568 int
569 sscop_send_erak(struct sscop *sop)
570 {
571 KBuffer *m;
572 struct erak_pdu *ep;
573 int err;
574
575
576 /*
577 * Get buffer for PDU
578 */
579 KB_ALLOCPKT(m, sizeof(struct erak_pdu), KB_F_NOWAIT, KB_T_HEADER);
580 if (m == NULL)
581 return (1);
582
583 /*
584 * Setup buffer controls
585 */
586 KB_HEADSET(m, MIN(sop->so_headout,
587 KB_BFRLEN(m) - sizeof(struct erak_pdu)));
588 KB_LEN(m) = sizeof(struct erak_pdu);
589
590 /*
591 * Build PDU
592 */
593 KB_DATASTART(m, ep, struct erak_pdu *);
594 ep->erak_rsvd = 0;
595 ep->erak_nmr = htonl((PT_ERAK << PT_TYPE_SHIFT) |
596 SEQ_VAL(sop->so_rcvmax));
597
598 /*
599 * Send PDU towards peer
600 */
601 STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
602 sop->so_connvc, (int)m, 0, err);
603
604 if (err)
605 KB_FREEALL(m);
606
607 return (err);
608 }
609
610
611 /*
612 * Build and send POLL PDU
613 *
614 * A POLL PDU will be constructed and passed down the protocol stack.
615 *
616 * Arguments:
617 * sop pointer to sscop connection control block
618 *
619 * Returns:
620 * 0 PDU successfully built and passed down the stack
621 * else unable to build or send pdu
622 *
623 */
624 int
625 sscop_send_poll(struct sscop *sop)
626 {
627 KBuffer *m;
628 struct poll_pdu *pp;
629 int err;
630
631
632 /*
633 * Get buffer for PDU
634 */
635 KB_ALLOCPKT(m, sizeof(struct poll_pdu), KB_F_NOWAIT, KB_T_HEADER);
636 if (m == NULL)
637 return (1);
638
639 /*
640 * Setup buffer controls
641 */
642 KB_HEADSET(m, MIN(sop->so_headout,
643 KB_BFRLEN(m) - sizeof(struct poll_pdu)));
644 KB_LEN(m) = sizeof(struct poll_pdu);
645
646 /*
647 * Build PDU
648 */
649 KB_DATASTART(m, pp, struct poll_pdu *);
650 pp->poll_nps = htonl(SEQ_VAL(sop->so_pollsend));
651 pp->poll_ns = htonl((PT_POLL << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_send));
652
653 /*
654 * Send PDU towards peer
655 */
656 STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
657 sop->so_connvc, (int)m, 0, err);
658
659 if (err)
660 KB_FREEALL(m);
661
662 return (err);
663 }
664
665
666 /*
667 * STAT PDU Construction - Initialize for new PDU
668 *
669 * Arguments:
670 * sop pointer to sscop connection control block
671 *
672 * Returns:
673 * addr pointer to initialized buffer
674 * 0 unable to allocate buffer
675 *
676 */
677 static KBuffer *
678 sscop_stat_init(struct sscop *sop)
679 {
680 KBuffer *m;
681
682 #define STAT_INIT_SIZE (sizeof(struct stat_pdu) + 2 * sizeof(sscop_seq))
683
684 /*
685 * Get buffer for PDU
686 */
687 KB_ALLOCPKT(m, STAT_INIT_SIZE, KB_F_NOWAIT, KB_T_HEADER);
688 if (m == NULL)
689 return (0);
690
691 /*
692 * Setup buffer controls
693 */
694 KB_HEADSET(m, sop->so_headout < (KB_BFRLEN(m) - STAT_INIT_SIZE) ?
695 sop->so_headout : 0);
696 KB_LEN(m) = 0;
697
698 return (m);
699 #undef STAT_INIT_SIZE
700 }
701
702
703 /*
704 * STAT PDU Construction - Add List Element
705 *
706 * Arguments:
707 * elem sequence number to add to list
708 * m pointer to current buffer
709 *
710 * Returns:
711 * addr pointer to current buffer (updated)
712 * 0 buffer allocation failure
713 *
714 */
715 static KBuffer *
716 sscop_stat_add(sscop_seq elem, KBuffer *m)
717 {
718 KBuffer *n;
719 sscop_seq *sp;
720 int space;
721
722 /*
723 * See if new element will fit in current buffer
724 */
725 KB_TAILROOM(m, space);
726 if (space < sizeof(elem)) {
727
728 /*
729 * Nope, so get another buffer
730 */
731 KB_ALLOC(n, sizeof(elem), KB_F_NOWAIT, KB_T_DATA);
732 if (n == NULL)
733 return (0);
734
735 /*
736 * Link in new buffer
737 */
738 KB_LINK(n, m);
739 KB_LEN(n) = 0;
740 m = n;
741 }
742
743 /*
744 * Add new element
745 */
746 KB_DATAEND(m, sp, sscop_seq *);
747 *sp = htonl(elem);
748 KB_LEN(m) += sizeof (elem);
749 return (m);
750 }
751
752
753 /*
754 * STAT PDU Construction - Add Trailer and Send
755 *
756 * Arguments:
757 * sop pointer to sscop connection control block
758 * nps received poll sequence number (POLL.N(PS))
759 * head pointer to head of buffer chain
760 * m pointer to current (last) buffer
761 *
762 * Returns:
763 * 0 STAT successfully sent
764 * else unable to send STAT or truncated STAT was sent - buffer freed
765 *
766 */
767 static int
768 sscop_stat_end(struct sscop *sop, sscop_seq nps, KBuffer *head, KBuffer *m)
769 {
770 struct stat_pdu *sp;
771 KBuffer *n;
772 int err, space, trunc = 0;
773
774 /*
775 * See if PDU trailer will fit in current buffer
776 */
777 KB_TAILROOM(m, space);
778 if (space < sizeof(struct stat_pdu)) {
779
780 /*
781 * Doesn't fit, so get another buffer
782 */
783 KB_ALLOC(n, sizeof(struct stat_pdu), KB_F_NOWAIT, KB_T_DATA);
784 if (n == NULL) {
785 /*
786 * Out of buffers - truncate elements and send
787 * what we can, but tell caller that we can't
788 * send any more segments.
789 */
790 trunc = 1;
791 do {
792 KB_LEN(m) -= sizeof(sscop_seq);
793 space += sizeof(sscop_seq);
794 } while (space < sizeof(struct stat_pdu));
795 } else {
796 /*
797 * Link in new buffer
798 */
799 KB_LINK(n, m);
800 KB_LEN(n) = 0;
801 m = n;
802 }
803 }
804
805 /*
806 * Build PDU trailer
807 */
808 KB_DATAEND(m, sp, struct stat_pdu *);
809 sp->stat_nps = htonl(nps);
810 sp->stat_nmr = htonl(sop->so_rcvmax);
811 sp->stat_nr = htonl(sop->so_rcvnext);
812 sp->stat_type = PT_STAT;
813 KB_LEN(m) += sizeof(struct stat_pdu);
814
815 /*
816 * Finally, send the STAT
817 */
818 STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
819 sop->so_connvc, (int)head, 0, err);
820
821 if (err) {
822 /*
823 * We lie about the STACK_CALL failing...
824 */
825 KB_FREEALL(head);
826 }
827
828 if (trunc)
829 return (1);
830 else
831 return (0);
832 }
833
834
835 /*
836 * Check for PDU in Receive Queue
837 *
838 * A receive queue will be searched for an SD PDU matching the requested
839 * sequence number. The caller must supply a pointer to the address of the
840 * PDU in the particular receive queue at which to begin the search. This
841 * function will update that pointer as it traverses the queue.
842 *
843 * Arguments:
844 * sop pointer to sscop connection control block
845 * seq sequence number of PDU to locate
846 * currp address of pointer to PDU in receive queue to start search
847 *
848 * Returns:
849 * 0 reqeusted PDU not in receive queue
850 * 1 requested PDU located in receive queue
851 *
852 */
853 static int
854 sscop_recv_locate(struct sscop *sop, sscop_seq seq, struct pdu_hdr **currp)
855 {
856 sscop_seq cs;
857
858 /*
859 * Search queue until we know the answer
860 */
861 while (1) {
862 /*
863 * If we're at the end of the queue, the PDU isn't there
864 */
865 if (*currp == NULL)
866 return (0);
867
868 /*
869 * Get the current PDU sequence number
870 */
871 cs = (*currp)->ph_ns;
872
873 /*
874 * See if we're at the requested PDU
875 */
876 if (seq == cs)
877 return (1);
878
879 /*
880 * If we're past the requested seq number,
881 * the PDU isn't there
882 */
883 if (SEQ_LT(seq, cs, sop->so_rcvnext))
884 return (0);
885
886 /*
887 * Go to next PDU and keep looking
888 */
889 *currp = (*currp)->ph_recv_lk;
890 }
891 }
892
893
894 /*
895 * Build and send STAT PDU
896 *
897 * A STAT PDU will be constructed and passed down the protocol stack.
898 *
899 * Arguments:
900 * sop pointer to sscop connection control block
901 * nps received poll sequence number (POLL.N(PS))
902 *
903 * Returns:
904 * 0 PDU successfully built and passed down the stack
905 * else unable to build or send complete pdu
906 *
907 */
908 int
909 sscop_send_stat(struct sscop *sop, sscop_seq nps)
910 {
911 KBuffer *head, *curr, *n;
912 struct pdu_hdr *rq = sop->so_recv_hd;
913 sscop_seq i;
914 sscop_seq vrh = sop->so_rcvhigh;
915 sscop_seq vrr = sop->so_rcvnext;
916 int len = 0;
917
918 /*
919 * Initialize for start of STAT PDU
920 */
921 head = sscop_stat_init(sop);
922 if (head == NULL)
923 return (1);
924 curr = head;
925
926 /*
927 * Start with first PDU not yet received
928 */
929 i = vrr;
930
931 /*
932 * Keep looping until we get to last sent PDU
933 */
934 while (i != vrh) {
935
936 /*
937 * Find next missing PDU
938 */
939 while (SEQ_LT(i, vrh, vrr) && sscop_recv_locate(sop, i, &rq)) {
940 SEQ_INCR(i, 1);
941 }
942
943 /*
944 * Add odd (start of missing gap) STAT element
945 */
946 n = sscop_stat_add(i, curr);
947 if (n == NULL) {
948 goto nobufs;
949 }
950 curr = n;
951 len++;
952
953 /*
954 * Have we reached the last sent PDU sequence number??
955 */
956 if (i == vrh) {
957 /*
958 * Yes, then we're done, send STAT
959 */
960 break;
961 }
962
963 /*
964 * Have we reached the max STAT size yet??
965 */
966 if (len >= PDU_MAX_ELEM) {
967 /*
968 * Yes, send this STAT segment
969 */
970 if (sscop_stat_end(sop, nps, head, curr)) {
971 return (1);
972 }
973
974 /*
975 * Start a new segment
976 */
977 head = sscop_stat_init(sop);
978 if (head == NULL)
979 return (1);
980 curr = head;
981
982 /*
983 * Restart missing gap
984 */
985 curr = sscop_stat_add(i, curr);
986 if (curr == NULL) {
987 KB_FREEALL(head);
988 return (1);
989 }
990 len = 1;
991 }
992
993 /*
994 * Now find the end of the missing gap
995 */
996 do {
997 SEQ_INCR(i, 1);
998 } while (SEQ_LT(i, vrh, vrr) &&
999 (sscop_recv_locate(sop, i, &rq) == 0));
1000
1001 /*
1002 * Add even (start of received gap) STAT element
1003 */
1004 n = sscop_stat_add(i, curr);
1005 if (n == NULL) {
1006 goto nobufs;
1007 }
1008 curr = n;
1009 len++;
1010 }
1011
1012 /*
1013 * Finally, send the STAT PDU (or last STAT segment)
1014 */
1015 if (sscop_stat_end(sop, nps, head, curr)) {
1016 return (1);
1017 }
1018
1019 return (0);
1020
1021 nobufs:
1022 /*
1023 * Send a truncated STAT PDU
1024 */
1025 sscop_stat_end(sop, nps, head, curr);
1026
1027 return (1);
1028 }
1029
1030
1031 /*
1032 * Build and send USTAT PDU
1033 *
1034 * A USTAT PDU will be constructed and passed down the protocol stack.
1035 *
1036 * Arguments:
1037 * sop pointer to sscop connection control block
1038 * ns sequence number for second list element
1039 *
1040 * Returns:
1041 * 0 PDU successfully built and passed down the stack
1042 * else unable to build or send pdu
1043 *
1044 */
1045 int
1046 sscop_send_ustat(struct sscop *sop, sscop_seq ns)
1047 {
1048 KBuffer *m;
1049 struct ustat_pdu *up;
1050 int err;
1051
1052
1053 /*
1054 * Get buffer for PDU
1055 */
1056 KB_ALLOCPKT(m, sizeof(struct ustat_pdu), KB_F_NOWAIT, KB_T_HEADER);
1057 if (m == NULL)
1058 return (1);
1059
1060 /*
1061 * Setup buffer controls
1062 */
1063 KB_HEADSET(m, MIN(sop->so_headout,
1064 KB_BFRLEN(m) - sizeof(struct ustat_pdu)));
1065 KB_LEN(m) = sizeof(struct ustat_pdu);
1066
1067 /*
1068 * Build PDU
1069 */
1070 KB_DATASTART(m, up, struct ustat_pdu *);
1071 up->ustat_le1 = htonl(SEQ_VAL(sop->so_rcvhigh));
1072 up->ustat_le2 = htonl(SEQ_VAL(ns));
1073 up->ustat_nmr = htonl(SEQ_VAL(sop->so_rcvmax));
1074 up->ustat_nr =
1075 htonl((PT_USTAT << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_rcvnext));
1076
1077 /*
1078 * Send PDU towards peer
1079 */
1080 STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
1081 sop->so_connvc, (int)m, 0, err);
1082
1083 if (err)
1084 KB_FREEALL(m);
1085
1086 return (err);
1087 }
1088
1089
1090 /*
1091 * Build and send UD PDU
1092 *
1093 * A UD PDU will be constructed and passed down the protocol stack.
1094 *
1095 * Arguments:
1096 * sop pointer to sscop connection control block
1097 * m pointer to user data buffer chain
1098 *
1099 * Returns:
1100 * 0 PDU successfully built and passed down the stack
1101 * else unable to build or send pdu (buffer released)
1102 *
1103 */
1104 int
1105 sscop_send_ud(struct sscop *sop, KBuffer *m)
1106 {
1107 KBuffer *ml, *n;
1108 int len = 0, err;
1109 int pad, trlen, space;
1110 u_char *cp;
1111
1112 /*
1113 * Count data and get to last buffer in chain
1114 */
1115 for (ml = m; ; ml = KB_NEXT(ml)) {
1116 len += KB_LEN(ml);
1117 if (KB_NEXT(ml) == NULL)
1118 break;
1119 }
1120
1121 /*
1122 * Verify data length
1123 */
1124 if (len > sop->so_parm.sp_maxinfo) {
1125 KB_FREEALL(m);
1126 sscop_abort(sop, "sscop: maximum unitdata size exceeded\n");
1127 return (1);
1128 }
1129
1130 /*
1131 * Figure out how much padding we'll need
1132 */
1133 pad = ((len + (PDU_PAD_ALIGN - 1)) & ~(PDU_PAD_ALIGN - 1)) - len;
1134 trlen = pad + sizeof(struct ud_pdu);
1135
1136 /*
1137 * Get space for PDU trailer and padding
1138 */
1139 KB_TAILROOM(ml, space);
1140 if (space < trlen) {
1141 /*
1142 * Allocate & link buffer for pad and trailer
1143 */
1144 KB_ALLOC(n, trlen, KB_F_NOWAIT, KB_T_HEADER);
1145 if (n == NULL)
1146 return (1);
1147
1148 KB_LEN(n) = 0;
1149 KB_LINK(n, ml);
1150 ml = n;
1151 }
1152
1153 /*
1154 * Build the PDU trailer
1155 *
1156 * Since we can't be sure of alignment in the buffers, we
1157 * have to move this a byte at a time.
1158 */
1159 KB_DATAEND(ml, cp, u_char *);
1160 cp += pad;
1161 *cp++ = (pad << PT_PAD_SHIFT) | PT_UD;
1162 KM_ZERO(cp, 3);
1163 KB_LEN(ml) += trlen;
1164
1165 /*
1166 * Now pass PDU down the stack
1167 */
1168 STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
1169 sop->so_connvc, (int)m, 0, err);
1170 if (err) {
1171 KB_FREEALL(m);
1172 return (1);
1173 }
1174
1175 return (0);
1176 }
1177
1178
1179 /*
1180 * Print an SSCOP PDU
1181 *
1182 * Arguments:
1183 * sop pointer to sscop connection control block
1184 * m pointer to pdu buffer chain
1185 * msg pointer to message string
1186 *
1187 * Returns:
1188 * none
1189 *
1190 */
1191 void
1192 sscop_pdu_print(struct sscop *sop, KBuffer *m, char *msg)
1193 {
1194 char buf[128];
1195 struct vccb *vcp;
1196
1197 vcp = sop->so_connvc->cvc_vcc;
1198 ksnprintf(buf, sizeof(buf),
1199 "sscop %s: vcc=(%d,%d)\n", msg, vcp->vc_vpi, vcp->vc_vci);
1200 atm_pdu_print(m, buf);
1201 }
1202
DragonFly BSD