1 /* 2 * Copyright (c) University of British Columbia, 1984 3 * Copyright (C) Computer Science Department IV, 4 * University of Erlangen-Nuremberg, Germany, 1992 5 * Copyright (c) 1991, 1992, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * This code is derived from software contributed to Berkeley by the 9 * Laboratory for Computation Vision and the Computer Science Department 10 * of the the University of British Columbia and the Computer Science 11 * Department (IV) of the University of Erlangen-Nuremberg, Germany. 12 * 13 * %sccs.include.redist.c% 14 * 15 * @(#)pk_input.c 8.1 (Berkeley) 06/10/93 16 */ 17 18 #include <sys/param.h> 19 #include <sys/systm.h> 20 #include <sys/mbuf.h> 21 #include <sys/socket.h> 22 #include <sys/protosw.h> 23 #include <sys/socketvar.h> 24 #include <sys/errno.h> 25 26 #include <net/if.h> 27 #include <net/if_dl.h> 28 #include <net/if_llc.h> 29 #include <net/route.h> 30 31 #include <netccitt/dll.h> 32 #include <netccitt/x25.h> 33 #include <netccitt/pk.h> 34 #include <netccitt/pk_var.h> 35 #include <netccitt/llc_var.h> 36 37 struct pkcb_q pkcb_q = {&pkcb_q, &pkcb_q}; 38 39 /* 40 * ccittintr() is the generic interrupt handler for HDLC, LLC2, and X.25. This 41 * allows to have kernel running X.25 but no HDLC or LLC2 or both (in case we 42 * employ boards that do all the stuff themselves, e.g. ADAX X.25 or TPS ISDN.) 43 */ 44 void 45 ccittintr () 46 { 47 extern struct ifqueue pkintrq; 48 extern struct ifqueue hdintrq; 49 extern struct ifqueue llcintrq; 50 51 #ifdef HDLC 52 if (hdintrq.ifq_len) 53 hdintr (); 54 #endif 55 #ifdef LLC 56 if (llcintrq.ifq_len) 57 llcintr (); 58 #endif 59 if (pkintrq.ifq_len) 60 pkintr (); 61 } 62 63 struct pkcb * 64 pk_newlink (ia, llnext) 65 struct x25_ifaddr *ia; 66 caddr_t llnext; 67 { 68 register struct x25config *xcp = &ia -> ia_xc; 69 register struct pkcb *pkp; 70 register struct pklcd *lcp; 71 register struct protosw *pp; 72 unsigned size; 73 74 pp = pffindproto (AF_CCITT, (int) xcp -> xc_lproto, 0); 75 if (pp == 0 || pp -> pr_output == 0) { 76 pk_message (0, xcp, "link level protosw error"); 77 return ((struct pkcb *)0); 78 } 79 /* 80 * Allocate a network control block structure 81 */ 82 size = sizeof (struct pkcb); 83 pkp = (struct pkcb *) malloc (size, M_PCB, M_WAITOK); 84 if (pkp == 0) 85 return ((struct pkcb *)0); 86 bzero ((caddr_t) pkp, size); 87 pkp -> pk_lloutput = pp -> pr_output; 88 pkp -> pk_llctlinput = (caddr_t (*)()) pp -> pr_ctlinput; 89 pkp -> pk_xcp = xcp; 90 pkp -> pk_ia = ia; 91 pkp -> pk_state = DTE_WAITING; 92 pkp -> pk_llnext = llnext; 93 insque (pkp, &pkcb_q); 94 95 /* 96 * set defaults 97 */ 98 99 if (xcp -> xc_pwsize == 0) 100 xcp -> xc_pwsize = DEFAULT_WINDOW_SIZE; 101 if (xcp -> xc_psize == 0) 102 xcp -> xc_psize = X25_PS128; 103 /* 104 * Allocate logical channel descriptor vector 105 */ 106 107 (void) pk_resize (pkp); 108 return (pkp); 109 } 110 111 112 pk_dellink (pkp) 113 register struct pkcb *pkp; 114 { 115 register int i; 116 register struct protosw *pp; 117 118 /* 119 * Essentially we have the choice to 120 * (a) go ahead and let the route be deleted and 121 * leave the pkcb associated with that route 122 * as it is, i.e. the connections stay open 123 * (b) do a pk_disconnect() on all channels associated 124 * with the route via the pkcb and then proceed. 125 * 126 * For the time being we stick with (b) 127 */ 128 129 for (i = 1; i < pkp -> pk_maxlcn; ++i) 130 if (pkp -> pk_chan[i]) 131 pk_disconnect (pkp -> pk_chan[i]); 132 133 /* 134 * Free the pkcb 135 */ 136 137 /* 138 * First find the protoswitch to get hold of the link level 139 * protocol to be notified that the packet level entity is 140 * dissolving ... 141 */ 142 pp = pffindproto (AF_CCITT, (int) pkp -> pk_xcp -> xc_lproto, 0); 143 if (pp == 0 || pp -> pr_output == 0) { 144 pk_message (0, pkp -> pk_xcp, "link level protosw error"); 145 return (EPROTONOSUPPORT); 146 } 147 148 pkp -> pk_refcount--; 149 if (!pkp -> pk_refcount) { 150 struct dll_ctlinfo ctlinfo; 151 152 remque (pkp); 153 if (pkp -> pk_rt -> rt_llinfo == (caddr_t) pkp) 154 pkp -> pk_rt -> rt_llinfo = (caddr_t) NULL; 155 156 /* 157 * Tell the link level that the pkcb is dissolving 158 */ 159 if (pp -> pr_ctlinput && pkp -> pk_llnext) { 160 ctlinfo.dlcti_pcb = pkp -> pk_llnext; 161 ctlinfo.dlcti_rt = pkp -> pk_rt; 162 (pp -> pr_ctlinput)(PRC_DISCONNECT_REQUEST, 163 pkp -> pk_xcp, &ctlinfo); 164 } 165 free ((caddr_t) pkp -> pk_chan, M_IFADDR); 166 free ((caddr_t) pkp, M_PCB); 167 } 168 169 return (0); 170 } 171 172 173 pk_resize (pkp) 174 register struct pkcb *pkp; 175 { 176 struct pklcd *dev_lcp = 0; 177 struct x25config *xcp = pkp -> pk_xcp; 178 if (pkp -> pk_chan && 179 (pkp -> pk_maxlcn != xcp -> xc_maxlcn)) { 180 pk_restart (pkp, X25_RESTART_NETWORK_CONGESTION); 181 dev_lcp = pkp -> pk_chan[0]; 182 free ((caddr_t) pkp -> pk_chan, M_IFADDR); 183 pkp -> pk_chan = 0; 184 } 185 if (pkp -> pk_chan == 0) { 186 unsigned size; 187 pkp -> pk_maxlcn = xcp -> xc_maxlcn; 188 size = (pkp -> pk_maxlcn + 1) * sizeof (struct pklcd *); 189 pkp -> pk_chan = 190 (struct pklcd **) malloc (size, M_IFADDR, M_WAITOK); 191 if (pkp -> pk_chan) { 192 bzero ((caddr_t) pkp -> pk_chan, size); 193 /* 194 * Allocate a logical channel descriptor for lcn 0 195 */ 196 if (dev_lcp == 0 && 197 (dev_lcp = pk_attach ((struct socket *)0)) == 0) 198 return (ENOBUFS); 199 dev_lcp -> lcd_state = READY; 200 dev_lcp -> lcd_pkp = pkp; 201 pkp -> pk_chan[0] = dev_lcp; 202 } else { 203 if (dev_lcp) 204 pk_close (dev_lcp); 205 return (ENOBUFS); 206 } 207 } 208 return 0; 209 } 210 211 /* 212 * This procedure is called by the link level whenever the link 213 * becomes operational, is reset, or when the link goes down. 214 */ 215 /*VARARGS*/ 216 caddr_t 217 pk_ctlinput (code, src, addr) 218 struct sockaddr *src; 219 caddr_t addr; 220 { 221 register struct pkcb *pkp = (struct pkcb *) addr; 222 223 switch (code) { 224 case PRC_LINKUP: 225 if (pkp -> pk_state == DTE_WAITING) 226 pk_restart (pkp, X25_RESTART_NETWORK_CONGESTION); 227 break; 228 229 case PRC_LINKDOWN: 230 pk_restart (pkp, -1); /* Clear all active circuits */ 231 pkp -> pk_state = DTE_WAITING; 232 break; 233 234 case PRC_LINKRESET: 235 pk_restart (pkp, X25_RESTART_NETWORK_CONGESTION); 236 break; 237 238 case PRC_CONNECT_INDICATION: { 239 struct rtentry *llrt; 240 241 if ((llrt = rtalloc1(src, 0)) == 0) 242 return 0; 243 else llrt -> rt_refcnt--; 244 245 pkp = (((struct npaidbentry *) llrt -> rt_llinfo) -> np_rt) ? 246 (struct pkcb *)(((struct npaidbentry *) llrt -> rt_llinfo) -> np_rt -> rt_llinfo) : (struct pkcb *) 0; 247 if (pkp == (struct pkcb *) 0) 248 return 0; 249 pkp -> pk_llnext = addr; 250 251 return ((caddr_t) pkp); 252 } 253 case PRC_DISCONNECT_INDICATION: 254 pk_restart (pkp, -1) ; /* Clear all active circuits */ 255 pkp -> pk_state = DTE_WAITING; 256 pkp -> pk_llnext = (caddr_t) 0; 257 } 258 return (0); 259 } 260 struct ifqueue pkintrq; 261 /* 262 * This routine is called if there are semi-smart devices that do HDLC 263 * in hardware and want to queue the packet and call level 3 directly 264 */ 265 pkintr () 266 { 267 register struct mbuf *m; 268 register struct ifaddr *ifa; 269 register struct ifnet *ifp; 270 register int s; 271 272 for (;;) { 273 s = splimp (); 274 IF_DEQUEUE (&pkintrq, m); 275 splx (s); 276 if (m == 0) 277 break; 278 if (m -> m_len < PKHEADERLN) { 279 printf ("pkintr: packet too short (len=%d)\n", 280 m -> m_len); 281 m_freem (m); 282 continue; 283 } 284 pk_input (m); 285 } 286 } 287 struct mbuf *pk_bad_packet; 288 struct mbuf_cache pk_input_cache = {0 }; 289 /* 290 * X.25 PACKET INPUT 291 * 292 * This procedure is called by a link level procedure whenever 293 * an information frame is received. It decodes the packet and 294 * demultiplexes based on the logical channel number. 295 * 296 * We change the original conventions of the UBC code here -- 297 * since there may be multiple pkcb's for a given interface 298 * of type 802.2 class 2, we retrieve which one it is from 299 * m_pkthdr.rcvif (which has been overwritten by lower layers); 300 * That field is then restored for the benefit of upper layers which 301 * may make use of it, such as CLNP. 302 * 303 */ 304 305 #define RESTART_DTE_ORIGINATED(xp) (((xp) -> packet_cause == X25_RESTART_DTE_ORIGINATED) || \ 306 ((xp) -> packet_cause >= X25_RESTART_DTE_ORIGINATED2)) 307 308 pk_input (m) 309 register struct mbuf *m; 310 { 311 register struct x25_packet *xp; 312 register struct pklcd *lcp; 313 register struct socket *so = 0; 314 register struct pkcb *pkp; 315 int ptype, lcn, lcdstate = LISTEN; 316 317 if (pk_input_cache.mbc_size || pk_input_cache.mbc_oldsize) 318 mbuf_cache (&pk_input_cache, m); 319 if ((m -> m_flags & M_PKTHDR) == 0) 320 panic ("pkintr"); 321 322 if ((pkp = (struct pkcb *) m -> m_pkthdr.rcvif) == 0) 323 return; 324 xp = mtod (m, struct x25_packet *); 325 ptype = pk_decode (xp); 326 lcn = LCN(xp); 327 lcp = pkp -> pk_chan[lcn]; 328 329 /* 330 * If the DTE is in Restart state, then it will ignore data, 331 * interrupt, call setup and clearing, flow control and reset 332 * packets. 333 */ 334 if (lcn < 0 || lcn > pkp -> pk_maxlcn) { 335 pk_message (lcn, pkp -> pk_xcp, "illegal lcn"); 336 m_freem (m); 337 return; 338 } 339 340 pk_trace (pkp -> pk_xcp, m, "P-In"); 341 342 if (pkp -> pk_state != DTE_READY && ptype != RESTART && ptype != RESTART_CONF) { 343 m_freem (m); 344 return; 345 } 346 if (lcp) { 347 so = lcp -> lcd_so; 348 lcdstate = lcp -> lcd_state; 349 } else { 350 if (ptype == CLEAR) { /* idle line probe (Datapac specific) */ 351 /* send response on lcd 0's output queue */ 352 lcp = pkp -> pk_chan[0]; 353 lcp -> lcd_template = pk_template (lcn, X25_CLEAR_CONFIRM); 354 pk_output (lcp); 355 m_freem (m); 356 return; 357 } 358 if (ptype != CALL) 359 ptype = INVALID_PACKET; 360 } 361 362 if (lcn == 0 && ptype != RESTART && ptype != RESTART_CONF) { 363 pk_message (0, pkp -> pk_xcp, "illegal ptype (%d, %s) on lcn 0", 364 ptype, pk_name[ptype / MAXSTATES]); 365 if (pk_bad_packet) 366 m_freem (pk_bad_packet); 367 pk_bad_packet = m; 368 return; 369 } 370 371 m -> m_pkthdr.rcvif = pkp -> pk_ia -> ia_ifp; 372 373 switch (ptype + lcdstate) { 374 /* 375 * Incoming Call packet received. 376 */ 377 case CALL + LISTEN: 378 pk_incoming_call (pkp, m); 379 break; 380 381 /* 382 * Call collision: Just throw this "incoming call" away since 383 * the DCE will ignore it anyway. 384 */ 385 case CALL + SENT_CALL: 386 pk_message ((int) lcn, pkp -> pk_xcp, 387 "incoming call collision"); 388 break; 389 390 /* 391 * Call confirmation packet received. This usually means our 392 * previous connect request is now complete. 393 */ 394 case CALL_ACCEPTED + SENT_CALL: 395 MCHTYPE(m, MT_CONTROL); 396 pk_call_accepted (lcp, m); 397 break; 398 399 /* 400 * This condition can only happen if the previous state was 401 * SENT_CALL. Just ignore the packet, eventually a clear 402 * confirmation should arrive. 403 */ 404 case CALL_ACCEPTED + SENT_CLEAR: 405 break; 406 407 /* 408 * Clear packet received. This requires a complete tear down 409 * of the virtual circuit. Free buffers and control blocks. 410 * and send a clear confirmation. 411 */ 412 case CLEAR + READY: 413 case CLEAR + RECEIVED_CALL: 414 case CLEAR + SENT_CALL: 415 case CLEAR + DATA_TRANSFER: 416 lcp -> lcd_state = RECEIVED_CLEAR; 417 lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CLEAR_CONFIRM); 418 pk_output (lcp); 419 pk_clearcause (pkp, xp); 420 if (lcp -> lcd_upper) { 421 MCHTYPE(m, MT_CONTROL); 422 lcp -> lcd_upper (lcp, m); 423 } 424 pk_close (lcp); 425 lcp = 0; 426 break; 427 428 /* 429 * Clear collision: Treat this clear packet as a confirmation. 430 */ 431 case CLEAR + SENT_CLEAR: 432 pk_close (lcp); 433 break; 434 435 /* 436 * Clear confirmation received. This usually means the virtual 437 * circuit is now completely removed. 438 */ 439 case CLEAR_CONF + SENT_CLEAR: 440 pk_close (lcp); 441 break; 442 443 /* 444 * A clear confirmation on an unassigned logical channel - just 445 * ignore it. Note: All other packets on an unassigned channel 446 * results in a clear. 447 */ 448 case CLEAR_CONF + READY: 449 case CLEAR_CONF + LISTEN: 450 break; 451 452 /* 453 * Data packet received. Pass on to next level. Move the Q and M 454 * bits into the data portion for the next level. 455 */ 456 case DATA + DATA_TRANSFER: 457 if (lcp -> lcd_reset_condition) { 458 ptype = DELETE_PACKET; 459 break; 460 } 461 462 /* 463 * Process the P(S) flow control information in this Data packet. 464 * Check that the packets arrive in the correct sequence and that 465 * they are within the "lcd_input_window". Input window rotation is 466 * initiated by the receive interface. 467 */ 468 469 if (PS(xp) != ((lcp -> lcd_rsn + 1) % MODULUS) || 470 PS(xp) == ((lcp -> lcd_input_window + lcp -> lcd_windowsize) % MODULUS)) { 471 m_freem (m); 472 pk_procerror (RESET, lcp, "p(s) flow control error", 1); 473 break; 474 } 475 lcp -> lcd_rsn = PS(xp); 476 477 if (pk_ack (lcp, PR(xp)) != PACKET_OK) { 478 m_freem (m); 479 break; 480 } 481 m -> m_data += PKHEADERLN; 482 m -> m_len -= PKHEADERLN; 483 m -> m_pkthdr.len -= PKHEADERLN; 484 485 lcp -> lcd_rxcnt++; 486 if (lcp -> lcd_flags & X25_MBS_HOLD) { 487 register struct mbuf *n = lcp -> lcd_cps; 488 int mbit = MBIT(xp); 489 octet q_and_d_bits; 490 491 if (n) { 492 n -> m_pkthdr.len += m -> m_pkthdr.len; 493 while (n -> m_next) 494 n = n -> m_next; 495 n -> m_next = m; 496 m = lcp -> lcd_cps; 497 498 if (lcp -> lcd_cpsmax && 499 n -> m_pkthdr.len > lcp -> lcd_cpsmax) { 500 pk_procerror (RESET, lcp, 501 "C.P.S. overflow", 128); 502 return; 503 } 504 q_and_d_bits = 0xc0 & *(octet *) xp; 505 xp = (struct x25_packet *) 506 (mtod (m, octet *) - PKHEADERLN); 507 *(octet *) xp |= q_and_d_bits; 508 } 509 if (mbit) { 510 lcp -> lcd_cps = m; 511 pk_flowcontrol (lcp, 0, 1); 512 return; 513 } 514 lcp -> lcd_cps = 0; 515 } 516 if (so == 0) 517 break; 518 if (lcp -> lcd_flags & X25_MQBIT) { 519 octet t = (X25GBITS(xp -> bits, q_bit)) ? t = 0x80 : 0; 520 521 if (MBIT(xp)) 522 t |= 0x40; 523 m -> m_data -= 1; 524 m -> m_len += 1; 525 m -> m_pkthdr.len += 1; 526 *mtod (m, octet *) = t; 527 } 528 529 /* 530 * Discard Q-BIT packets if the application 531 * doesn't want to be informed of M and Q bit status 532 */ 533 if (X25GBITS(xp -> bits, q_bit) 534 && (lcp -> lcd_flags & X25_MQBIT) == 0) { 535 m_freem (m); 536 /* 537 * NB. This is dangerous: sending a RR here can 538 * cause sequence number errors if a previous data 539 * packet has not yet been passed up to the application 540 * (RR's are normally generated via PRU_RCVD). 541 */ 542 pk_flowcontrol (lcp, 0, 1); 543 } else { 544 sbappendrecord (&so -> so_rcv, m); 545 sorwakeup (so); 546 } 547 break; 548 549 /* 550 * Interrupt packet received. 551 */ 552 case INTERRUPT + DATA_TRANSFER: 553 if (lcp -> lcd_reset_condition) 554 break; 555 lcp -> lcd_intrdata = xp -> packet_data; 556 lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_INTERRUPT_CONFIRM); 557 pk_output (lcp); 558 m -> m_data += PKHEADERLN; 559 m -> m_len -= PKHEADERLN; 560 m -> m_pkthdr.len -= PKHEADERLN; 561 MCHTYPE(m, MT_OOBDATA); 562 if (so) { 563 if (so -> so_options & SO_OOBINLINE) 564 sbinsertoob (&so -> so_rcv, m); 565 else 566 m_freem (m); 567 sohasoutofband (so); 568 } 569 break; 570 571 /* 572 * Interrupt confirmation packet received. 573 */ 574 case INTERRUPT_CONF + DATA_TRANSFER: 575 if (lcp -> lcd_reset_condition) 576 break; 577 if (lcp -> lcd_intrconf_pending == TRUE) 578 lcp -> lcd_intrconf_pending = FALSE; 579 else 580 pk_procerror (RESET, lcp, "unexpected packet", 43); 581 break; 582 583 /* 584 * Receiver ready received. Rotate the output window and output 585 * any data packets waiting transmission. 586 */ 587 case RR + DATA_TRANSFER: 588 if (lcp -> lcd_reset_condition || 589 pk_ack (lcp, PR(xp)) != PACKET_OK) { 590 ptype = DELETE_PACKET; 591 break; 592 } 593 if (lcp -> lcd_rnr_condition == TRUE) 594 lcp -> lcd_rnr_condition = FALSE; 595 pk_output (lcp); 596 break; 597 598 /* 599 * Receiver Not Ready received. Packets up to the P(R) can be 600 * be sent. Condition is cleared with a RR. 601 */ 602 case RNR + DATA_TRANSFER: 603 if (lcp -> lcd_reset_condition || 604 pk_ack (lcp, PR(xp)) != PACKET_OK) { 605 ptype = DELETE_PACKET; 606 break; 607 } 608 lcp -> lcd_rnr_condition = TRUE; 609 break; 610 611 /* 612 * Reset packet received. Set state to FLOW_OPEN. The Input and 613 * Output window edges ar set to zero. Both the send and receive 614 * numbers are reset. A confirmation is returned. 615 */ 616 case RESET + DATA_TRANSFER: 617 if (lcp -> lcd_reset_condition) 618 /* Reset collision. Just ignore packet. */ 619 break; 620 621 pk_resetcause (pkp, xp); 622 lcp -> lcd_window_condition = lcp -> lcd_rnr_condition = 623 lcp -> lcd_intrconf_pending = FALSE; 624 lcp -> lcd_output_window = lcp -> lcd_input_window = 625 lcp -> lcd_last_transmitted_pr = 0; 626 lcp -> lcd_ssn = 0; 627 lcp -> lcd_rsn = MODULUS - 1; 628 629 lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_RESET_CONFIRM); 630 pk_output (lcp); 631 632 pk_flush (lcp); 633 if (so == 0) 634 break; 635 wakeup ((caddr_t) & so -> so_timeo); 636 sorwakeup (so); 637 sowwakeup (so); 638 break; 639 640 /* 641 * Reset confirmation received. 642 */ 643 case RESET_CONF + DATA_TRANSFER: 644 if (lcp -> lcd_reset_condition) { 645 lcp -> lcd_reset_condition = FALSE; 646 pk_output (lcp); 647 } 648 else 649 pk_procerror (RESET, lcp, "unexpected packet", 32); 650 break; 651 652 case DATA + SENT_CLEAR: 653 ptype = DELETE_PACKET; 654 case RR + SENT_CLEAR: 655 case RNR + SENT_CLEAR: 656 case INTERRUPT + SENT_CLEAR: 657 case INTERRUPT_CONF + SENT_CLEAR: 658 case RESET + SENT_CLEAR: 659 case RESET_CONF + SENT_CLEAR: 660 /* Just ignore p if we have sent a CLEAR already. 661 */ 662 break; 663 664 /* 665 * Restart sets all the permanent virtual circuits to the "Data 666 * Transfer" stae and all the switched virtual circuits to the 667 * "Ready" state. 668 */ 669 case RESTART + READY: 670 switch (pkp -> pk_state) { 671 case DTE_SENT_RESTART: 672 /* 673 * Restart collision. 674 * If case the restart cause is "DTE originated" we 675 * have a DTE-DTE situation and are trying to resolve 676 * who is going to play DTE/DCE [ISO 8208:4.2-4.5] 677 */ 678 if (RESTART_DTE_ORIGINATED(xp)) { 679 pk_restart (pkp, X25_RESTART_DTE_ORIGINATED); 680 pk_message (0, pkp -> pk_xcp, 681 "RESTART collision"); 682 if ((pkp -> pk_restartcolls++) > MAXRESTARTCOLLISIONS) { 683 pk_message (0, pkp -> pk_xcp, 684 "excessive RESTART collisions"); 685 pkp -> pk_restartcolls = 0; 686 } 687 break; 688 } 689 pkp -> pk_state = DTE_READY; 690 pkp -> pk_dxerole |= DTE_PLAYDTE; 691 pkp -> pk_dxerole &= ~DTE_PLAYDCE; 692 pk_message (0, pkp -> pk_xcp, 693 "Packet level operational"); 694 pk_message (0, pkp -> pk_xcp, 695 "Assuming DTE role"); 696 if (pkp -> pk_dxerole & DTE_CONNECTPENDING) 697 pk_callcomplete (pkp); 698 break; 699 700 default: 701 pk_restart (pkp, -1); 702 pk_restartcause (pkp, xp); 703 pkp -> pk_chan[0] -> lcd_template = pk_template (0, 704 X25_RESTART_CONFIRM); 705 pk_output (pkp -> pk_chan[0]); 706 pkp -> pk_state = DTE_READY; 707 pkp -> pk_dxerole |= RESTART_DTE_ORIGINATED(xp) ? DTE_PLAYDCE : 708 DTE_PLAYDTE; 709 if (pkp -> pk_dxerole & DTE_PLAYDTE) { 710 pkp -> pk_dxerole &= ~DTE_PLAYDCE; 711 pk_message (0, pkp -> pk_xcp, 712 "Assuming DTE role"); 713 } else { 714 pkp -> pk_dxerole &= ~DTE_PLAYDTE; 715 pk_message (0, pkp -> pk_xcp, 716 "Assuming DCE role"); 717 } 718 if (pkp -> pk_dxerole & DTE_CONNECTPENDING) 719 pk_callcomplete (pkp); 720 } 721 break; 722 723 /* 724 * Restart confirmation received. All logical channels are set 725 * to READY. 726 */ 727 case RESTART_CONF + READY: 728 switch (pkp -> pk_state) { 729 case DTE_SENT_RESTART: 730 pkp -> pk_state = DTE_READY; 731 pkp -> pk_dxerole |= DTE_PLAYDTE; 732 pkp -> pk_dxerole &= ~DTE_PLAYDCE; 733 pk_message (0, pkp -> pk_xcp, 734 "Packet level operational"); 735 pk_message (0, pkp -> pk_xcp, 736 "Assuming DTE role"); 737 if (pkp -> pk_dxerole & DTE_CONNECTPENDING) 738 pk_callcomplete (pkp); 739 break; 740 741 default: 742 /* Restart local procedure error. */ 743 pk_restart (pkp, X25_RESTART_LOCAL_PROCEDURE_ERROR); 744 pkp -> pk_state = DTE_SENT_RESTART; 745 pkp -> pk_dxerole &= ~(DTE_PLAYDTE | DTE_PLAYDCE); 746 } 747 break; 748 749 default: 750 if (lcp) { 751 pk_procerror (CLEAR, lcp, "unknown packet error", 33); 752 pk_message (lcn, pkp -> pk_xcp, 753 "\"%s\" unexpected in \"%s\" state", 754 pk_name[ptype/MAXSTATES], pk_state[lcdstate]); 755 } else 756 pk_message (lcn, pkp -> pk_xcp, 757 "packet arrived on unassigned lcn"); 758 break; 759 } 760 if (so == 0 && lcp && lcp -> lcd_upper && lcdstate == DATA_TRANSFER) { 761 if (ptype != DATA && ptype != INTERRUPT) 762 MCHTYPE(m, MT_CONTROL); 763 lcp -> lcd_upper (lcp, m); 764 } else if (ptype != DATA && ptype != INTERRUPT) 765 m_freem (m); 766 } 767 768 static 769 prune_dnic (from, to, dnicname, xcp) 770 char *from, *to, *dnicname; 771 register struct x25config *xcp; 772 { 773 register char *cp1 = from, *cp2 = from; 774 if (xcp -> xc_prepnd0 && *cp1 == '0') { 775 from = ++cp1; 776 goto copyrest; 777 } 778 if (xcp -> xc_nodnic) { 779 for (cp1 = dnicname; *cp2 = *cp1++;) 780 cp2++; 781 cp1 = from; 782 } 783 copyrest: 784 for (cp1 = dnicname; *cp2 = *cp1++;) 785 cp2++; 786 } 787 /* static */ 788 pk_simple_bsd (from, to, lower, len) 789 register octet *from, *to; 790 register len, lower; 791 { 792 register int c; 793 while (--len >= 0) { 794 c = *from; 795 if (lower & 0x01) 796 *from++; 797 else 798 c >>= 4; 799 c &= 0x0f; c |= 0x30; *to++ = c; lower++; 800 } 801 *to = 0; 802 } 803 804 /*static octet * */ 805 pk_from_bcd (a, iscalling, sa, xcp) 806 register struct x25_calladdr *a; 807 register struct sockaddr_x25 *sa; 808 register struct x25config *xcp; 809 { 810 octet buf[MAXADDRLN+1]; 811 octet *cp; 812 unsigned count; 813 814 bzero ((caddr_t) sa, sizeof (*sa)); 815 sa -> x25_len = sizeof (*sa); 816 sa -> x25_family = AF_CCITT; 817 if (iscalling) { 818 cp = a -> address_field + (X25GBITS(a -> addrlens, called_addrlen) / 2); 819 count = X25GBITS(a -> addrlens, calling_addrlen); 820 pk_simple_bsd (cp, buf, X25GBITS(a -> addrlens, called_addrlen), count); 821 } else { 822 count = X25GBITS(a -> addrlens, called_addrlen); 823 pk_simple_bsd (a -> address_field, buf, 0, count); 824 } 825 if (xcp -> xc_addr.x25_net && (xcp -> xc_nodnic || xcp -> xc_prepnd0)) { 826 octet dnicname[sizeof (long) * NBBY/3 + 2]; 827 828 sprintf ((char *) dnicname, "%d", xcp -> xc_addr.x25_net); 829 prune_dnic ((char *) buf, sa -> x25_addr, dnicname, xcp); 830 } else 831 bcopy ((caddr_t) buf, (caddr_t) sa -> x25_addr, count + 1); 832 } 833 834 static 835 save_extra (m0, fp, so) 836 struct mbuf *m0; 837 octet *fp; 838 struct socket *so; 839 { 840 register struct mbuf *m; 841 struct cmsghdr cmsghdr; 842 if (m = m_copy (m, 0, (int)M_COPYALL)) { 843 int off = fp - mtod (m0, octet *); 844 int len = m -> m_pkthdr.len - off + sizeof (cmsghdr); 845 cmsghdr.cmsg_len = len; 846 cmsghdr.cmsg_level = AF_CCITT; 847 cmsghdr.cmsg_type = PK_FACILITIES; 848 m_adj (m, off); 849 M_PREPEND (m, sizeof (cmsghdr), M_DONTWAIT); 850 if (m == 0) 851 return; 852 bcopy ((caddr_t)&cmsghdr, mtod (m, caddr_t), sizeof (cmsghdr)); 853 MCHTYPE(m, MT_CONTROL); 854 sbappendrecord (&so -> so_rcv, m); 855 } 856 } 857 858 /* 859 * This routine handles incoming call packets. It matches the protocol 860 * field on the Call User Data field (usually the first four bytes) with 861 * sockets awaiting connections. 862 */ 863 864 pk_incoming_call (pkp, m0) 865 struct mbuf *m0; 866 struct pkcb *pkp; 867 { 868 register struct pklcd *lcp = 0, *l; 869 register struct sockaddr_x25 *sa; 870 register struct x25_calladdr *a; 871 register struct socket *so = 0; 872 struct x25_packet *xp = mtod (m0, struct x25_packet *); 873 struct mbuf *m; 874 struct x25config *xcp = pkp -> pk_xcp; 875 int len = m0 -> m_pkthdr.len; 876 unsigned udlen; 877 char *errstr = "server unavailable"; 878 octet *u, *facp; 879 int lcn = LCN(xp); 880 881 /* First, copy the data from the incoming call packet to a X25 address 882 descriptor. It is to be regretted that you have 883 to parse the facilities into a sockaddr to determine 884 if reverse charging is being requested */ 885 if ((m = m_get (M_DONTWAIT, MT_SONAME)) == 0) 886 return; 887 sa = mtod (m, struct sockaddr_x25 *); 888 a = (struct x25_calladdr *) &xp -> packet_data; 889 facp = u = (octet *) (a -> address_field + 890 ((X25GBITS(a -> addrlens, called_addrlen) + X25GBITS(a -> addrlens, calling_addrlen) + 1) / 2)); 891 u += *u + 1; 892 udlen = min (16, ((octet *) xp) + len - u); 893 if (udlen < 0) 894 udlen = 0; 895 pk_from_bcd (a, 1, sa, pkp -> pk_xcp); /* get calling address */ 896 pk_parse_facilities (facp, sa); 897 bcopy ((caddr_t) u, sa -> x25_udata, udlen); 898 sa -> x25_udlen = udlen; 899 900 /* 901 * Now, loop through the listen sockets looking for a match on the 902 * PID. That is the first few octets of the user data field. 903 * This is the closest thing to a port number for X.25 packets. 904 * It does provide a way of multiplexing services at the user level. 905 */ 906 907 for (l = pk_listenhead; l; l = l -> lcd_listen) { 908 struct sockaddr_x25 *sxp = l -> lcd_ceaddr; 909 910 if (bcmp (sxp -> x25_udata, u, sxp -> x25_udlen)) 911 continue; 912 if (sxp -> x25_net && 913 sxp -> x25_net != xcp -> xc_addr.x25_net) 914 continue; 915 /* 916 * don't accept incoming calls with the D-Bit on 917 * unless the server agrees 918 */ 919 if (X25GBITS(xp -> bits, d_bit) && !(sxp -> x25_opts.op_flags & X25_DBIT)) { 920 errstr = "incoming D-Bit mismatch"; 921 break; 922 } 923 /* 924 * don't accept incoming collect calls unless 925 * the server sets the reverse charging option. 926 */ 927 if ((sxp -> x25_opts.op_flags & (X25_OLDSOCKADDR|X25_REVERSE_CHARGE)) == 0 && 928 sa -> x25_opts.op_flags & X25_REVERSE_CHARGE) { 929 errstr = "incoming collect call refused"; 930 break; 931 } 932 if (l -> lcd_so) { 933 if (so = sonewconn (l -> lcd_so, SS_ISCONNECTED)) 934 lcp = (struct pklcd *) so -> so_pcb; 935 } else 936 lcp = pk_attach ((struct socket *) 0); 937 if (lcp == 0) { 938 /* 939 * Insufficient space or too many unaccepted 940 * connections. Just throw the call away. 941 */ 942 errstr = "server malfunction"; 943 break; 944 } 945 lcp -> lcd_upper = l -> lcd_upper; 946 lcp -> lcd_upnext = l -> lcd_upnext; 947 lcp -> lcd_lcn = lcn; 948 lcp -> lcd_state = RECEIVED_CALL; 949 sa -> x25_opts.op_flags |= (sxp -> x25_opts.op_flags & 950 ~X25_REVERSE_CHARGE) | l -> lcd_flags; 951 pk_assoc (pkp, lcp, sa); 952 lcp -> lcd_faddr = *sa; 953 lcp -> lcd_laddr.x25_udlen = sxp -> x25_udlen; 954 lcp -> lcd_craddr = &lcp -> lcd_faddr; 955 lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CALL_ACCEPTED); 956 if (lcp -> lcd_flags & X25_DBIT) { 957 if (X25GBITS(xp -> bits, d_bit)) 958 X25SBITS(mtod (lcp -> lcd_template, 959 struct x25_packet *) -> bits, d_bit, 1); 960 else 961 lcp -> lcd_flags &= ~X25_DBIT; 962 } 963 if (so) { 964 pk_output (lcp); 965 soisconnected (so); 966 if (so -> so_options & SO_OOBINLINE) 967 save_extra (m0, facp, so); 968 } else if (lcp -> lcd_upper) { 969 (*lcp -> lcd_upper) (lcp, m0); 970 } 971 (void) m_free (m); 972 return; 973 } 974 975 /* 976 * If the call fails for whatever reason, we still need to build a 977 * skeleton LCD in order to be able to properly receive the CLEAR 978 * CONFIRMATION. 979 */ 980 #ifdef WATERLOO /* be explicit */ 981 if (l == 0 && bcmp (sa -> x25_udata, "ean", 3) == 0) 982 pk_message (lcn, pkp -> pk_xcp, "host=%s ean%c: %s", 983 sa -> x25_addr, sa -> x25_udata[3] & 0xff, errstr); 984 else if (l == 0 && bcmp (sa -> x25_udata, "\1\0\0\0", 4) == 0) 985 pk_message (lcn, pkp -> pk_xcp, "host=%s x29d: %s", 986 sa -> x25_addr, errstr); 987 else 988 #endif 989 pk_message (lcn, pkp -> pk_xcp, "host=%s pid=%x %x %x %x: %s", 990 sa -> x25_addr, sa -> x25_udata[0] & 0xff, 991 sa -> x25_udata[1] & 0xff, sa -> x25_udata[2] & 0xff, 992 sa -> x25_udata[3] & 0xff, errstr); 993 if ((lcp = pk_attach ((struct socket *)0)) == 0) { 994 (void) m_free (m); 995 return; 996 } 997 lcp -> lcd_lcn = lcn; 998 lcp -> lcd_state = RECEIVED_CALL; 999 pk_assoc (pkp, lcp, sa); 1000 (void) m_free (m); 1001 pk_clear (lcp, 0, 1); 1002 } 1003 1004 pk_call_accepted (lcp, m) 1005 struct pklcd *lcp; 1006 struct mbuf *m; 1007 { 1008 register struct x25_calladdr *ap; 1009 register octet *fcp; 1010 struct x25_packet *xp = mtod (m, struct x25_packet *); 1011 int len = m -> m_len; 1012 1013 lcp -> lcd_state = DATA_TRANSFER; 1014 if (lcp -> lcd_so) 1015 soisconnected (lcp -> lcd_so); 1016 if ((lcp -> lcd_flags & X25_DBIT) && (X25GBITS(xp -> bits, d_bit) == 0)) 1017 lcp -> lcd_flags &= ~X25_DBIT; 1018 if (len > 3) { 1019 ap = (struct x25_calladdr *) &xp -> packet_data; 1020 fcp = (octet *) ap -> address_field + (X25GBITS(ap -> addrlens, calling_addrlen) + 1021 X25GBITS(ap -> addrlens, called_addrlen) + 1) / 2; 1022 if (fcp + *fcp <= ((octet *) xp) + len) 1023 pk_parse_facilities (fcp, lcp -> lcd_ceaddr); 1024 } 1025 pk_assoc (lcp -> lcd_pkp, lcp, lcp -> lcd_ceaddr); 1026 if (lcp -> lcd_so == 0 && lcp -> lcd_upper) 1027 lcp -> lcd_upper (lcp, m); 1028 } 1029 1030 pk_parse_facilities (fcp, sa) 1031 register octet *fcp; 1032 register struct sockaddr_x25 *sa; 1033 { 1034 register octet *maxfcp; 1035 1036 maxfcp = fcp + *fcp; 1037 fcp++; 1038 while (fcp < maxfcp) { 1039 /* 1040 * Ignore national DCE or DTE facilities 1041 */ 1042 if (*fcp == 0 || *fcp == 0xff) 1043 break; 1044 switch (*fcp) { 1045 case FACILITIES_WINDOWSIZE: 1046 sa -> x25_opts.op_wsize = fcp[1]; 1047 fcp += 3; 1048 break; 1049 1050 case FACILITIES_PACKETSIZE: 1051 sa -> x25_opts.op_psize = fcp[1]; 1052 fcp += 3; 1053 break; 1054 1055 case FACILITIES_THROUGHPUT: 1056 sa -> x25_opts.op_speed = fcp[1]; 1057 fcp += 2; 1058 break; 1059 1060 case FACILITIES_REVERSE_CHARGE: 1061 if (fcp[1] & 01) 1062 sa -> x25_opts.op_flags |= X25_REVERSE_CHARGE; 1063 /* 1064 * Datapac specific: for a X.25(1976) DTE, bit 2 1065 * indicates a "hi priority" (eg. international) call. 1066 */ 1067 if (fcp[1] & 02 && sa -> x25_opts.op_psize == 0) 1068 sa -> x25_opts.op_psize = X25_PS128; 1069 fcp += 2; 1070 break; 1071 1072 default: 1073 /*printf("unknown facility %x, class=%d\n", *fcp, (*fcp & 0xc0) >> 6);*/ 1074 switch ((*fcp & 0xc0) >> 6) { 1075 case 0: /* class A */ 1076 fcp += 2; 1077 break; 1078 1079 case 1: 1080 fcp += 3; 1081 break; 1082 1083 case 2: 1084 fcp += 4; 1085 break; 1086 1087 case 3: 1088 fcp++; 1089 fcp += *fcp; 1090 } 1091 } 1092 } 1093 } 1094