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