![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pk_input.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / netccitt|
Return to pk_input.c CVS log | Up to [Net/2] / Net2 / netccitt |
1.1 root 1: /*
2: * Copyright (c) University of British Columbia, 1984
3: * Copyright (c) 1991 The Regents of the University of California.
4: * All rights reserved.
5: *
6: * This code is derived from software contributed to Berkeley by
7: * the Laboratory for Computation Vision and the Computer Science Department
8: * of the University of British Columbia.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. All advertising materials mentioning features or use of this software
19: * must display the following acknowledgement:
20: * This product includes software developed by the University of
21: * California, Berkeley and its contributors.
22: * 4. Neither the name of the University nor the names of its contributors
23: * may be used to endorse or promote products derived from this software
24: * without specific prior written permission.
25: *
26: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36: * SUCH DAMAGE.
37: *
38: * @(#)pk_input.c 7.13 (Berkeley) 6/6/91
39: */
40:
41: #include "param.h"
42: #include "systm.h"
43: #include "mbuf.h"
44: #include "socket.h"
45: #include "protosw.h"
46: #include "socketvar.h"
47: #include "errno.h"
48:
49: #include "../net/if.h"
50:
51: #include "x25.h"
52: #include "pk.h"
53: #include "pk_var.h"
54:
55: struct pkcb *
56: pk_newlink (ia, llnext)
57: struct x25_ifaddr *ia;
58: caddr_t llnext;
59: {
60: register struct x25config *xcp = &ia->ia_xc;
61: register struct pkcb *pkp;
62: register struct pklcd *lcp;
63: register struct protosw *pp;
64: unsigned size;
65:
66: pp = pffindproto (AF_CCITT, (int)xcp -> xc_lproto, 0);
67: if (pp == 0 || pp -> pr_output == 0) {
68: pk_message (0, xcp, "link level protosw error");
69: return ((struct pkcb *)0);
70: }
71: /*
72: * Allocate a network control block structure
73: */
74: size = sizeof (struct pkcb);
75: pkp = (struct pkcb *)malloc(size, M_PCB, M_WAITOK);
76: if (pkp == 0)
77: return ((struct pkcb *)0);
78: bzero ((caddr_t)pkp, size);
79: pkp -> pk_lloutput = pp -> pr_output;
80: pkp -> pk_xcp = xcp;
81: pkp -> pk_ia = ia;
82: pkp -> pk_state = DTE_WAITING;
83: pkp -> pk_next = pkcbhead;
84: pkp -> pk_llnext = llnext;
85: pkcbhead = pkp;
86:
87: /*
88: * set defaults
89: */
90:
91: if (xcp -> xc_pwsize == 0)
92: xcp -> xc_pwsize = DEFAULT_WINDOW_SIZE;
93: if (xcp -> xc_psize == 0)
94: xcp -> xc_psize = X25_PS128;
95: /*
96: * Allocate logical channel descriptor vector
97: */
98:
99: (void)pk_resize(pkp);
100: return (pkp);
101: }
102:
103: pk_resize (pkp)
104: register struct pkcb *pkp;
105: {
106: struct pklcd *dev_lcp = 0;
107: struct x25config *xcp = pkp -> pk_xcp;
108: if (pkp -> pk_chan &&
109: (pkp -> pk_maxlcn != xcp -> xc_maxlcn)) {
110: pk_restart (pkp, X25_RESTART_NETWORK_CONGESTION);
111: dev_lcp = pkp -> pk_chan[0];
112: free ((caddr_t)pkp -> pk_chan, M_IFADDR);
113: pkp -> pk_chan = 0;
114: }
115: if (pkp -> pk_chan == 0) {
116: unsigned size;
117: pkp -> pk_maxlcn = xcp -> xc_maxlcn;
118: size = (pkp -> pk_maxlcn + 1) * sizeof (struct pklcd *);
119: pkp -> pk_chan =
120: (struct pklcd **) malloc (size, M_IFADDR, M_WAITOK);
121: if (pkp -> pk_chan) {
122: bzero ((caddr_t)pkp -> pk_chan, size);
123: /*
124: * Allocate a logical channel descriptor for lcn 0
125: */
126: if (dev_lcp == 0 &&
127: (dev_lcp = pk_attach ((struct socket *)0)) == 0)
128: return (ENOBUFS);
129: dev_lcp -> lcd_state = READY;
130: dev_lcp -> lcd_pkp = pkp;
131: pkp -> pk_chan[0] = dev_lcp;
132: } else {
133: if (dev_lcp)
134: pk_close (dev_lcp);
135: return (ENOBUFS);
136: }
137: }
138: return 0;
139: }
140:
141: /*
142: * This procedure is called by the link level whenever the link
143: * becomes operational, is reset, or when the link goes down.
144: */
145:
146: pk_ctlinput (code, pkp)
147: register struct pkcb *pkp;
148: {
149:
150:
151: switch (code) {
152: case PRC_LINKUP:
153: if (pkp -> pk_state == DTE_WAITING)
154: pk_restart (pkp, X25_RESTART_NETWORK_CONGESTION);
155: break;
156:
157: case PRC_LINKDOWN:
158: pk_restart (pkp, -1); /* Clear all active circuits */
159: pkp -> pk_state = DTE_WAITING;
160: break;
161:
162: case PRC_LINKRESET:
163: pk_restart (pkp, X25_RESTART_NETWORK_CONGESTION);
164: break;
165:
166: }
167: return (0);
168: }
169: struct ifqueue pkintrq;
170: /*
171: * This routine is called if there are semi-smart devices that do HDLC
172: * in hardware and want to queue the packet and call level 3 directly
173: */
174: pkintr ()
175: {
176: register struct mbuf *m;
177: register struct ifaddr *ifa;
178: register struct ifnet *ifp;
179: register int s;
180:
181: for (;;) {
182: s = splimp ();
183: IF_DEQUEUE (&pkintrq, m);
184: splx (s);
185: if (m == 0)
186: break;
187: if (m->m_len < PKHEADERLN) {
188: printf ("pkintr: packet too short (len=%d)\n",
189: m->m_len);
190: m_freem (m);
191: continue;
192: }
193: pk_input(m);
194: }
195: }
196: struct mbuf *pk_bad_packet;
197: struct mbuf_cache pk_input_cache = {0 };
198: /*
199: * X.25 PACKET INPUT
200: *
201: * This procedure is called by a link level procedure whenever
202: * an information frame is received. It decodes the packet and
203: * demultiplexes based on the logical channel number.
204: *
205: * We change the original conventions of the UBC code here --
206: * since there may be multiple pkcb's for 802.2 class 2
207: * for a given interface, we must be informed which one it is;
208: * so we overwrite the pkthdr.rcvif; it can be recovered if necessary.
209: *
210: */
211:
212: pk_input (m)
213: register struct mbuf *m;
214: {
215: register struct x25_packet *xp;
216: register struct pklcd *lcp;
217: register struct socket *so = 0;
218: register struct pkcb *pkp;
219: int ptype, lcn, lcdstate = LISTEN;
220:
221: if (pk_input_cache.mbc_size || pk_input_cache.mbc_oldsize)
222: mbuf_cache(&pk_input_cache, m);
223: if ((m->m_flags & M_PKTHDR) == 0)
224: panic("pkintr");
225: if ((pkp = (struct pkcb *)m->m_pkthdr.rcvif) == 0)
226: return;
227: xp = mtod (m, struct x25_packet *);
228: ptype = pk_decode (xp);
229: lcn = LCN(xp);
230: lcp = pkp -> pk_chan[lcn];
231:
232: /*
233: * If the DTE is in Restart state, then it will ignore data,
234: * interrupt, call setup and clearing, flow control and reset
235: * packets.
236: */
237: if (lcn < 0 || lcn > pkp -> pk_maxlcn) {
238: pk_message (lcn, pkp -> pk_xcp, "illegal lcn");
239: m_freem (m);
240: return;
241: }
242:
243: pk_trace (pkp -> pk_xcp, m, "P-In");
244:
245: if (pkp -> pk_state != DTE_READY && ptype != RESTART && ptype != RESTART_CONF) {
246: m_freem (m);
247: return;
248: }
249: if (lcp) {
250: so = lcp -> lcd_so;
251: lcdstate = lcp -> lcd_state;
252: } else {
253: if (ptype == CLEAR) { /* idle line probe (Datapac specific) */
254: /* send response on lcd 0's output queue */
255: lcp = pkp -> pk_chan[0];
256: lcp -> lcd_template = pk_template (lcn, X25_CLEAR_CONFIRM);
257: pk_output (lcp);
258: m_freem (m);
259: return;
260: }
261: if (ptype != CALL)
262: ptype = INVALID_PACKET;
263: }
264:
265: if (lcn == 0 && ptype != RESTART && ptype != RESTART_CONF) {
266: pk_message (0, pkp -> pk_xcp, "illegal ptype (%d, %s) on lcn 0",
267: ptype, pk_name[ptype / MAXSTATES]);
268: if (pk_bad_packet)
269: m_freem (pk_bad_packet);
270: pk_bad_packet = m;
271: return;
272: }
273:
274: switch (ptype + lcdstate) {
275: /*
276: * Incoming Call packet received.
277: */
278: case CALL + LISTEN:
279: pk_incoming_call (pkp, m);
280: break;
281:
282: /*
283: * Call collision: Just throw this "incoming call" away since
284: * the DCE will ignore it anyway.
285: */
286: case CALL + SENT_CALL:
287: pk_message ((int)lcn, pkp -> pk_xcp,
288: "incoming call collision");
289: break;
290:
291: /*
292: * Call confirmation packet received. This usually means our
293: * previous connect request is now complete.
294: */
295: case CALL_ACCEPTED + SENT_CALL:
296: MCHTYPE(m, MT_CONTROL);
297: pk_call_accepted (lcp, m);
298: break;
299:
300: /*
301: * This condition can only happen if the previous state was
302: * SENT_CALL. Just ignore the packet, eventually a clear
303: * confirmation should arrive.
304: */
305: case CALL_ACCEPTED + SENT_CLEAR:
306: break;
307:
308: /*
309: * Clear packet received. This requires a complete tear down
310: * of the virtual circuit. Free buffers and control blocks.
311: * and send a clear confirmation.
312: */
313: case CLEAR + READY:
314: case CLEAR + RECEIVED_CALL:
315: case CLEAR + SENT_CALL:
316: case CLEAR + DATA_TRANSFER:
317: lcp -> lcd_state = RECEIVED_CLEAR;
318: lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CLEAR_CONFIRM);
319: pk_output (lcp);
320: pk_clearcause (pkp, xp);
321: if (lcp -> lcd_upper) {
322: MCHTYPE(m, MT_CONTROL);
323: lcp -> lcd_upper (lcp, m);
324: }
325: pk_close (lcp);
326: lcp = 0;
327: break;
328:
329: /*
330: * Clear collision: Treat this clear packet as a confirmation.
331: */
332: case CLEAR + SENT_CLEAR:
333: pk_close (lcp);
334: break;
335:
336: /*
337: * Clear confirmation received. This usually means the virtual
338: * circuit is now completely removed.
339: */
340: case CLEAR_CONF + SENT_CLEAR:
341: pk_close (lcp);
342: break;
343:
344: /*
345: * A clear confirmation on an unassigned logical channel - just
346: * ignore it. Note: All other packets on an unassigned channel
347: * results in a clear.
348: */
349: case CLEAR_CONF + READY:
350: case CLEAR_CONF + LISTEN:
351: break;
352:
353: /*
354: * Data packet received. Pass on to next level. Move the Q and M
355: * bits into the data portion for the next level.
356: */
357: case DATA + DATA_TRANSFER:
358: if (lcp -> lcd_reset_condition) {
359: ptype = DELETE_PACKET;
360: break;
361: }
362:
363: /*
364: * Process the P(S) flow control information in this Data packet.
365: * Check that the packets arrive in the correct sequence and that
366: * they are within the "lcd_input_window". Input window rotation is
367: * initiated by the receive interface.
368: */
369:
370: if (PS(xp) != ((lcp -> lcd_rsn + 1) % MODULUS) ||
371: PS(xp) == ((lcp -> lcd_input_window + lcp->lcd_windowsize) % MODULUS)) {
372: m_freem (m);
373: pk_procerror (RESET, lcp, "p(s) flow control error", 1);
374: break;
375: }
376: lcp -> lcd_rsn = PS(xp);
377:
378: if (pk_ack (lcp, PR(xp)) != PACKET_OK) {
379: m_freem (m);
380: break;
381: }
382: m -> m_data += PKHEADERLN;
383: m -> m_len -= PKHEADERLN;
384: m -> m_pkthdr.len -= PKHEADERLN;
385:
386: lcp -> lcd_rxcnt++;
387: if (lcp -> lcd_flags & X25_MBS_HOLD) {
388: register struct mbuf *n = lcp -> lcd_cps;
389: int mbit = MBIT(xp);
390: octet q_and_d_bits;
391:
392: if (n) {
393: n -> m_pkthdr.len += m -> m_pkthdr.len;
394: while (n -> m_next)
395: n = n -> m_next;
396: n -> m_next = m;
397: m = lcp -> lcd_cps;
398:
399: if (lcp -> lcd_cpsmax &&
400: n -> m_pkthdr.len > lcp -> lcd_cpsmax) {
401: pk_procerror (RESET, lcp,
402: "C.P.S. overflow", 128);
403: return;
404: }
405: q_and_d_bits = 0xc0 & *(octet *)xp;
406: xp = (struct x25_packet *)
407: (mtod(m, octet *) - PKHEADERLN);
408: *(octet *)xp |= q_and_d_bits;
409: }
410: if (mbit) {
411: lcp -> lcd_cps = m;
412: pk_flowcontrol(lcp, 0, 1);
413: return;
414: }
415: lcp -> lcd_cps = 0;
416: }
417: if (so == 0)
418: break;
419: if (lcp -> lcd_flags & X25_MQBIT) {
420: octet t = (xp -> q_bit) ? t = 0x80 : 0;
421:
422: if (MBIT(xp))
423: t |= 0x40;
424: m -> m_data -= 1;
425: m -> m_len += 1;
426: m -> m_pkthdr.len += 1;
427: *mtod(m, octet *) = t;
428: }
429:
430: /*
431: * Discard Q-BIT packets if the application
432: * doesn't want to be informed of M and Q bit status
433: */
434: if (xp -> q_bit && (lcp -> lcd_flags & X25_MQBIT) == 0) {
435: m_freem (m);
436: /*
437: * NB. This is dangerous: sending a RR here can
438: * cause sequence number errors if a previous data
439: * packet has not yet been passed up to the application
440: * (RR's are normally generated via PRU_RCVD).
441: */
442: pk_flowcontrol(lcp, 0, 1);
443: } else {
444: sbappendrecord (&so -> so_rcv, m);
445: sorwakeup (so);
446: }
447: break;
448:
449: /*
450: * Interrupt packet received.
451: */
452: case INTERRUPT + DATA_TRANSFER:
453: if (lcp -> lcd_reset_condition)
454: break;
455: lcp -> lcd_intrdata = xp -> packet_data;
456: lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_INTERRUPT_CONFIRM);
457: pk_output (lcp);
458: m -> m_data += PKHEADERLN;
459: m -> m_len -= PKHEADERLN;
460: m -> m_pkthdr.len -= PKHEADERLN;
461: MCHTYPE(m, MT_OOBDATA);
462: if (so) {
463: if (so -> so_options & SO_OOBINLINE)
464: sbinsertoob (&so -> so_rcv, m);
465: else
466: m_freem (m);
467: sohasoutofband (so);
468: }
469: break;
470:
471: /*
472: * Interrupt confirmation packet received.
473: */
474: case INTERRUPT_CONF + DATA_TRANSFER:
475: if (lcp -> lcd_reset_condition)
476: break;
477: if (lcp -> lcd_intrconf_pending == TRUE)
478: lcp -> lcd_intrconf_pending = FALSE;
479: else
480: pk_procerror (RESET, lcp, "unexpected packet", 43);
481: break;
482:
483: /*
484: * Receiver ready received. Rotate the output window and output
485: * any data packets waiting transmission.
486: */
487: case RR + DATA_TRANSFER:
488: if (lcp -> lcd_reset_condition ||
489: pk_ack (lcp, PR(xp)) != PACKET_OK) {
490: ptype = DELETE_PACKET;
491: break;
492: }
493: if (lcp -> lcd_rnr_condition == TRUE)
494: lcp -> lcd_rnr_condition = FALSE;
495: pk_output (lcp);
496: break;
497:
498: /*
499: * Receiver Not Ready received. Packets up to the P(R) can be
500: * be sent. Condition is cleared with a RR.
501: */
502: case RNR + DATA_TRANSFER:
503: if (lcp -> lcd_reset_condition ||
504: pk_ack (lcp, PR(xp)) != PACKET_OK) {
505: ptype = DELETE_PACKET;
506: break;
507: }
508: lcp -> lcd_rnr_condition = TRUE;
509: break;
510:
511: /*
512: * Reset packet received. Set state to FLOW_OPEN. The Input and
513: * Output window edges ar set to zero. Both the send and receive
514: * numbers are reset. A confirmation is returned.
515: */
516: case RESET + DATA_TRANSFER:
517: if (lcp -> lcd_reset_condition)
518: /* Reset collision. Just ignore packet. */
519: break;
520:
521: pk_resetcause (pkp, xp);
522: lcp -> lcd_window_condition = lcp -> lcd_rnr_condition =
523: lcp -> lcd_intrconf_pending = FALSE;
524: lcp -> lcd_output_window = lcp -> lcd_input_window =
525: lcp -> lcd_last_transmitted_pr = 0;
526: lcp -> lcd_ssn = 0;
527: lcp -> lcd_rsn = MODULUS - 1;
528:
529: lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_RESET_CONFIRM);
530: pk_output (lcp);
531:
532: pk_flush(lcp);
533: if (so == 0)
534: break;
535: wakeup ((caddr_t) & so -> so_timeo);
536: sorwakeup (so);
537: sowwakeup (so);
538: break;
539:
540: /*
541: * Reset confirmation received.
542: */
543: case RESET_CONF + DATA_TRANSFER:
544: if (lcp -> lcd_reset_condition) {
545: lcp -> lcd_reset_condition = FALSE;
546: pk_output (lcp);
547: }
548: else
549: pk_procerror (RESET, lcp, "unexpected packet", 32);
550: break;
551:
552: case DATA + SENT_CLEAR:
553: ptype = DELETE_PACKET;
554: case RR + SENT_CLEAR:
555: case RNR + SENT_CLEAR:
556: case INTERRUPT + SENT_CLEAR:
557: case INTERRUPT_CONF + SENT_CLEAR:
558: case RESET + SENT_CLEAR:
559: case RESET_CONF + SENT_CLEAR:
560: /* Just ignore p if we have sent a CLEAR already.
561: */
562: break;
563:
564: /*
565: * Restart sets all the permanent virtual circuits to the "Data
566: * Transfer" stae and all the switched virtual circuits to the
567: * "Ready" state.
568: */
569: case RESTART + READY:
570: switch (pkp -> pk_state) {
571: case DTE_SENT_RESTART:
572: /* Restart collision. */
573: pkp -> pk_state = DTE_READY;
574: pk_message (0, pkp -> pk_xcp,
575: "Packet level operational");
576: break;
577:
578: default:
579: pk_restart (pkp, -1);
580: pk_restartcause (pkp, xp);
581: pkp -> pk_chan[0] -> lcd_template = pk_template (0,
582: X25_RESTART_CONFIRM);
583: pk_output (pkp -> pk_chan[0]);
584: }
585: break;
586:
587: /*
588: * Restart confirmation received. All logical channels are set
589: * to READY.
590: */
591: case RESTART_CONF + READY:
592: switch (pkp -> pk_state) {
593: case DTE_SENT_RESTART:
594: pkp -> pk_state = DTE_READY;
595: pk_message (0, pkp -> pk_xcp,
596: "Packet level operational");
597: break;
598:
599: default:
600: /* Restart local procedure error. */
601: pk_restart (pkp, X25_RESTART_LOCAL_PROCEDURE_ERROR);
602: pkp -> pk_state = DTE_SENT_RESTART;
603: }
604: break;
605:
606: default:
607: if (lcp) {
608: pk_procerror (CLEAR, lcp, "unknown packet error", 33);
609: pk_message (lcn, pkp -> pk_xcp,
610: "\"%s\" unexpected in \"%s\" state",
611: pk_name[ptype/MAXSTATES], pk_state[lcdstate]);
612: } else
613: pk_message (lcn, pkp -> pk_xcp,
614: "packet arrived on unassigned lcn");
615: break;
616: }
617: if (so == 0 && lcp && lcp -> lcd_upper && lcdstate == DATA_TRANSFER) {
618: if (ptype != DATA && ptype != INTERRUPT)
619: MCHTYPE(m, MT_CONTROL);
620: lcp -> lcd_upper (lcp, m);
621: } else if (ptype != DATA && ptype != INTERRUPT)
622: m_freem (m);
623: }
624:
625: static
626: prune_dnic(from, to, dnicname, xcp)
627: char *from, *to, *dnicname;
628: register struct x25config *xcp;
629: {
630: register char *cp1 = from, *cp2 = from;
631: if (xcp->xc_prepnd0 && *cp1 == '0') {
632: from = ++cp1;
633: goto copyrest;
634: }
635: if (xcp->xc_nodnic) {
636: for (cp1 = dnicname; *cp2 = *cp1++;)
637: cp2++;
638: cp1 = from;
639: }
640: copyrest:
641: for (cp1 = dnicname; *cp2 = *cp1++;)
642: cp2++;
643: }
644: /* static */
645: pk_simple_bsd (from, to, lower, len)
646: register octet *from, *to;
647: register len, lower;
648: {
649: register int c;
650: while (--len >= 0) {
651: c = *from;
652: if (lower & 0x01)
653: *from++;
654: else
655: c >>= 4;
656: c &= 0x0f; c |= 0x30; *to++ = c; lower++;
657: }
658: *to = 0;
659: }
660:
661: /*static octet * */
662: pk_from_bcd (a, iscalling, sa, xcp)
663: register struct x25_calladdr *a;
664: register struct sockaddr_x25 *sa;
665: register struct x25config *xcp;
666: {
667: octet buf[MAXADDRLN+1];
668: octet *cp;
669: unsigned count;
670:
671: bzero ((caddr_t)sa, sizeof (*sa));
672: sa -> x25_len = sizeof (*sa);
673: sa -> x25_family = AF_CCITT;
674: if (iscalling) {
675: cp = a -> address_field + (a -> called_addrlen / 2);
676: count = a -> calling_addrlen;
677: pk_simple_bsd (cp, buf, a -> called_addrlen, count);
678: } else {
679: count = a -> called_addrlen;
680: pk_simple_bsd (a -> address_field, buf, 0, count);
681: }
682: if (xcp -> xc_addr.x25_net && (xcp -> xc_nodnic || xcp ->xc_prepnd0)) {
683: octet dnicname[sizeof(long) * NBBY/3 + 2];
684:
685: sprintf (dnicname, "%d", xcp -> xc_addr.x25_net);
686: prune_dnic (buf, sa -> x25_addr, dnicname, xcp);
687: } else
688: bcopy ((caddr_t)buf, (caddr_t)sa -> x25_addr, count + 1);
689: }
690:
691: static
692: save_extra(m0, fp, so)
693: struct mbuf *m0;
694: octet *fp;
695: struct socket *so;
696: {
697: register struct mbuf *m;
698: struct cmsghdr cmsghdr;
699: if (m = m_copym (m, 0, (int)M_COPYALL)) {
700: int off = fp - mtod (m0, octet *);
701: int len = m->m_pkthdr.len - off + sizeof (cmsghdr);
702: cmsghdr.cmsg_len = len;
703: cmsghdr.cmsg_level = AF_CCITT;
704: cmsghdr.cmsg_type = PK_FACILITIES;
705: m_adj (m, off);
706: M_PREPEND (m, sizeof(cmsghdr), M_DONTWAIT);
707: if (m == 0)
708: return;
709: bcopy ((caddr_t)&cmsghdr, mtod (m, caddr_t), sizeof (cmsghdr));
710: MCHTYPE(m, MT_CONTROL);
711: sbappendrecord(&so -> so_rcv, m);
712: }
713: }
714:
715: /*
716: * This routine handles incoming call packets. It matches the protocol
717: * field on the Call User Data field (usually the first four bytes) with
718: * sockets awaiting connections.
719: */
720:
721: pk_incoming_call (pkp, m0)
722: struct mbuf *m0;
723: struct pkcb *pkp;
724: {
725: register struct pklcd *lcp = 0, *l;
726: register struct sockaddr_x25 *sa;
727: register struct x25_calladdr *a;
728: register struct socket *so = 0;
729: struct x25_packet *xp = mtod(m0, struct x25_packet *);
730: struct mbuf *m;
731: struct x25config *xcp = pkp -> pk_xcp;
732: int len = m0->m_pkthdr.len;
733: unsigned udlen;
734: char *errstr = "server unavailable";
735: octet *u, *facp;
736: int lcn = LCN(xp);
737:
738: /* First, copy the data from the incoming call packet to a X25 address
739: descriptor. It is to be regretted that you have
740: to parse the facilities into a sockaddr to determine
741: if reverse charging is being requested */
742: if ((m = m_get (M_DONTWAIT, MT_SONAME)) == 0)
743: return;
744: sa = mtod (m, struct sockaddr_x25 *);
745: a = (struct x25_calladdr *) &xp -> packet_data;
746: facp = u = (octet *) (a -> address_field +
747: ((a -> called_addrlen + a -> calling_addrlen + 1) / 2));
748: u += *u + 1;
749: udlen = min (16, ((octet *)xp) + len - u);
750: if (udlen < 0)
751: udlen = 0;
752: pk_from_bcd (a, 1, sa, pkp -> pk_xcp); /* get calling address */
753: pk_parse_facilities (u, sa);
754: bcopy ((caddr_t)u, sa -> x25_udata, udlen);
755: sa -> x25_udlen = udlen;
756:
757: /*
758: * Now, loop through the listen sockets looking for a match on the
759: * PID. That is the first four octets of the user data field. This
760: * is the closest thing to a port number for X.25 packets. What it
761: * does provide is away of multiplexing services at the user level.
762: */
763:
764: for (l = pk_listenhead; l; l = l -> lcd_listen) {
765: struct sockaddr_x25 *sxp = l -> lcd_ceaddr;
766:
767: if (bcmp (sxp -> x25_udata, u, sxp->x25_udlen))
768: continue;
769: if (sxp -> x25_net &&
770: sxp -> x25_net != xcp -> xc_addr.x25_net)
771: continue;
772: /*
773: * don't accept incoming calls with the D-Bit on
774: * unless the server agrees
775: */
776: if (xp -> d_bit && !(sxp -> x25_opts.op_flags & X25_DBIT)) {
777: errstr = "incoming D-Bit mismatch";
778: break;
779: }
780: /*
781: * don't accept incoming collect calls unless
782: * the server sets the reverse charging option.
783: */
784: if ((sxp -> x25_opts.op_flags & (X25_OLDSOCKADDR|X25_REVERSE_CHARGE)) == 0 &&
785: sa -> x25_opts.op_flags & X25_REVERSE_CHARGE) {
786: errstr = "incoming collect call refused";
787: break;
788: }
789: if (l -> lcd_so) {
790: if (so = sonewconn (l -> lcd_so, SS_ISCONNECTED))
791: lcp = (struct pklcd *) so -> so_pcb;
792: } else
793: lcp = pk_attach((struct socket *) 0);
794: if (lcp == 0) {
795: /*
796: * Insufficient space or too many unaccepted
797: * connections. Just throw the call away.
798: */
799: errstr = "server malfunction";
800: break;
801: }
802: lcp -> lcd_upper = l -> lcd_upper;
803: lcp -> lcd_upnext = l -> lcd_upnext;
804: lcp -> lcd_lcn = lcn;
805: lcp -> lcd_state = RECEIVED_CALL;
806: sa -> x25_opts.op_flags |= (sxp -> x25_opts.op_flags &
807: ~X25_REVERSE_CHARGE) | l -> lcd_flags;
808: pk_assoc (pkp, lcp, sa);
809: lcp -> lcd_faddr = *sa;
810: lcp -> lcd_laddr.x25_udlen = sxp -> x25_udlen;
811: lcp -> lcd_craddr = &lcp->lcd_faddr;
812: lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CALL_ACCEPTED);
813: if (lcp -> lcd_flags & X25_DBIT) {
814: if (xp -> d_bit)
815: mtod(lcp -> lcd_template,
816: struct x25_packet *) -> d_bit = 1;
817: else
818: lcp -> lcd_flags &= ~X25_DBIT;
819: }
820: if (so) {
821: pk_output (lcp);
822: soisconnected (so);
823: if (so -> so_options & SO_OOBINLINE)
824: save_extra(m0, facp, so);
825: } else if (lcp -> lcd_upper) {
826: (*lcp -> lcd_upper) (lcp, m0);
827: }
828: (void) m_free (m);
829: return;
830: }
831:
832: /*
833: * If the call fails for whatever reason, we still need to build a
834: * skeleton LCD in order to be able to properly receive the CLEAR
835: * CONFIRMATION.
836: */
837: #ifdef WATERLOO /* be explicit */
838: if (l == 0 && bcmp(sa->x25_udata, "ean", 3) == 0)
839: pk_message (lcn, pkp -> pk_xcp, "host=%s ean%c: %s",
840: sa->x25_addr, sa->x25_udata[3] & 0xff, errstr);
841: else if (l == 0 && bcmp(sa->x25_udata, "\1\0\0\0", 4) == 0)
842: pk_message (lcn, pkp -> pk_xcp, "host=%s x29d: %s",
843: sa->x25_addr, errstr);
844: else
845: #endif
846: pk_message (lcn, pkp -> pk_xcp, "host=%s pid=%x %x %x %x: %s",
847: sa -> x25_addr, sa -> x25_udata[0] & 0xff,
848: sa -> x25_udata[1] & 0xff, sa -> x25_udata[2] & 0xff,
849: sa -> x25_udata[3] & 0xff, errstr);
850: if ((lcp = pk_attach((struct socket *)0)) == 0) {
851: (void) m_free (m);
852: return;
853: }
854: lcp -> lcd_lcn = lcn;
855: lcp -> lcd_state = RECEIVED_CALL;
856: pk_assoc (pkp, lcp, sa);
857: (void) m_free (m);
858: pk_clear (lcp, 0, 1);
859: }
860:
861: pk_call_accepted (lcp, m)
862: struct pklcd *lcp;
863: struct mbuf *m;
864: {
865: register struct x25_calladdr *ap;
866: register octet *fcp;
867: struct x25_packet *xp = mtod (m, struct x25_packet *);
868: int len = m -> m_len;
869:
870: lcp -> lcd_state = DATA_TRANSFER;
871: if (lcp -> lcd_so)
872: soisconnected (lcp -> lcd_so);
873: if ((lcp -> lcd_flags & X25_DBIT) && (xp -> d_bit == 0))
874: lcp -> lcd_flags &= ~X25_DBIT;
875: if (len > 3) {
876: ap = (struct x25_calladdr *) &xp -> packet_data;
877: fcp = (octet *) ap -> address_field + (ap -> calling_addrlen +
878: ap -> called_addrlen + 1) / 2;
879: if (fcp + *fcp <= ((octet *)xp) + len)
880: pk_parse_facilities (fcp, lcp -> lcd_ceaddr);
881: }
882: pk_assoc (lcp -> lcd_pkp, lcp, lcp -> lcd_ceaddr);
883: if (lcp -> lcd_so == 0 && lcp -> lcd_upper)
884: lcp -> lcd_upper(lcp, m);
885: }
886:
887: pk_parse_facilities (fcp, sa)
888: register octet *fcp;
889: register struct sockaddr_x25 *sa;
890: {
891: register octet *maxfcp;
892:
893: maxfcp = fcp + *fcp;
894: fcp++;
895: while (fcp < maxfcp) {
896: /*
897: * Ignore national DCE or DTE facilities
898: */
899: if (*fcp == 0 || *fcp == 0xff)
900: break;
901: switch (*fcp) {
902: case FACILITIES_WINDOWSIZE:
903: sa -> x25_opts.op_wsize = fcp[1];
904: fcp += 3;
905: break;
906:
907: case FACILITIES_PACKETSIZE:
908: sa -> x25_opts.op_psize = fcp[1];
909: fcp += 3;
910: break;
911:
912: case FACILITIES_THROUGHPUT:
913: sa -> x25_opts.op_speed = fcp[1];
914: fcp += 2;
915: break;
916:
917: case FACILITIES_REVERSE_CHARGE:
918: if (fcp[1] & 01)
919: sa -> x25_opts.op_flags |= X25_REVERSE_CHARGE;
920: /*
921: * Datapac specific: for a X.25(1976) DTE, bit 2
922: * indicates a "hi priority" (eg. international) call.
923: */
924: if (fcp[1] & 02 && sa -> x25_opts.op_psize == 0)
925: sa -> x25_opts.op_psize = X25_PS128;
926: fcp += 2;
927: break;
928:
929: default:
930: /*printf("unknown facility %x, class=%d\n", *fcp, (*fcp & 0xc0) >> 6);*/
931: switch ((*fcp & 0xc0) >> 6) {
932: case 0: /* class A */
933: fcp += 2;
934: break;
935:
936: case 1:
937: fcp += 3;
938: break;
939:
940: case 2:
941: fcp += 4;
942: break;
943:
944: case 3:
945: fcp++;
946: fcp += *fcp;
947: }
948: }
949: }
950: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.