?  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 / q2110_sigcpcs.c
blob53bdebab34aa1dca4871e45da261459bf4ec96c0
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/q2110_sigcpcs.c,v 1.4 2000/01/17 20:49:49 mks Exp $
27 * @(#) $DragonFly: src/sys/netproto/atm/uni/q2110_sigcpcs.c,v 1.7 2006/01/14 13:36:39 swildner Exp $
28 */
29
30 /*
31 * ATM Forum UNI Support
32 * ---------------------
33 *
34 * ITU-T Q.2110 - Process CPCS-signals (SSCOP PDUs)
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 void sscop_bgn_outconn (struct sscop *, KBuffer *, caddr_t);
49 static void sscop_bgn_inconn (struct sscop *, KBuffer *, caddr_t);
50 static void sscop_bgn_ready (struct sscop *, KBuffer *, caddr_t);
51 static void sscop_bgrej_outrecov (struct sscop *, KBuffer *, caddr_t);
52 static void sscop_end_outrecov (struct sscop *, KBuffer *, caddr_t);
53 static void sscop_end_ready (struct sscop *, KBuffer *, caddr_t);
54 static void sscop_endak_outrecov (struct sscop *, KBuffer *, caddr_t);
55 static void sscop_rs_outresyn (struct sscop *, KBuffer *, caddr_t);
56 static void sscop_rs_inresyn (struct sscop *, KBuffer *, caddr_t);
57 static void sscop_rs_outrecov (struct sscop *, KBuffer *, caddr_t);
58 static void sscop_rs_ready (struct sscop *, KBuffer *, caddr_t);
59 static void sscop_er_error (struct sscop *, KBuffer *, caddr_t);
60 static void sscop_er_idle (struct sscop *, KBuffer *, caddr_t);
61 static void sscop_er_outrecov (struct sscop *, KBuffer *, caddr_t);
62 static void sscop_er_recovrsp (struct sscop *, KBuffer *, caddr_t);
63 static void sscop_er_inrecov (struct sscop *, KBuffer *, caddr_t);
64 static void sscop_er_ready (struct sscop *, KBuffer *, caddr_t);
65 static void sscop_erak_error (struct sscop *, KBuffer *, caddr_t);
66 static void sscop_erak_idle (struct sscop *, KBuffer *, caddr_t);
67 static void sscop_erak_outrecov (struct sscop *, KBuffer *, caddr_t);
68 static void sscop_sd_ready (struct sscop *, KBuffer *, caddr_t);
69 static void sscop_poll_ready (struct sscop *, KBuffer *, caddr_t);
70
71
72 /*
73 * PDU type state lookup tables
74 */
75 /* BGN PDU */
76 static void (*sscop_bgn_tab[SOS_NUMSTATES])
77 (struct sscop *, KBuffer *, caddr_t) = {
78 NULL, /* SOS_INST */
79 sscop_bgn_idle, /* SOS_IDLE */
80 sscop_bgn_outconn, /* SOS_OUTCONN */
81 sscop_bgn_inconn, /* SOS_INCONN */
82 sscop_bgn_outdisc, /* SOS_OUTDISC */
83 sscop_bgn_outresyn, /* SOS_OUTRESYN */
84 sscop_bgn_inresyn, /* SOS_INRESYN */
85 sscop_bgn_inresyn, /* SOS_OUTRECOV */
86 sscop_bgn_inresyn, /* SOS_RECOVRSP */
87 sscop_bgn_inresyn, /* SOS_INRECOV */
88 sscop_bgn_ready, /* SOS_READY */
89 sscop_noop /* SOS_TERM */
90 };
91
92 /* BGAK PDU */
93 static void (*sscop_bgak_tab[SOS_NUMSTATES])
94 (struct sscop *, KBuffer *, caddr_t) = {
95 NULL, /* SOS_INST */
96 sscop_bgak_idle, /* SOS_IDLE */
97 sscop_bgak_outconn, /* SOS_OUTCONN */
98 sscop_bgak_error, /* SOS_INCONN */
99 sscop_noop, /* SOS_OUTDISC */
100 sscop_noop, /* SOS_OUTRESYN */
101 sscop_bgak_error, /* SOS_INRESYN */
102 sscop_bgak_error, /* SOS_OUTRECOV */
103 sscop_bgak_error, /* SOS_RECOVRSP */
104 sscop_bgak_error, /* SOS_INRECOV */
105 sscop_noop, /* SOS_READY */
106 sscop_noop /* SOS_TERM */
107 };
108
109 /* BGREJ PDU */
110 static void (*sscop_bgrej_tab[SOS_NUMSTATES])
111 (struct sscop *, KBuffer *, caddr_t) = {
112 NULL, /* SOS_INST */
113 sscop_bgrej_error, /* SOS_IDLE */
114 sscop_bgrej_outconn, /* SOS_OUTCONN */
115 sscop_bgrej_inconn, /* SOS_INCONN */
116 sscop_endak_outdisc, /* SOS_OUTDISC */
117 sscop_bgrej_outresyn, /* SOS_OUTRESYN */
118 sscop_bgrej_inconn, /* SOS_INRESYN */
119 sscop_bgrej_outrecov, /* SOS_OUTRECOV */
120 sscop_bgrej_inconn, /* SOS_RECOVRSP */
121 sscop_bgrej_inconn, /* SOS_INRECOV */
122 sscop_bgrej_ready, /* SOS_READY */
123 sscop_noop /* SOS_TERM */
124 };
125
126 /* END PDU */
127 static void (*sscop_end_tab[SOS_NUMSTATES])
128 (struct sscop *, KBuffer *, caddr_t) = {
129 NULL, /* SOS_INST */
130 sscop_end_idle, /* SOS_IDLE */
131 sscop_noop, /* SOS_OUTCONN */
132 sscop_end_inconn, /* SOS_INCONN */
133 sscop_end_outdisc, /* SOS_OUTDISC */
134 sscop_end_inconn, /* SOS_OUTRESYN */
135 sscop_end_inconn, /* SOS_INRESYN */
136 sscop_end_outrecov, /* SOS_OUTRECOV */
137 sscop_end_inconn, /* SOS_RECOVRSP */
138 sscop_end_inconn, /* SOS_INRECOV */
139 sscop_end_ready, /* SOS_READY */
140 sscop_noop /* SOS_TERM */
141 };
142
143 /* ENDAK PDU */
144 static void (*sscop_endak_tab[SOS_NUMSTATES])
145 (struct sscop *, KBuffer *, caddr_t) = {
146 NULL, /* SOS_INST */
147 sscop_noop, /* SOS_IDLE */
148 sscop_noop, /* SOS_OUTCONN */
149 sscop_endak_inconn, /* SOS_INCONN */
150 sscop_endak_outdisc, /* SOS_OUTDISC */
151 sscop_endak_inconn, /* SOS_OUTRESYN */
152 sscop_endak_inconn, /* SOS_INRESYN */
153 sscop_endak_outrecov, /* SOS_OUTRECOV */
154 sscop_endak_inconn, /* SOS_RECOVRSP */
155 sscop_endak_inconn, /* SOS_INRECOV */
156 sscop_endak_ready, /* SOS_READY */
157 sscop_noop /* SOS_TERM */
158 };
159
160 /* RS PDU */
161 static void (*sscop_rs_tab[SOS_NUMSTATES])
162 (struct sscop *, KBuffer *, caddr_t) = {
163 NULL, /* SOS_INST */
164 sscop_rs_idle, /* SOS_IDLE */
165 sscop_noop, /* SOS_OUTCONN */
166 sscop_rs_error, /* SOS_INCONN */
167 sscop_noop, /* SOS_OUTDISC */
168 sscop_rs_outresyn, /* SOS_OUTRESYN */
169 sscop_rs_inresyn, /* SOS_INRESYN */
170 sscop_rs_outrecov, /* SOS_OUTRECOV */
171 sscop_rs_outrecov, /* SOS_RECOVRSP */
172 sscop_rs_outrecov, /* SOS_INRECOV */
173 sscop_rs_ready, /* SOS_READY */
174 sscop_noop /* SOS_TERM */
175 };
176
177 /* RSAK PDU */
178 static void (*sscop_rsak_tab[SOS_NUMSTATES])
179 (struct sscop *, KBuffer *, caddr_t) = {
180 NULL, /* SOS_INST */
181 sscop_rsak_idle, /* SOS_IDLE */
182 sscop_noop, /* SOS_OUTCONN */
183 sscop_rsak_error, /* SOS_INCONN */
184 sscop_noop, /* SOS_OUTDISC */
185 sscop_rsak_outresyn, /* SOS_OUTRESYN */
186 sscop_rsak_error, /* SOS_INRESYN */
187 sscop_rsak_error, /* SOS_OUTRECOV */
188 sscop_rsak_error, /* SOS_RECOVRSP */
189 sscop_rsak_error, /* SOS_INRECOV */
190 sscop_noop, /* SOS_READY */
191 sscop_noop /* SOS_TERM */
192 };
193
194 /* ER PDU */
195 static void (*sscop_er_tab[SOS_NUMSTATES])
196 (struct sscop *, KBuffer *, caddr_t) = {
197 NULL, /* SOS_INST */
198 sscop_er_idle, /* SOS_IDLE */
199 sscop_noop, /* SOS_OUTCONN */
200 sscop_er_error, /* SOS_INCONN */
201 sscop_noop, /* SOS_OUTDISC */
202 sscop_noop, /* SOS_OUTRESYN */
203 sscop_er_error, /* SOS_INRESYN */
204 sscop_er_outrecov, /* SOS_OUTRECOV */
205 sscop_er_recovrsp, /* SOS_RECOVRSP */
206 sscop_er_inrecov, /* SOS_INRECOV */
207 sscop_er_ready, /* SOS_READY */
208 sscop_noop /* SOS_TERM */
209 };
210
211 /* ERAK PDU */
212 static void (*sscop_erak_tab[SOS_NUMSTATES])
213 (struct sscop *, KBuffer *, caddr_t) = {
214 NULL, /* SOS_INST */
215 sscop_erak_idle, /* SOS_IDLE */
216 sscop_noop, /* SOS_OUTCONN */
217 sscop_erak_error, /* SOS_INCONN */
218 sscop_noop, /* SOS_OUTDISC */
219 sscop_noop, /* SOS_OUTRESYN */
220 sscop_erak_error, /* SOS_INRESYN */
221 sscop_erak_outrecov, /* SOS_OUTRECOV */
222 sscop_noop, /* SOS_RECOVRSP */
223 sscop_erak_error, /* SOS_INRECOV */
224 sscop_noop, /* SOS_READY */
225 sscop_noop /* SOS_TERM */
226 };
227
228 /* SD PDU */
229 static void (*sscop_sd_tab[SOS_NUMSTATES])
230 (struct sscop *, KBuffer *, caddr_t) = {
231 NULL, /* SOS_INST */
232 sscop_sd_idle, /* SOS_IDLE */
233 sscop_noop, /* SOS_OUTCONN */
234 sscop_sd_inconn, /* SOS_INCONN */
235 sscop_noop, /* SOS_OUTDISC */
236 sscop_noop, /* SOS_OUTRESYN */
237 sscop_sd_inconn, /* SOS_INRESYN */
238 sscop_noop, /* SOS_OUTRECOV */
239 sscop_noop, /* SOS_RECOVRSP */
240 sscop_sd_inconn, /* SOS_INRECOV */
241 sscop_sd_ready, /* SOS_READY */
242 sscop_noop /* SOS_TERM */
243 };
244
245 /* POLL PDU */
246 static void (*sscop_poll_tab[SOS_NUMSTATES])
247 (struct sscop *, KBuffer *, caddr_t) = {
248 NULL, /* SOS_INST */
249 sscop_poll_idle, /* SOS_IDLE */
250 sscop_noop, /* SOS_OUTCONN */
251 sscop_poll_inconn, /* SOS_INCONN */
252 sscop_noop, /* SOS_OUTDISC */
253 sscop_noop, /* SOS_OUTRESYN */
254 sscop_poll_inconn, /* SOS_INRESYN */
255 sscop_noop, /* SOS_OUTRECOV */
256 sscop_noop, /* SOS_RECOVRSP */
257 sscop_poll_inconn, /* SOS_INRECOV */
258 sscop_poll_ready, /* SOS_READY */
259 sscop_noop /* SOS_TERM */
260 };
261
262 /* STAT PDU */
263 static void (*sscop_stat_tab[SOS_NUMSTATES])
264 (struct sscop *, KBuffer *, caddr_t) = {
265 NULL, /* SOS_INST */
266 sscop_stat_idle, /* SOS_IDLE */
267 sscop_noop, /* SOS_OUTCONN */
268 sscop_stat_inconn, /* SOS_INCONN */
269 sscop_noop, /* SOS_OUTDISC */
270 sscop_noop, /* SOS_OUTRESYN */
271 sscop_stat_inconn, /* SOS_INRESYN */
272 sscop_noop, /* SOS_OUTRECOV */
273 sscop_stat_inconn, /* SOS_RECOVRSP */
274 sscop_stat_inconn, /* SOS_INRECOV */
275 sscop_stat_ready, /* SOS_READY */
276 sscop_noop /* SOS_TERM */
277 };
278
279 /* USTAT PDU */
280 static void (*sscop_ustat_tab[SOS_NUMSTATES])
281 (struct sscop *, KBuffer *, caddr_t) = {
282 NULL, /* SOS_INST */
283 sscop_ustat_idle, /* SOS_IDLE */
284 sscop_noop, /* SOS_OUTCONN */
285 sscop_ustat_inconn, /* SOS_INCONN */
286 sscop_noop, /* SOS_OUTDISC */
287 sscop_noop, /* SOS_OUTRESYN */
288 sscop_ustat_inconn, /* SOS_INRESYN */
289 sscop_noop, /* SOS_OUTRECOV */
290 sscop_ustat_inconn, /* SOS_RECOVRSP */
291 sscop_ustat_inconn, /* SOS_INRECOV */
292 sscop_ustat_ready, /* SOS_READY */
293 sscop_noop /* SOS_TERM */
294 };
295
296 /* UD PDU */
297 static void (*sscop_ud_tab[SOS_NUMSTATES])
298 (struct sscop *, KBuffer *, caddr_t) = {
299 NULL, /* SOS_INST */
300 sscop_ud_all, /* SOS_IDLE */
301 sscop_ud_all, /* SOS_OUTCONN */
302 sscop_ud_all, /* SOS_INCONN */
303 sscop_ud_all, /* SOS_OUTDISC */
304 sscop_ud_all, /* SOS_OUTRESYN */
305 sscop_ud_all, /* SOS_INRESYN */
306 sscop_ud_all, /* SOS_OUTRECOV */
307 sscop_ud_all, /* SOS_RECOVRSP */
308 sscop_ud_all, /* SOS_INRECOV */
309 sscop_ud_all, /* SOS_READY */
310 sscop_noop /* SOS_TERM */
311 };
312
313 /* MD PDU */
314 static void (*sscop_md_tab[SOS_NUMSTATES])
315 (struct sscop *, KBuffer *, caddr_t) = {
316 NULL, /* SOS_INST */
317 sscop_md_all, /* SOS_IDLE */
318 sscop_md_all, /* SOS_OUTCONN */
319 sscop_md_all, /* SOS_INCONN */
320 sscop_md_all, /* SOS_OUTDISC */
321 sscop_md_all, /* SOS_OUTRESYN */
322 sscop_md_all, /* SOS_INRESYN */
323 sscop_md_all, /* SOS_OUTRECOV */
324 sscop_md_all, /* SOS_RECOVRSP */
325 sscop_md_all, /* SOS_INRECOV */
326 sscop_md_all, /* SOS_READY */
327 sscop_noop /* SOS_TERM */
328 };
329
330
331 /*
332 * PDU type lookup table
333 */
334 void (*(*sscop_q2110_pdutab[]))
335 (struct sscop *, KBuffer *, caddr_t) = {
336 NULL,
337 sscop_bgn_tab,
338 sscop_bgak_tab,
339 sscop_end_tab,
340 sscop_endak_tab,
341 sscop_rs_tab,
342 sscop_rsak_tab,
343 sscop_bgrej_tab,
344 sscop_sd_tab,
345 sscop_er_tab,
346 sscop_poll_tab,
347 sscop_stat_tab,
348 sscop_ustat_tab,
349 sscop_ud_tab,
350 sscop_md_tab,
351 sscop_erak_tab
352 };
353
354
355 /*
356 * BGN PDU / SOS_OUTCONN Processor
357 *
358 * Arguments:
359 * sop pointer to sscop connection block
360 * m pointer to PDU buffer (without trailer)
361 * trlr pointer to PDU trailer
362 *
363 * Returns:
364 * none
365 *
366 */
367 static void
368 sscop_bgn_outconn(struct sscop *sop, KBuffer *m, caddr_t trlr)
369 {
370 struct bgn_pdu *bp = (struct bgn_pdu *)trlr;
371 int err;
372
373 /*
374 * If retransmitted BGN, ignore it
375 */
376 if (sscop_is_rexmit(sop, bp->bgn_nsq)) {
377 KB_FREEALL(m);
378 return;
379 }
380
381 /*
382 * Stop retransmit timer
383 */
384 sop->so_timer[SSCOP_T_CC] = 0;
385
386 /*
387 * Initialize state variables
388 */
389 SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr));
390 SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin);
391 q2110_init_state(sop);
392
393 /*
394 * Return an ACK to peer
395 */
396 sscop_send_bgak(sop);
397
398 /*
399 * Notify user of connection establishment
400 */
401 STACK_CALL(SSCOP_ESTABLISH_CNF, sop->so_upper, sop->so_toku,
402 sop->so_connvc, (int)m, 0, err);
403 if (err) {
404 KB_FREEALL(m);
405 sscop_abort(sop, "stack memory\n");
406 return;
407 }
408
409 /*
410 * Start data transfer timers
411 */
412 sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll;
413 sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp;
414
415 /*
416 * OK, we're ready for data
417 */
418 sop->so_state = SOS_READY;
419
420 /*
421 * See if transmit queues need servicing
422 */
423 if (sop->so_flags & SOF_XMITSRVC)
424 sscop_service_xmit(sop);
425
426 return;
427 }
428
429
430 /*
431 * BGN PDU / SOS_INCONN Processor
432 *
433 * Arguments:
434 * sop pointer to sscop connection block
435 * m pointer to PDU buffer (without trailer)
436 * trlr pointer to PDU trailer
437 *
438 * Returns:
439 * none
440 *
441 */
442 static void
443 sscop_bgn_inconn(struct sscop *sop, KBuffer *m, caddr_t trlr)
444 {
445 struct bgn_pdu *bp = (struct bgn_pdu *)trlr;
446 int err;
447
448 /*
449 * If retransmitted BGN, ignore it
450 */
451 if (sscop_is_rexmit(sop, bp->bgn_nsq)) {
452 KB_FREEALL(m);
453 return;
454 }
455
456 /*
457 * Initialize transmit window
458 */
459 SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr));
460
461 /*
462 * First, tell user current connection has been released
463 */
464 STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
465 sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_USER, err);
466 if (err) {
467 KB_FREEALL(m);
468 sscop_abort(sop, "stack memory\n");
469 return;
470 }
471
472 /*
473 * Now, tell user of new connection establishment
474 */
475 STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku,
476 sop->so_connvc, (int)m, 0, err);
477 if (err) {
478 KB_FREEALL(m);
479 sscop_abort(sop, "stack memory\n");
480 return;
481 }
482
483 return;
484 }
485
486
487 /*
488 * BGN PDU / SOS_READY Processor
489 *
490 * Arguments:
491 * sop pointer to sscop connection block
492 * m pointer to PDU buffer (without trailer)
493 * trlr pointer to PDU trailer
494 *
495 * Returns:
496 * none
497 *
498 */
499 static void
500 sscop_bgn_ready(struct sscop *sop, KBuffer *m, caddr_t trlr)
501 {
502 struct bgn_pdu *bp = (struct bgn_pdu *)trlr;
503 int err;
504
505 /*
506 * If retransmitted BGN, just ACK it again
507 */
508 if (sscop_is_rexmit(sop, bp->bgn_nsq)) {
509 KB_FREEALL(m);
510 sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp;
511 sscop_send_bgak(sop);
512 return;
513 }
514
515 /*
516 * Stop data transfer timers
517 */
518 sop->so_timer[SSCOP_T_POLL] = 0;
519 sop->so_timer[SSCOP_T_NORESP] = 0;
520 sop->so_timer[SSCOP_T_IDLE] = 0;
521 sop->so_flags &= ~SOF_KEEPALIVE;
522
523 /*
524 * Initialize transmit window
525 */
526 SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr));
527
528 /*
529 * Clear out appropriate queues
530 */
531 q2110_prep_retrieve(sop);
532
533 /*
534 * Tell user current connection has been released
535 */
536 STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
537 sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_USER, err);
538 if (err) {
539 KB_FREEALL(m);
540 sscop_abort(sop, "stack memory\n");
541 return;
542 }
543
544 /*
545 * Tell user of incoming connection
546 */
547 STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku,
548 sop->so_connvc, (int)m, 0, err);
549 if (err) {
550 KB_FREEALL(m);
551 sscop_abort(sop, "stack memory\n");
552 return;
553 }
554
555 /*
556 * Wait for user's response
557 */
558 sop->so_state = SOS_INCONN;
559
560 return;
561 }
562
563
564 /*
565 * BGREJ PDU / SOS_OUTRECOV Processor
566 *
567 * Arguments:
568 * sop pointer to sscop connection block
569 * m pointer to PDU buffer (without trailer)
570 * trlr pointer to PDU trailer
571 *
572 * Returns:
573 * none
574 *
575 */
576 static void
577 sscop_bgrej_outrecov(struct sscop *sop, KBuffer *m, caddr_t trlr)
578 {
579 int err;
580
581 /*
582 * Stop retransmit timer
583 */
584 sop->so_timer[SSCOP_T_CC] = 0;
585
586 /*
587 * Report protocol error
588 */
589 sscop_bgrej_error(sop, m, trlr);
590
591 /*
592 * Notify user of connection failure
593 */
594 STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
595 sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
596 if (err) {
597 sscop_abort(sop, "stack memory\n");
598 return;
599 }
600
601 /*
602 * Clear receiver buffer
603 */
604 sscop_rcvr_drain(sop);
605
606 /*
607 * Back to idle state
608 */
609 sop->so_state = SOS_IDLE;
610
611 return;
612 }
613
614
615 /*
616 * END PDU / SOS_OUTRECOV Processor
617 *
618 * Arguments:
619 * sop pointer to sscop connection block
620 * m pointer to PDU buffer (without trailer)
621 * trlr pointer to PDU trailer
622 *
623 * Returns:
624 * none
625 *
626 */
627 static void
628 sscop_end_outrecov(struct sscop *sop, KBuffer *m, caddr_t trlr)
629 {
630 struct end_pdu *ep = (struct end_pdu *)trlr;
631 int err, source;
632
633 /*
634 * Stop retransmit timer
635 */
636 sop->so_timer[SSCOP_T_CC] = 0;
637
638 /*
639 * Acknowledge END
640 */
641 sscop_send_endak(sop);
642
643 /*
644 * Get Source value
645 */
646 if (ep->end_type & PT_SOURCE_SSCOP)
647 source = SSCOP_SOURCE_SSCOP;
648 else
649 source = SSCOP_SOURCE_USER;
650
651 /*
652 * Notify user of connection termination
653 */
654 STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
655 sop->so_connvc, (int)m, source, err);
656 if (err) {
657 KB_FREEALL(m);
658 sscop_abort(sop, "stack memory\n");
659 return;
660 }
661
662 /*
663 * Clear receiver buffer
664 */
665 sscop_rcvr_drain(sop);
666
667 /*
668 * Back to idle state
669 */
670 sop->so_state = SOS_IDLE;
671
672 return;
673 }
674
675
676 /*
677 * END PDU / SOS_READY Processor
678 *
679 * Arguments:
680 * sop pointer to sscop connection block
681 * m pointer to PDU buffer (without trailer)
682 * trlr pointer to PDU trailer
683 *
684 * Returns:
685 * none
686 *
687 */
688 static void
689 sscop_end_ready(struct sscop *sop, KBuffer *m, caddr_t trlr)
690 {
691 struct end_pdu *ep = (struct end_pdu *)trlr;
692 int err, source;
693
694 /*
695 * Stop data transfer timers
696 */
697 sop->so_timer[SSCOP_T_POLL] = 0;
698 sop->so_timer[SSCOP_T_NORESP] = 0;
699 sop->so_timer[SSCOP_T_IDLE] = 0;
700 sop->so_flags &= ~SOF_KEEPALIVE;
701
702 /*
703 * Acknowledge END
704 */
705 sscop_send_endak(sop);
706
707 /*
708 * Get Source value
709 */
710 if (ep->end_type & PT_SOURCE_SSCOP)
711 source = SSCOP_SOURCE_SSCOP;
712 else
713 source = SSCOP_SOURCE_USER;
714
715 /*
716 * Notify user of connection termination
717 */
718 STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
719 sop->so_connvc, (int)m, source, err);
720 if (err) {
721 KB_FREEALL(m);
722 sscop_abort(sop, "stack memory\n");
723 return;
724 }
725
726 /*
727 * Clear out appropriate queues
728 */
729 q2110_prep_retrieve(sop);
730
731 /*
732 * Back to idle state
733 */
734 sop->so_state = SOS_IDLE;
735
736 return;
737 }
738
739
740 /*
741 * ENDAK PDU / SOS_OUTRECOV Processor
742 *
743 * Arguments:
744 * sop pointer to sscop connection block
745 * m pointer to PDU buffer (without trailer)
746 * trlr pointer to PDU trailer
747 *
748 * Returns:
749 * none
750 *
751 */
752 static void
753 sscop_endak_outrecov(struct sscop *sop, KBuffer *m, caddr_t trlr)
754 {
755 int err;
756
757 /*
758 * Stop retransmit timer
759 */
760 sop->so_timer[SSCOP_T_CC] = 0;
761
762 /*
763 * Report protocol error
764 */
765 sscop_endak_error(sop, m, trlr);
766
767 /*
768 * Notify user of connection failure
769 */
770 STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
771 sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
772 if (err) {
773 sscop_abort(sop, "stack memory\n");
774 return;
775 }
776
777 /*
778 * Clear receiver buffer
779 */
780 sscop_rcvr_drain(sop);
781
782 /*
783 * Back to idle state
784 */
785 sop->so_state = SOS_IDLE;
786
787 return;
788 }
789
790
791 /*
792 * RS PDU / SOS_OUTRESYN Processor
793 *
794 * Arguments:
795 * sop pointer to sscop connection block
796 * m pointer to PDU buffer (without trailer)
797 * trlr pointer to PDU trailer
798 *
799 * Returns:
800 * none
801 *
802 */
803 static void
804 sscop_rs_outresyn(struct sscop *sop, KBuffer *m, caddr_t trlr)
805 {
806 struct rs_pdu *rp = (struct rs_pdu *)trlr;
807 int err;
808
809 /*
810 * If retransmitted RS, ignore it
811 */
812 if (sscop_is_rexmit(sop, rp->rs_nsq)) {
813 KB_FREEALL(m);
814 return;
815 }
816
817 /*
818 * Stop retransmit timer
819 */
820 sop->so_timer[SSCOP_T_CC] = 0;
821
822 /*
823 * Initialize state variables
824 */
825 SEQ_SET(sop->so_sendmax, ntohl(rp->rs_nmr));
826 SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin);
827 q2110_init_state(sop);
828
829 /*
830 * Free PDU buffers
831 */
832 KB_FREEALL(m);
833
834 /*
835 * Return an ACK to peer
836 */
837 sscop_send_rsak(sop);
838
839 /*
840 * Notify user of connection resynchronization
841 */
842 STACK_CALL(SSCOP_RESYNC_CNF, sop->so_upper, sop->so_toku,
843 sop->so_connvc, 0, 0, err);
844 if (err) {
845 sscop_abort(sop, "stack memory\n");
846 return;
847 }
848
849 /*
850 * Start data transfer timers
851 */
852 sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll;
853 sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp;
854
855 /*
856 * OK, we're ready for data
857 */
858 sop->so_state = SOS_READY;
859
860 /*
861 * See if transmit queues need servicing
862 */
863 if (sop->so_flags & SOF_XMITSRVC)
864 sscop_service_xmit(sop);
865
866 return;
867 }
868
869
870 /*
871 * RS PDU / SOS_INRESYN Processor
872 *
873 * Arguments:
874 * sop pointer to sscop connection block
875 * m pointer to PDU buffer (without trailer)
876 * trlr pointer to PDU trailer
877 *
878 * Returns:
879 * none
880 *
881 */
882 static void
883 sscop_rs_inresyn(struct sscop *sop, KBuffer *m, caddr_t trlr)
884 {
885 struct rs_pdu *rp = (struct rs_pdu *)trlr;
886
887 /*
888 * If retransmitted RS, ignore it
889 */
890 if (sscop_is_rexmit(sop, rp->rs_nsq)) {
891 KB_FREEALL(m);
892 return;
893 }
894
895 /*
896 * Report error condition
897 */
898 sscop_rs_error(sop, m, trlr);
899
900 return;
901 }
902
903
904 /*
905 * RS PDU / SOS_OUTRECOV Processor
906 *
907 * Arguments:
908 * sop pointer to sscop connection block
909 * m pointer to PDU buffer (without trailer)
910 * trlr pointer to PDU trailer
911 *
912 * Returns:
913 * none
914 *
915 */
916 static void
917 sscop_rs_outrecov(struct sscop *sop, KBuffer *m, caddr_t trlr)
918 {
919 struct rs_pdu *rp = (struct rs_pdu *)trlr;
920 int err;
921
922 /*
923 * If retransmitted RS, report an error
924 */
925 if (sscop_is_rexmit(sop, rp->rs_nsq)) {
926 sscop_rs_error(sop, m, trlr);
927 return;
928 }
929
930 /*
931 * Stop retransmit timer
932 */
933 sop->so_timer[SSCOP_T_CC] = 0;
934
935 /*
936 * Initialize transmit window
937 */
938 SEQ_SET(sop->so_sendmax, ntohl(rp->rs_nmr));
939
940 /*
941 * Notify user of connection resynchronization
942 */
943 STACK_CALL(SSCOP_RESYNC_IND, sop->so_upper, sop->so_toku,
944 sop->so_connvc, (int)m, 0, err);
945 if (err) {
946 KB_FREEALL(m);
947 sscop_abort(sop, "stack memory\n");
948 return;
949 }
950
951 /*
952 * Clear receiver buffer
953 */
954 sscop_rcvr_drain(sop);
955
956 /*
957 * Wait for user response
958 */
959 sop->so_state = SOS_INRESYN;
960
961 return;
962 }
963
964
965 /*
966 * RS PDU / SOS_READY Processor
967 *
968 * Arguments:
969 * sop pointer to sscop connection block
970 * m pointer to PDU buffer (without trailer)
971 * trlr pointer to PDU trailer
972 *
973 * Returns:
974 * none
975 *
976 */
977 static void
978 sscop_rs_ready(struct sscop *sop, KBuffer *m, caddr_t trlr)
979 {
980 struct rs_pdu *rp = (struct rs_pdu *)trlr;
981 int err;
982
983 /*
984 * If retransmitted RS, just ACK it
985 */
986 if (sscop_is_rexmit(sop, rp->rs_nsq)) {
987 KB_FREEALL(m);
988 sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp;
989 sscop_send_rsak(sop);
990 return;
991 }
992
993 /*
994 * Stop data transfer timers
995 */
996 sop->so_timer[SSCOP_T_POLL] = 0;
997 sop->so_timer[SSCOP_T_NORESP] = 0;
998 sop->so_timer[SSCOP_T_IDLE] = 0;
999 sop->so_flags &= ~SOF_KEEPALIVE;
1000
1001 /*
1002 * Initialize transmit window
1003 */
1004 SEQ_SET(sop->so_sendmax, ntohl(rp->rs_nmr));
1005
1006 /*
1007 * Notify user of connection resynchronization
1008 */
1009 STACK_CALL(SSCOP_RESYNC_IND, sop->so_upper, sop->so_toku,
1010 sop->so_connvc, (int)m, 0, err);
1011 if (err) {
1012 KB_FREEALL(m);
1013 sscop_abort(sop, "stack memory\n");
1014 return;
1015 }
1016
1017 /*
1018 * Clear out appropriate queues
1019 */
1020 q2110_prep_retrieve(sop);
1021
1022 /*
1023 * Wait for user response
1024 */
1025 sop->so_state = SOS_INRESYN;
1026
1027 return;
1028 }
1029
1030 /*
1031 * ER PDU / Protocol Error
1032 *
1033 * Arguments:
1034 * sop pointer to sscop connection block
1035 * m pointer to PDU buffer (without trailer)
1036 * trlr pointer to PDU trailer
1037 *
1038 * Returns:
1039 * none
1040 *
1041 */
1042 static void
1043 sscop_er_error(struct sscop *sop, KBuffer *m, caddr_t trlr)
1044 {
1045
1046 /*
1047 * Record error condition
1048 */
1049 sscop_maa_error(sop, 'L');
1050 KB_FREEALL(m);
1051
1052 return;
1053 }
1054
1055
1056 /*
1057 * ER PDU / SOS_IDLE Processor
1058 *
1059 * Arguments:
1060 * sop pointer to sscop connection block
1061 * m pointer to PDU buffer (without trailer)
1062 * trlr pointer to PDU trailer
1063 *
1064 * Returns:
1065 * none
1066 *
1067 */
1068 static void
1069 sscop_er_idle(struct sscop *sop, KBuffer *m, caddr_t trlr)
1070 {
1071
1072 /*
1073 * Record error condition
1074 */
1075 sscop_er_error(sop, m, trlr);
1076
1077 /*
1078 * Return an END to peer
1079 */
1080 sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
1081
1082 return;
1083 }
1084
1085
1086 /*
1087 * ER PDU / SOS_OUTRECOV Processor
1088 *
1089 * Arguments:
1090 * sop pointer to sscop connection block
1091 * m pointer to PDU buffer (without trailer)
1092 * trlr pointer to PDU trailer
1093 *
1094 * Returns:
1095 * none
1096 *
1097 */
1098 static void
1099 sscop_er_outrecov(struct sscop *sop, KBuffer *m, caddr_t trlr)
1100 {
1101 struct er_pdu *ep = (struct er_pdu *)trlr;
1102 int err;
1103
1104 /*
1105 * If retransmitted ER, report an error
1106 */
1107 if (sscop_is_rexmit(sop, ep->er_nsq)) {
1108 sscop_er_error(sop, m, trlr);
1109 return;
1110 }
1111
1112 /*
1113 * Stop retransmit timer
1114 */
1115 sop->so_timer[SSCOP_T_CC] = 0;
1116
1117 /*
1118 * Initialize transmit window
1119 */
1120 SEQ_SET(sop->so_sendmax, ntohl(ep->er_nmr));
1121
1122 /*
1123 * Initialize receiver window
1124 */
1125 SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin);
1126
1127 /*
1128 * Free PDU buffers
1129 */
1130 KB_FREEALL(m);
1131
1132 /*
1133 * Acknowledge ER
1134 */
1135 sscop_send_erak(sop);
1136
1137 /*
1138 * Deliver any outstanding data to user
1139 */
1140 q2110_deliver_data(sop);
1141
1142 /*
1143 * Notify user of connection recovery
1144 */
1145 STACK_CALL(SSCOP_RECOVER_IND, sop->so_upper, sop->so_toku,
1146 sop->so_connvc, 0, 0, err);
1147 if (err) {
1148 sscop_abort(sop, "stack memory\n");
1149 return;
1150 }
1151
1152 /*
1153 * Wait for user response
1154 */
1155 sop->so_state = SOS_RECOVRSP;
1156
1157 return;
1158 }
1159
1160
1161 /*
1162 * ER PDU / SOS_RECOVRSP Processor
1163 *
1164 * Arguments:
1165 * sop pointer to sscop connection block
1166 * m pointer to PDU buffer (without trailer)
1167 * trlr pointer to PDU trailer
1168 *
1169 * Returns:
1170 * none
1171 *
1172 */
1173 static void
1174 sscop_er_recovrsp(struct sscop *sop, KBuffer *m, caddr_t trlr)
1175 {
1176 struct er_pdu *ep = (struct er_pdu *)trlr;
1177
1178 /*
1179 * If retransmitted ER, just ACK it
1180 */
1181 if (sscop_is_rexmit(sop, ep->er_nsq)) {
1182 KB_FREEALL(m);
1183 sscop_send_erak(sop);
1184 return;
1185 }
1186
1187 /*
1188 * Report error condition
1189 */
1190 sscop_er_error(sop, m, trlr);
1191
1192 return;
1193 }
1194
1195
1196 /*
1197 * ER PDU / SOS_INRECOV Processor
1198 *
1199 * Arguments:
1200 * sop pointer to sscop connection block
1201 * m pointer to PDU buffer (without trailer)
1202 * trlr pointer to PDU trailer
1203 *
1204 * Returns:
1205 * none
1206 *
1207 */
1208 static void
1209 sscop_er_inrecov(struct sscop *sop, KBuffer *m, caddr_t trlr)
1210 {
1211 struct er_pdu *ep = (struct er_pdu *)trlr;
1212
1213 /*
1214 * If retransmitted ER, just ignore it
1215 */
1216 if (sscop_is_rexmit(sop, ep->er_nsq)) {
1217 KB_FREEALL(m);
1218 return;
1219 }
1220
1221 /*
1222 * Report error condition
1223 */
1224 sscop_er_error(sop, m, trlr);
1225
1226 return;
1227 }
1228
1229
1230 /*
1231 * ER PDU / SOS_READY Processor
1232 *
1233 * Arguments:
1234 * sop pointer to sscop connection block
1235 * m pointer to PDU buffer (without trailer)
1236 * trlr pointer to PDU trailer
1237 *
1238 * Returns:
1239 * none
1240 *
1241 */
1242 static void
1243 sscop_er_ready(struct sscop *sop, KBuffer *m, caddr_t trlr)
1244 {
1245 struct er_pdu *ep = (struct er_pdu *)trlr;
1246 int err;
1247
1248 /*
1249 * If retransmitted ER, just ACK it
1250 */
1251 if (sscop_is_rexmit(sop, ep->er_nsq)) {
1252 KB_FREEALL(m);
1253 sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp;
1254 sscop_send_erak(sop);
1255 return;
1256 }
1257
1258 /*
1259 * Stop data transfer timers
1260 */
1261 sop->so_timer[SSCOP_T_POLL] = 0;
1262 sop->so_timer[SSCOP_T_NORESP] = 0;
1263 sop->so_timer[SSCOP_T_IDLE] = 0;
1264 sop->so_flags &= ~SOF_KEEPALIVE;
1265
1266 /*
1267 * Initialize transmit window
1268 */
1269 SEQ_SET(sop->so_sendmax, ntohl(ep->er_nmr));
1270
1271 /*
1272 * Free PDU buffers
1273 */
1274 KB_FREEALL(m);
1275
1276 /*
1277 * Clear out appropriate queues
1278 */
1279 q2110_prep_recovery(sop);
1280
1281 /*
1282 * Deliver any outstanding data to user
1283 */
1284 q2110_deliver_data(sop);
1285
1286 /*
1287 * Notify user of connection recovery
1288 */
1289 STACK_CALL(SSCOP_RECOVER_IND, sop->so_upper, sop->so_toku,
1290 sop->so_connvc, 0, 0, err);
1291 if (err) {
1292 sscop_abort(sop, "stack memory\n");
1293 return;
1294 }
1295
1296 /*
1297 * Wait for user response
1298 */
1299 sop->so_state = SOS_INRECOV;
1300
1301 return;
1302 }
1303
1304
1305 /*
1306 * ERAK PDU / Protocol Error
1307 *
1308 * Arguments:
1309 * sop pointer to sscop connection block
1310 * m pointer to PDU buffer (without trailer)
1311 * trlr pointer to PDU trailer
1312 *
1313 * Returns:
1314 * none
1315 *
1316 */
1317 static void
1318 sscop_erak_error(struct sscop *sop, KBuffer *m, caddr_t trlr)
1319 {
1320
1321 /*
1322 * Record error condition
1323 */
1324 sscop_maa_error(sop, 'M');
1325 KB_FREEALL(m);
1326
1327 return;
1328 }
1329
1330
1331 /*
1332 * ERAK PDU / SOS_IDLE Processor
1333 *
1334 * Arguments:
1335 * sop pointer to sscop connection block
1336 * m pointer to PDU buffer (without trailer)
1337 * trlr pointer to PDU trailer
1338 *
1339 * Returns:
1340 * none
1341 *
1342 */
1343 static void
1344 sscop_erak_idle(struct sscop *sop, KBuffer *m, caddr_t trlr)
1345 {
1346
1347 /*
1348 * Record error condition
1349 */
1350 sscop_erak_error(sop, m, trlr);
1351
1352 /*
1353 * Return an END to peer
1354 */
1355 sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
1356
1357 return;
1358 }
1359
1360
1361 /*
1362 * ERAK PDU / SOS_OUTRECOV Processor
1363 *
1364 * Arguments:
1365 * sop pointer to sscop connection block
1366 * m pointer to PDU buffer (without trailer)
1367 * trlr pointer to PDU trailer
1368 *
1369 * Returns:
1370 * none
1371 *
1372 */
1373 static void
1374 sscop_erak_outrecov(struct sscop *sop, KBuffer *m, caddr_t trlr)
1375 {
1376 struct erak_pdu *ep = (struct erak_pdu *)trlr;
1377 int err;
1378
1379 /*
1380 * Stop retransmit timer
1381 */
1382 sop->so_timer[SSCOP_T_CC] = 0;
1383
1384 /*
1385 * Initialize transmit window
1386 */
1387 SEQ_SET(sop->so_sendmax, ntohl(ep->erak_nmr));
1388
1389 /*
1390 * Free PDU buffers
1391 */
1392 KB_FREEALL(m);
1393
1394 /*
1395 * Deliver any outstanding data to user
1396 */
1397 q2110_deliver_data(sop);
1398
1399 /*
1400 * Notify user of connection recovery
1401 */
1402 STACK_CALL(SSCOP_RECOVER_IND, sop->so_upper, sop->so_toku,
1403 sop->so_connvc, 0, 0, err);
1404 if (err) {
1405 sscop_abort(sop, "stack memory\n");
1406 return;
1407 }
1408
1409 /*
1410 * Wait for user response
1411 */
1412 sop->so_state = SOS_RECOVRSP;
1413
1414 return;
1415 }
1416
1417
1418 /*
1419 * SD PDU / SOS_READY Processor
1420 *
1421 * Arguments:
1422 * sop pointer to sscop connection block
1423 * m pointer to PDU buffer (without trailer)
1424 * trlr pointer to PDU trailer
1425 *
1426 * Returns:
1427 * none
1428 *
1429 */
1430 static void
1431 sscop_sd_ready(struct sscop *sop, KBuffer *m, caddr_t trlr)
1432 {
1433 struct sd_pdu *sp = (struct sd_pdu *)trlr;
1434 struct pdu_hdr *php;
1435 KBuffer *n;
1436 sscop_seq ns;
1437 int err, space;
1438
1439 /*
1440 * Get PDU sequence number
1441 */
1442 SEQ_SET(ns, ntohl(sp->sd_ns));
1443
1444 /*
1445 * Ensure that the sequence number fits within the window
1446 */
1447 if (SEQ_GEQ(ns, sop->so_rcvmax, sop->so_rcvnext)) {
1448 /*
1449 * It doesn't, drop received data
1450 */
1451 KB_FREEALL(m);
1452
1453 /*
1454 * If next highest PDU hasn't reached window end yet,
1455 * then send a USTAT to inform transmitter of this gap
1456 */
1457 if (SEQ_LT(sop->so_rcvhigh, sop->so_rcvmax, sop->so_rcvnext)) {
1458 sscop_send_ustat(sop, sop->so_rcvmax);
1459 sop->so_rcvhigh = sop->so_rcvmax;
1460 }
1461 return;
1462 }
1463
1464 /*
1465 * If this is the next in-sequence PDU, hand it to user
1466 */
1467 if (ns == sop->so_rcvnext) {
1468 STACK_CALL(SSCOP_DATA_IND, sop->so_upper, sop->so_toku,
1469 sop->so_connvc, (int)m, ns, err);
1470 if (err) {
1471 KB_FREEALL(m);
1472 return;
1473 }
1474
1475 /*
1476 * Bump next expected sequence number
1477 */
1478 SEQ_INCR(sop->so_rcvnext, 1);
1479
1480 /*
1481 * Slide receive window down
1482 */
1483 SEQ_INCR(sop->so_rcvmax, 1);
1484
1485 /*
1486 * Is this the highest sequence PDU we've received??
1487 */
1488 if (ns == sop->so_rcvhigh) {
1489 /*
1490 * Yes, bump the limit and exit
1491 */
1492 sop->so_rcvhigh = sop->so_rcvnext;
1493 return;
1494 }
1495
1496 /*
1497 * This is a retransmitted PDU, so see if we have
1498 * more in-sequence PDUs already queued up
1499 */
1500 while ((php = sop->so_recv_hd) &&
1501 (php->ph_ns == sop->so_rcvnext)) {
1502
1503 /*
1504 * Yup we do, so remove next PDU from queue and
1505 * pass it up to the user as well
1506 */
1507 sop->so_recv_hd = php->ph_recv_lk;
1508 if (sop->so_recv_hd == NULL)
1509 sop->so_recv_tl = NULL;
1510 STACK_CALL(SSCOP_DATA_IND, sop->so_upper, sop->so_toku,
1511 sop->so_connvc, (int)php->ph_buf, php->ph_ns,
1512 err);
1513 if (err) {
1514 /*
1515 * Should never happen, but...
1516 */
1517 KB_FREEALL(php->ph_buf);
1518 sscop_abort(sop, "stack memory\n");
1519 return;
1520 }
1521
1522 /*
1523 * Bump next expected sequence number
1524 */
1525 SEQ_INCR(sop->so_rcvnext, 1);
1526
1527 /*
1528 * Slide receive window down
1529 */
1530 SEQ_INCR(sop->so_rcvmax, 1);
1531 }
1532
1533 /*
1534 * Finished with data delivery...
1535 */
1536 return;
1537 }
1538
1539 /*
1540 * We're gonna have to queue this PDU, so find space
1541 * for the PDU header
1542 */
1543 KB_HEADROOM(m, space);
1544
1545 /*
1546 * If there's not enough room in the received buffer,
1547 * allocate & link a new buffer for the header
1548 */
1549 if (space < sizeof(struct pdu_hdr)) {
1550
1551 KB_ALLOC(n, sizeof(struct pdu_hdr), KB_F_NOWAIT, KB_T_HEADER);
1552 if (n == NULL) {
1553 KB_FREEALL(m);
1554 return;
1555 }
1556 KB_HEADSET(n, sizeof(struct pdu_hdr));
1557 KB_LEN(n) = 0;
1558 KB_LINKHEAD(n, m);
1559 m = n;
1560 }
1561
1562 /*
1563 * Build PDU header
1564 *
1565 * We can at least assume/require that the start of
1566 * the user data is aligned. Also note that we don't
1567 * include this header in the buffer len/offset fields.
1568 */
1569 KB_DATASTART(m, php, struct pdu_hdr *);
1570 php--;
1571 php->ph_ns = ns;
1572 php->ph_buf = m;
1573
1574 /*
1575 * Insert PDU into the receive queue
1576 */
1577 if (sscop_recv_insert(sop, php)) {
1578 /*
1579 * Oops, a duplicate sequence number PDU is already on
1580 * the queue, somethings wrong here.
1581 */
1582 sscop_maa_error(sop, 'Q');
1583
1584 /*
1585 * Free buffers
1586 */
1587 KB_FREEALL(m);
1588
1589 /*
1590 * Go into recovery mode
1591 */
1592 q2110_error_recovery(sop);
1593
1594 return;
1595 }
1596
1597 /*
1598 * Are we at the high-water mark??
1599 */
1600 if (ns == sop->so_rcvhigh) {
1601 /*
1602 * Yes, just bump the mark
1603 */
1604 SEQ_INCR(sop->so_rcvhigh, 1);
1605
1606 return;
1607 }
1608
1609 /*
1610 * Are we beyond the high-water mark??
1611 */
1612 if (SEQ_GT(ns, sop->so_rcvhigh, sop->so_rcvnext)) {
1613 /*
1614 * Yes, then there's a missing PDU, so inform the transmitter
1615 */
1616 sscop_send_ustat(sop, ns);
1617
1618 /*
1619 * Update high-water mark
1620 */
1621 sop->so_rcvhigh = SEQ_ADD(ns, 1);
1622 }
1623
1624 return;
1625 }
1626
1627
1628 /*
1629 * POLL PDU / SOS_READY Processor
1630 *
1631 * Arguments:
1632 * sop pointer to sscop connection block
1633 * m pointer to PDU buffer (without trailer)
1634 * trlr pointer to PDU trailer
1635 *
1636 * Returns:
1637 * none
1638 *
1639 */
1640 static void
1641 sscop_poll_ready(struct sscop *sop, KBuffer *m, caddr_t trlr)
1642 {
1643 struct poll_pdu *pp = (struct poll_pdu *)trlr;
1644 sscop_seq nps;
1645
1646 pp->poll_ns = ntohl(pp->poll_ns);
1647
1648 /*
1649 * If the poll sequence number is less than highest number
1650 * we've already seen, something's wrong
1651 */
1652 if (SEQ_LT(pp->poll_ns, sop->so_rcvhigh, sop->so_rcvnext)) {
1653 /*
1654 * Record error condition
1655 */
1656 sscop_maa_error(sop, 'Q');
1657
1658 /*
1659 * Free buffers
1660 */
1661 KB_FREEALL(m);
1662
1663 /*
1664 * Go into recovery mode
1665 */
1666 q2110_error_recovery(sop);
1667
1668 return;
1669 }
1670
1671 /*
1672 * Set a new "next highest" sequence number expected
1673 */
1674 if (SEQ_LT(pp->poll_ns, sop->so_rcvmax, sop->so_rcvnext))
1675 SEQ_SET(sop->so_rcvhigh, pp->poll_ns);
1676 else
1677 sop->so_rcvhigh = sop->so_rcvmax;
1678
1679 /*
1680 * Return a STAT PDU to peer
1681 */
1682 SEQ_SET(nps, ntohl(pp->poll_nps));
1683 KB_FREEALL(m);
1684 sscop_send_stat(sop, nps);
1685
1686 return;
1687 }
1688
DragonFly BSD