1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26
27 /*
28 * llc1 - an LLC Class 1 MUX compatible with SunConnect LLC2 uses DLPI
29 * interface. Its primary use is to support RPL for network boot but can be
30 * used by other protocols.
31 */
32
33 #include <sys/types.h>
34 #include <sys/errno.h>
35 #include <sys/param.h>
36 #include <sys/mkdev.h>
37 #include <sys/sysmacros.h>
38 #include <sys/systm.h>
39 #include <sys/stropts.h>
40 #include <sys/stream.h>
41 #include <sys/kmem.h>
42 #include <sys/conf.h>
43 #include <sys/ddi.h>
44 #include <sys/devops.h>
45 #include <sys/sunddi.h>
46 #include <sys/ksynch.h>
47 #include <sys/dlpi.h>
48 #include <sys/ethernet.h>
49 #include <sys/strsun.h>
50 #include <sys/stat.h>
51 #include <netinet/in.h> /* for byteorder macros on machines that define them */
52 #include <sys/llc1.h>
53 #include <sys/kstat.h>
54 #include <sys/debug.h>
55
56 /*
57 * function prototypes, etc.
58 */
59 static int llc1_open(queue_t *q, dev_t *dev, int flag, int sflag,
60 cred_t *cred);
61 static int llc1_close(queue_t *q, int flag, cred_t *cred);
62 static int llc1_uwput(queue_t *q, mblk_t *mp);
63 static int llc1_uwsrv(queue_t *q);
64 static int llc1_lrsrv(queue_t *q);
65 static int llc1_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
66 static int llc1_detach(dev_info_t *dev, ddi_detach_cmd_t cmd);
67 static int llc1_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd);
68
69 static mblk_t *llc1_form_udata(llc1_t *lld, llc_mac_info_t *macinfo,
70 mblk_t *mp);
71 static mblk_t *llc1_xid_reply(llc_mac_info_t *macinfo, mblk_t *mp, int sap);
72 static mblk_t *llc1_xid_ind_con(llc1_t *lld, llc_mac_info_t *macinfo,
73 mblk_t *mp);
74 static mblk_t *llc1_test_reply(llc_mac_info_t *macinfo, mblk_t *mp, int sap);
75 static mblk_t *llc1_test_ind_con(llc1_t *lld, llc_mac_info_t *macinfo,
76 mblk_t *mp);
77
78 static void llc1_ioctl(queue_t *q, mblk_t *mp);
79 static void llc1_recv(llc_mac_info_t *macinfo, mblk_t *mp);
80 static void llc1_req_raw(llc_mac_info_t *macinfo);
81 static void llc1_find_waiting(llc_mac_info_t *macinfo, mblk_t *mp, long prim);
82
83 static minor_t llc1_findminor(llc1dev_t *device);
84 static void llc1_send_disable_multi(llc_mac_info_t *, llc_mcast_t *);
85
86 static void llc1insque(void *elem, void *pred);
87 static void llc1remque(void *arg);
88 static void llc1error();
89 static int llc1_subs_unbind(void);
90 static void llc1_init_kstat(llc_mac_info_t *macinfo);
91 static void llc1_uninit_kstat(llc_mac_info_t *macinfo);
92 static int llc1_update_kstat(kstat_t *ksp, int rw);
93 static int llc1_broadcast(struct ether_addr *addr, llc_mac_info_t *macinfo);
94 static int llc1_unbind(queue_t *q, mblk_t *mp);
95 static int llc1_subs_bind(queue_t *q, mblk_t *mp);
96 static int llc1_unitdata(queue_t *q, mblk_t *mp);
97 static int llc1_inforeq(queue_t *q, mblk_t *mp);
98 static int llc1attach(queue_t *q, mblk_t *mp);
99 static void llc1_send_bindreq(llc_mac_info_t *macinfo);
100 static int llc1_req_info(queue_t *q);
101 static int llc1_cmds(queue_t *q, mblk_t *mp);
102 static int llc1_setppa(struct ll_snioc *snioc);
103 static int llc1_getppa(llc_mac_info_t *macinfo, struct ll_snioc *snioc);
104 static int llc1_bind(queue_t *q, mblk_t *mp);
105 static int llc1unattach(queue_t *q, mblk_t *mp);
106 static int llc1_enable_multi(queue_t *q, mblk_t *mp);
107 static int llc1_disable_multi(queue_t *q, mblk_t *mp);
108 static int llc1_xid_req_res(queue_t *q, mblk_t *mp, int req_or_res);
109 static int llc1_test_req_res(queue_t *q, mblk_t *mp, int req_or_res);
110 static int llc1_local(struct ether_addr *addr, llc_mac_info_t *macinfo);
111 static int llc1_snap_match(llc1_t *lld, struct snaphdr *snap);
112
113 /*
114 * the standard streams glue for defining the type of streams entity and the
115 * operational parameters.
116 */
117
118 static struct module_info llc1_minfo = {
119 LLC1IDNUM,
120 "llc1",
121 0,
122 LLC1_DEFMAX,
123 LLC1_HIWATER, /* high water mark */
124 LLC1_LOWATER, /* low water mark */
125 };
126
127 static struct qinit llc1_rint = {
128 NULL,
129 NULL,
130 llc1_open,
131 llc1_close,
132 NULL,
133 &llc1_minfo,
134 NULL
135 };
136
137 static struct qinit llc1_wint = {
138 llc1_uwput,
139 llc1_uwsrv,
140 NULL,
141 NULL,
142 NULL,
143 &llc1_minfo,
144 NULL
145 };
146
147 static struct qinit llc1_muxrint = {
148 putq,
149 llc1_lrsrv,
150 NULL,
151 NULL,
152 NULL,
153 &llc1_minfo,
154 NULL
155 };
156
157 static struct qinit llc1_muxwint = {
158 NULL,
159 NULL,
160 NULL,
161 NULL,
162 NULL,
163 &llc1_minfo,
164 NULL
165 };
166
167 struct streamtab llc1_info = {
168 &llc1_rint,
169 &llc1_wint,
170 &llc1_muxrint,
171 &llc1_muxwint
172 };
173
174 /*
175 * loadable module/driver wrapper this allows llc1 to be unloaded later
176 */
177
178 #if !defined(BUILD_STATIC)
179 #include <sys/modctl.h>
180
181 /* define the "ops" structure for a STREAMS driver */
182 DDI_DEFINE_STREAM_OPS(llc1_ops, nulldev, nulldev, llc1_attach,
183 llc1_detach, nodev, llc1_getinfo, D_MP | D_MTPERMOD, &llc1_info,
184 ddi_quiesce_not_supported);
185
186 /*
187 * Module linkage information for the kernel.
188 */
189 static struct modldrv modldrv = {
190 &mod_driverops, /* Type of module. This one is a driver */
191 "LLC Class 1 Driver",
192 &llc1_ops, /* driver ops */
193 };
194
195 static struct modlinkage modlinkage = {
196 MODREV_1, (void *)&modldrv, NULL
197 };
198
199 int
200 _init(void)
201 {
202 return (mod_install(&modlinkage));
203 }
204
205 int
206 _fini(void)
207 {
208 return (mod_remove(&modlinkage));
209 }
210
211 int
212 _info(struct modinfo *modinfop)
213 {
214 return (mod_info(&modlinkage, modinfop));
215 }
216
217 #endif
218
219 #ifdef LLC1_DEBUG
220 extern int llc1_debug = 0x0;
221
222 #endif
223
224 /*
225 * Allocate and zero-out "number" structures each of type "structure" in
226 * kernel memory.
227 */
228 #define GETSTRUCT(structure, number) \
229 (kmem_zalloc(sizeof (structure) * (number), KM_NOSLEEP))
230 #define GETBUF(structure, size) \
231 (kmem_zalloc(size, KM_NOSLEEP))
232
233 static struct llc1device llc1_device_list;
234
235 /*
236 * llc1_attach - init time attach support When the hardware specific attach
237 * is called, it must call this procedure with the device class structure
238 */
239
240 static int
241 llc1_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd)
242 {
243 if (cmd != DDI_ATTACH)
244 return (DDI_FAILURE);
245
246 /*
247 * there isn't any hardware but we do need to initialize things
248 */
249 if (!(llc1_device_list.llc1_status & LLC1_ATTACHED)) {
250 llc1_device_list.llc1_status |= LLC1_ATTACHED;
251 rw_init(&llc1_device_list.llc1_rwlock, NULL, RW_DRIVER, NULL);
252
253 /* make sure minor device lists are initialized */
254 llc1_device_list.llc1_str_next =
255 llc1_device_list.llc1_str_prev =
256 (llc1_t *)&llc1_device_list.llc1_str_next;
257
258 /* make sure device list is initialized */
259 llc1_device_list.llc1_mac_next =
260 llc1_device_list.llc1_mac_prev =
261 (llc_mac_info_t *)&llc1_device_list.llc1_mac_next;
262 }
263
264 /*
265 * now do all the DDI stuff necessary
266 */
267
268 ddi_set_driver_private(devinfo, &llc1_device_list);
269
270 /*
271 * create the file system device node
272 */
273 if (ddi_create_minor_node(devinfo, "llc1", S_IFCHR,
274 0, DDI_PSEUDO, CLONE_DEV) == DDI_FAILURE) {
275 llc1error(devinfo, "ddi_create_minor_node failed");
276 ddi_remove_minor_node(devinfo, NULL);
277 return (DDI_FAILURE);
278 }
279 llc1_device_list.llc1_multisize = ddi_getprop(DDI_DEV_T_NONE,
280 devinfo, 0, "multisize", 0);
281 if (llc1_device_list.llc1_multisize == 0)
282 llc1_device_list.llc1_multisize = LLC1_MAX_MULTICAST;
283
284 ddi_report_dev(devinfo);
285 return (DDI_SUCCESS);
286 }
287
288 /*
289 * llc1_detach standard kernel interface routine
290 */
291
292 static int
293 llc1_detach(dev_info_t *dev, ddi_detach_cmd_t cmd)
294 {
295 if (cmd != DDI_DETACH) {
296 return (DDI_FAILURE);
297 }
298 if (llc1_device_list.llc1_ndevice > 0)
299 return (DDI_FAILURE);
300 /* remove all mutex and locks */
301 rw_destroy(&llc1_device_list.llc1_rwlock);
302 llc1_device_list.llc1_status = 0; /* no longer attached */
303 ddi_remove_minor_node(dev, NULL);
304 return (DDI_SUCCESS);
305 }
306
307 /*
308 * llc1_devinfo(dev, cmd, arg, result) standard kernel devinfo lookup
309 * function
310 */
311 /*ARGSUSED2*/
312 static int
313 llc1_getinfo(dev_info_t *dev, ddi_info_cmd_t cmd, void *arg, void **result)
314 {
315 int error;
316
317 switch (cmd) {
318 case DDI_INFO_DEVT2DEVINFO:
319 if (dev == NULL) {
320 error = DDI_FAILURE;
321 } else {
322 *result = (void *)dev;
323 error = DDI_SUCCESS;
324 }
325 break;
326 case DDI_INFO_DEVT2INSTANCE:
327 *result = (void *)0;
328 error = DDI_SUCCESS;
329 break;
330 default:
331 error = DDI_FAILURE;
332 }
333 return (error);
334 }
335
336 /*
337 * llc1_open()
338 * LLC1 open routine, called when device is opened by the user
339 */
340
341 /*ARGSUSED2*/
342 static int
343 llc1_open(queue_t *q, dev_t *dev, int flag, int sflag, cred_t *cred)
344 {
345 llc1_t *llc1;
346 minor_t minordev;
347 int status = 0;
348
349 ASSERT(q);
350
351 /*
352 * Stream already open, sucess.
353 */
354 if (q->q_ptr)
355 return (0);
356 /*
357 * Serialize access through open/close this will serialize across all
358 * llc1 devices, but open and close are not frequent so should not
359 * induce much, if any delay.
360 */
361 rw_enter(&llc1_device_list.llc1_rwlock, RW_WRITER);
362
363 if (sflag == CLONEOPEN) {
364 /* need to find a minor dev */
365 minordev = llc1_findminor(&llc1_device_list);
366 if (minordev == 0) {
367 rw_exit(&llc1_device_list.llc1_rwlock);
368 return (ENXIO);
369 }
370 *dev = makedevice(getmajor(*dev), minordev);
371 } else {
372 minordev = getminor (*dev);
373 if ((minordev > MAXMIN32) || (minordev == 0)) {
374 rw_exit(&llc1_device_list.llc1_rwlock);
375 return (ENXIO);
376 }
377 }
378
379 /*
380 * get a per-stream structure and link things together so we
381 * can easily find them later.
382 */
383
384 llc1 = kmem_zalloc(sizeof (llc1_t), KM_SLEEP);
385 llc1->llc_qptr = q;
386 WR(q)->q_ptr = q->q_ptr = (caddr_t)llc1;
387 /*
388 * fill in the structure and state info
389 */
390 llc1->llc_state = DL_UNATTACHED;
391 llc1->llc_style = DL_STYLE2;
392 llc1->llc_minor = minordev;
393
394 mutex_init(&llc1->llc_lock, NULL, MUTEX_DRIVER, NULL);
395 llc1insque(llc1, llc1_device_list.llc1_str_prev);
396 rw_exit(&llc1_device_list.llc1_rwlock);
397 qprocson(q); /* start the queues running */
398 return (status);
399 }
400
401 /*
402 * llc1_close(q)
403 * normal stream close call checks current status and cleans up
404 * data structures that were dynamically allocated
405 */
406 /*ARGSUSED1*/
407 static int
408 llc1_close(queue_t *q, int flag, cred_t *cred)
409 {
410 llc1_t *llc1;
411
412 ASSERT(q);
413 ASSERT(q->q_ptr);
414
415 qprocsoff(q);
416 llc1 = (llc1_t *)q->q_ptr;
417 rw_enter(&llc1_device_list.llc1_rwlock, RW_WRITER);
418 /* completely disassociate the stream from the device */
419 q->q_ptr = WR(q)->q_ptr = NULL;
420
421 (void) llc1remque(llc1); /* remove from active list */
422 rw_exit(&llc1_device_list.llc1_rwlock);
423
424 mutex_enter(&llc1->llc_lock);
425 if (llc1->llc_state == DL_IDLE || llc1->llc_state == DL_UNBOUND) {
426 llc1->llc_state = DL_UNBOUND; /* force the issue */
427 }
428
429 if (llc1->llc_mcast != NULL) {
430 int i;
431
432 for (i = 0; i < llc1_device_list.llc1_multisize; i++) {
433 llc_mcast_t *mcast;
434
435 if ((mcast = llc1->llc_mcast[i]) != NULL) {
436 /*
437 * disable from stream and possibly
438 * lower stream
439 */
440 if (llc1->llc_mac_info &&
441 llc1->llc_mac_info->llcp_flags &
442 LLC1_AVAILABLE)
443 llc1_send_disable_multi(
444 llc1->llc_mac_info,
445 mcast);
446 llc1->llc_mcast[i] = NULL;
447 }
448 }
449 kmem_free(llc1->llc_mcast,
450 sizeof (llc_mcast_t *) * llc1->llc_multicnt);
451 llc1->llc_mcast = NULL;
452 }
453 llc1->llc_state = DL_UNATTACHED;
454
455 mutex_exit(&llc1->llc_lock);
456
457 mutex_destroy(&llc1->llc_lock);
458
459 kmem_free(llc1, sizeof (llc1_t));
460
461 return (0);
462 }
463
464 /*
465 * llc1_uwput()
466 * general llc stream write put routine. Receives ioctl's from
467 * user level and data from upper modules and processes them immediately.
468 * M_PROTO/M_PCPROTO are queued for later processing by the service
469 * procedure.
470 */
471
472 static int
473 llc1_uwput(queue_t *q, mblk_t *mp)
474 {
475 llc1_t *ld = (llc1_t *)(q->q_ptr);
476
477 #ifdef LLC1_DEBUG
478 if (llc1_debug & LLCTRACE)
479 printf("llc1_wput(%x %x): type %d\n", q, mp, DB_TYPE(mp));
480 #endif
481 switch (DB_TYPE(mp)) {
482
483 case M_IOCTL: /* no waiting in ioctl's */
484 (void) llc1_ioctl(q, mp);
485 break;
486
487 case M_FLUSH: /* canonical flush handling */
488 if (*mp->b_rptr & FLUSHW)
489 flushq(q, 0);
490
491 if (*mp->b_rptr & FLUSHR) {
492 flushq(RD(q), 0);
493 *mp->b_rptr &= ~FLUSHW;
494 qreply(q, mp);
495 } else
496 freemsg(mp);
497 break;
498
499 /* for now, we will always queue */
500 case M_PROTO:
501 case M_PCPROTO:
502 (void) putq(q, mp);
503 break;
504
505 case M_DATA:
506 /* fast data / raw support */
507 if ((ld->llc_flags & (LLC_RAW | LLC_FAST)) == 0 ||
508 ld->llc_state != DL_IDLE) {
509 (void) merror(q, mp, EPROTO);
510 break;
511 }
512 /* need to do further checking */
513 (void) putq(q, mp);
514 break;
515
516 default:
517 #ifdef LLC1_DEBUG
518 if (llc1_debug & LLCERRS)
519 printf("llc1: Unexpected packet type from queue: %d\n",
520 mp->b_datap->db_type);
521 #endif
522 freemsg(mp);
523 }
524 return (0);
525 }
526
527 /*
528 * llc1_lrsrv()
529 * called when data is put into the service queue from below.
530 * Determines additional processing that might be needed and sends the data
531 * upstream in the form of a Data Indication packet.
532 */
533 static int
534 llc1_lrsrv(queue_t *q)
535 {
536 mblk_t *mp;
537 union DL_primitives *prim;
538 llc_mac_info_t *macinfo = (llc_mac_info_t *)q->q_ptr;
539 struct iocblk *iocp;
540
541 #ifdef LLC1_DEBUG
542 if (llc1_debug & LLCTRACE)
543 printf("llc1_rsrv(%x)\n", q);
544 if (llc1_debug & LLCRECV) {
545 printf("llc1_lrsrv: q=%x macinfo=%x", q, macinfo);
546 if (macinfo == NULL) {
547 printf("NULL macinfo");
548 panic("null macinfo in lrsrv");
549 /*NOTREACHED*/
550 }
551 printf("\n");
552 }
553 #endif
554
555 /*
556 * determine where message goes, then call the proper handler
557 */
558
559 while ((mp = getq(q)) != NULL) {
560 switch (DB_TYPE(mp)) {
561 case M_PROTO:
562 case M_PCPROTO:
563 prim = (union DL_primitives *)mp->b_rptr;
564 /* only some primitives ever get passed through */
565 switch (prim->dl_primitive) {
566 case DL_INFO_ACK:
567 if (macinfo->llcp_flags & LLC1_LINKED) {
568 /*
569 * we are in the midst of completing
570 * the I_LINK/I_PLINK and needed this
571 * info
572 */
573 macinfo->llcp_flags &= ~LLC1_LINKED;
574 macinfo->llcp_flags |= LLC1_AVAILABLE;
575 macinfo->llcp_maxpkt =
576 prim->info_ack.dl_max_sdu;
577 macinfo->llcp_minpkt =
578 prim->info_ack.dl_min_sdu;
579 macinfo->llcp_type =
580 prim->info_ack.dl_mac_type;
581 if (macinfo->llcp_type == DL_ETHER) {
582 macinfo->llcp_type = DL_CSMACD;
583 /*
584 * size of max header
585 * (including SNAP)
586 */
587 macinfo->llcp_maxpkt -= 8;
588 }
589 macinfo->llcp_addrlen =
590 prim->info_ack.dl_addr_length -
591 ABS(prim->info_ack.dl_sap_length);
592
593 bcopy(mp->b_rptr +
594 prim->info_ack.dl_addr_offset,
595 macinfo->llcp_macaddr,
596 macinfo->llcp_addrlen);
597 bcopy(mp->b_rptr +
598 prim->info_ack.
599 dl_brdcst_addr_offset,
600 macinfo->llcp_broadcast,
601 prim->info_ack.
602 dl_brdcst_addr_length);
603
604 if (prim->info_ack.dl_current_state ==
605 DL_UNBOUND)
606 llc1_send_bindreq(macinfo);
607 freemsg(mp);
608 /*
609 * need to put the lower stream into
610 * DLRAW mode. Currently only DL_ETHER
611 * or DL_CSMACD
612 */
613 switch (macinfo->llcp_type) {
614 case DL_ETHER:
615 case DL_CSMACD:
616 /*
617 * raw mode is optimal so ask
618 * for it * we might not get
619 * it but that's OK
620 */
621 llc1_req_raw(macinfo);
622 break;
623 default:
624 /*
625 * don't want raw mode so don't
626 * ask for it
627 */
628 break;
629 }
630 } else {
631 if (prim->info_ack.dl_current_state ==
632 DL_IDLE)
633 /* address was wrong before */
634 bcopy(mp->b_rptr +
635 prim->info_ack.dl_addr_offset,
636 macinfo->llcp_macaddr,
637 macinfo->llcp_addrlen);
638 freemsg(mp);
639 }
640 break;
641 case DL_BIND_ACK:
642 /*
643 * if we had to bind, the macaddr is wrong
644 * so get it again
645 */
646 freemsg(mp);
647 (void) llc1_req_info(q);
648 break;
649 case DL_UNITDATA_IND:
650 /* when not using raw mode we get these */
651 (void) llc1_recv(macinfo, mp);
652 break;
653 case DL_ERROR_ACK:
654 /* binding is a special case */
655 if (prim->error_ack.dl_error_primitive ==
656 DL_BIND_REQ) {
657 freemsg(mp);
658 if (macinfo->llcp_flags & LLC1_BINDING)
659 llc1_send_bindreq(macinfo);
660 } else
661 llc1_find_waiting(macinfo, mp,
662 prim->error_ack.dl_error_primitive);
663 break;
664 case DL_PHYS_ADDR_ACK:
665 llc1_find_waiting(macinfo, mp,
666 DL_PHYS_ADDR_REQ);
667 break;
668 case DL_OK_ACK:
669 if (prim->ok_ack.dl_correct_primitive ==
670 DL_BIND_REQ)
671 macinfo->llcp_flags &= ~LLC1_BINDING;
672 /* FALLTHROUGH */
673 default:
674 freemsg(mp);
675 }
676 break;
677
678 case M_IOCACK:
679 /* probably our DLIOCRAW completing */
680 iocp = (struct iocblk *)mp->b_rptr;
681 if ((macinfo->llcp_flags & LLC1_RAW_WAIT) &&
682 macinfo->llcp_iocid == iocp->ioc_id) {
683 macinfo->llcp_flags &= ~LLC1_RAW_WAIT;
684 /* we can use this form */
685 macinfo->llcp_flags |= LLC1_USING_RAW;
686 freemsg(mp);
687 break;
688 }
689 /* need to find the correct queue */
690 freemsg(mp);
691 break;
692 case M_IOCNAK:
693 iocp = (struct iocblk *)mp->b_rptr;
694 if ((macinfo->llcp_flags & LLC1_RAW_WAIT) &&
695 macinfo->llcp_iocid == iocp->ioc_id) {
696 macinfo->llcp_flags &= ~LLC1_RAW_WAIT;
697 freemsg(mp);
698 break;
699 }
700 /* need to find the correct queue */
701 freemsg(mp);
702 break;
703 case M_DATA:
704 llc1_recv(macinfo, mp);
705 break;
706 }
707 }
708 return (0);
709 }
710
711 /*
712 * llc1_uwsrv - Incoming messages are processed according to the DLPI
713 * protocol specification
714 */
715
716 static int
717 llc1_uwsrv(queue_t *q)
718 {
719 mblk_t *mp;
720 llc1_t *lld = (llc1_t *)q->q_ptr;
721 union DL_primitives *prim;
722 int err;
723
724 #ifdef LLC1_DEBUG
725 if (llc1_debug & LLCTRACE)
726 printf("llc1_wsrv(%x)\n", q);
727 #endif
728
729
730 while ((mp = getq(q)) != NULL) {
731 switch (mp->b_datap->db_type) {
732 case M_PROTO: /* Will be an DLPI message of some type */
733 case M_PCPROTO:
734 if ((err = llc1_cmds(q, mp)) != LLCE_OK) {
735 prim = (union DL_primitives *)mp->b_rptr;
736 if (err == LLCE_NOBUFFER || err == DL_SYSERR) {
737 /* quit while we're ahead */
738 lld->llc_stats->llcs_nobuffer++;
739 #ifdef LLC1_DEBUG
740 if (llc1_debug & LLCERRS)
741 printf(
742 "llc1_cmds: nonfatal err=%d\n",
743 err);
744 #endif
745 (void) putbq(q, mp);
746 return (0);
747
748 } else {
749 dlerrorack(q, mp,
750 prim->dl_primitive,
751 err, 0);
752 }
753 }
754 break;
755 case M_DATA:
756 /*
757 * retry of a previously processed
758 * UNITDATA_REQ or is a RAW message from
759 * above
760 */
761
762 mutex_enter(&lld->llc_lock);
763 putnext(lld->llc_mac_info->llcp_queue, mp);
764 mutex_exit(&lld->llc_lock);
765 freemsg(mp); /* free on success */
766 break;
767
768 /* This should never happen */
769 default:
770 #ifdef LLC1_DEBUG
771 if (llc1_debug & LLCERRS)
772 printf("llc1_wsrv: type(%x) not supported\n",
773 mp->b_datap->db_type);
774 #endif
775 freemsg(mp); /* unknown types are discarded */
776 break;
777 }
778 }
779 return (0);
780 }
781
782 /*
783 * llc1_multicast used to determine if the address is a multicast address for
784 * this user.
785 */
786 int
787 llc1_multicast(struct ether_addr *addr, llc1_t *lld)
788 {
789 int i;
790
791 if (lld->llc_mcast)
792 for (i = 0; i < lld->llc_multicnt; i++)
793 if (lld->llc_mcast[i] &&
794 lld->llc_mcast[i]->llcm_refcnt &&
795 bcmp(lld->llc_mcast[i]->llcm_addr,
796 addr->ether_addr_octet, ETHERADDRL) == 0)
797 return (1);
798 return (0);
799 }
800
801 /*
802 * llc1_ioctl handles all ioctl requests passed downstream. This routine is
803 * passed a pointer to the message block with the ioctl request in it, and a
804 * pointer to the queue so it can respond to the ioctl request with an ack.
805 */
806
807 int llc1_doreqinfo;
808
809 static void
810 llc1_ioctl(queue_t *q, mblk_t *mp)
811 {
812 struct iocblk *iocp;
813 llc1_t *lld;
814 struct linkblk *link;
815 llc_mac_info_t *macinfo;
816 mblk_t *tmp;
817 int error;
818
819 #ifdef LLC1_DEBUG
820 if (llc1_debug & LLCTRACE)
821 printf("llc1_ioctl(%x %x)\n", q, mp);
822 #endif
823 lld = (llc1_t *)q->q_ptr;
824 iocp = (struct iocblk *)mp->b_rptr;
825 switch (iocp->ioc_cmd) {
826 /* XXX need to lock the data structures */
827 case I_PLINK:
828 case I_LINK:
829 link = (struct linkblk *)mp->b_cont->b_rptr;
830 tmp = allocb(sizeof (llc_mac_info_t), BPRI_MED);
831 if (tmp == NULL) {
832 (void) miocnak(q, mp, 0, ENOSR);
833 return;
834 }
835 bzero(tmp->b_rptr, sizeof (llc_mac_info_t));
836 macinfo = (llc_mac_info_t *)tmp->b_rptr;
837 macinfo->llcp_mb = tmp;
838 macinfo->llcp_next = macinfo->llcp_prev = macinfo;
839 macinfo->llcp_queue = link->l_qbot;
840 macinfo->llcp_lindex = link->l_index;
841 /* tentative */
842 macinfo->llcp_ppa = --llc1_device_list.llc1_nextppa;
843 llc1_device_list.llc1_ndevice++;
844 macinfo->llcp_flags |= LLC1_LINKED | LLC1_DEF_PPA;
845 macinfo->llcp_lqtop = q;
846 macinfo->llcp_data = NULL;
847
848 /* need to do an info_req before an info_req or attach */
849
850 rw_enter(&llc1_device_list.llc1_rwlock, RW_WRITER);
851 llc1insque(macinfo, llc1_device_list.llc1_mac_prev);
852 macinfo->llcp_queue->q_ptr = RD(macinfo->llcp_queue)->q_ptr =
853 (caddr_t)macinfo;
854 llc1_init_kstat(macinfo);
855 rw_exit(&llc1_device_list.llc1_rwlock);
856
857 /* initiate getting the info */
858 (void) llc1_req_info(macinfo->llcp_queue);
859
860 miocack(q, mp, 0, 0);
861 return;
862
863 case I_PUNLINK:
864 case I_UNLINK:
865 link = (struct linkblk *)mp->b_cont->b_rptr;
866 rw_enter(&llc1_device_list.llc1_rwlock, RW_WRITER);
867 for (macinfo = llc1_device_list.llc1_mac_next;
868 macinfo != NULL &&
869 macinfo !=
870 (llc_mac_info_t *)&llc1_device_list.llc1_mac_next;
871 macinfo = macinfo->llcp_next) {
872 if (macinfo->llcp_lindex == link->l_index &&
873 macinfo->llcp_queue == link->l_qbot) {
874 /* found it */
875
876 ASSERT(macinfo->llcp_next);
877
878 /* remove from device list */
879 llc1_device_list.llc1_ndevice--;
880 llc1remque(macinfo);
881
882 /* remove any mcast structs */
883 if (macinfo->llcp_mcast != NULL) {
884 kmem_free(macinfo->llcp_mcast,
885 sizeof (llc_mcast_t) *
886 llc1_device_list.llc1_multisize);
887 macinfo->llcp_mcast = NULL;
888 }
889
890 /* remove any kstat counters */
891 if (macinfo->llcp_kstatp != NULL)
892 llc1_uninit_kstat(macinfo);
893 if (macinfo->llcp_mb != NULL)
894 freeb(macinfo->llcp_mb);
895
896 lld->llc_mac_info = NULL;
897
898 miocack(q, mp, 0, 0);
899
900 /* finish any necessary setup */
901 if (llc1_device_list.llc1_ndevice == 0)
902 llc1_device_list.llc1_nextppa = 0;
903
904 rw_exit(&llc1_device_list.llc1_rwlock);
905 return;
906 }
907 }
908 rw_exit(&llc1_device_list.llc1_rwlock);
909 /*
910 * what should really be done here -- force errors on all
911 * streams?
912 */
913 miocnak(q, mp, 0, EINVAL);
914 return;
915
916 case L_SETPPA:
917 error = miocpullup(mp, sizeof (struct ll_snioc));
918 if (error != 0) {
919 miocnak(q, mp, 0, error);
920 return;
921 }
922
923 if (llc1_setppa((struct ll_snioc *)mp->b_cont->b_rptr) >= 0) {
924 miocack(q, mp, 0, 0);
925 return;
926 }
927 miocnak(q, mp, 0, EINVAL);
928 return;
929
930 case L_GETPPA:
931 if (mp->b_cont == NULL) {
932 mp->b_cont = allocb(sizeof (struct ll_snioc), BPRI_MED);
933 if (mp->b_cont == NULL) {
934 miocnak(q, mp, 0, ENOSR);
935 return;
936 }
937 mp->b_cont->b_wptr =
938 mp->b_cont->b_rptr + sizeof (struct ll_snioc);
939 } else {
940 error = miocpullup(mp, sizeof (struct ll_snioc));
941 if (error != 0) {
942 miocnak(q, mp, 0, error);
943 return;
944 }
945 }
946
947 lld = (llc1_t *)q->q_ptr;
948 if (llc1_getppa(lld->llc_mac_info,
949 (struct ll_snioc *)mp->b_cont->b_rptr) >= 0)
950 miocack(q, mp, 0, 0);
951 else
952 miocnak(q, mp, 0, EINVAL);
953 return;
954 default:
955 miocnak(q, mp, 0, EINVAL);
956 }
957 }
958
959 /*
960 * llc1_setppa(snioc) this function sets the real PPA number for a previously
961 * I_LINKED stream. Be careful to select the macinfo struct associated
962 * with our llc struct, to avoid erroneous references.
963 */
964
965 static int
966 llc1_setppa(struct ll_snioc *snioc)
967 {
968 llc_mac_info_t *macinfo;
969
970 for (macinfo = llc1_device_list.llc1_mac_next;
971 macinfo != (llc_mac_info_t *)&llc1_device_list.llc1_mac_next;
972 macinfo = macinfo->llcp_next)
973 if (macinfo->llcp_lindex == snioc->lli_index &&
974 (macinfo->llcp_flags & LLC1_DEF_PPA)) {
975 macinfo->llcp_flags &= ~LLC1_DEF_PPA;
976 macinfo->llcp_ppa = snioc->lli_ppa;
977 return (0);
978 }
979 return (-1);
980 }
981
982 /*
983 * llc1_getppa(macinfo, snioc) returns the PPA for this stream
984 */
985 static int
986 llc1_getppa(llc_mac_info_t *macinfo, struct ll_snioc *snioc)
987 {
988 if (macinfo == NULL)
989 return (-1);
990 snioc->lli_ppa = macinfo->llcp_ppa;
991 snioc->lli_index = macinfo->llcp_lindex;
992 return (0);
993 }
994
995 /*
996 * llc1_cmds - process the DL commands as defined in dlpi.h
997 */
998 static int
999 llc1_cmds(queue_t *q, mblk_t *mp)
1000 {
1001 union DL_primitives *dlp;
1002 llc1_t *llc = (llc1_t *)q->q_ptr;
1003 int result = 0;
1004 llc_mac_info_t *macinfo = llc->llc_mac_info;
1005
1006 dlp = (union DL_primitives *)mp->b_rptr;
1007 #ifdef LLC1_DEBUG
1008 if (llc1_debug & LLCTRACE)
1009 printf("llc1_cmds(%x, %x):dlp=%x, dlp->dl_primitive=%d\n",
1010 q, mp, dlp, dlp->dl_primitive);
1011 #endif
1012 mutex_enter(&llc->llc_lock);
1013 rw_enter(&llc1_device_list.llc1_rwlock, RW_READER);
1014
1015 switch (dlp->dl_primitive) {
1016 case DL_BIND_REQ:
1017 result = llc1_bind(q, mp);
1018 break;
1019
1020 case DL_UNBIND_REQ:
1021 result = llc1_unbind(q, mp);
1022 break;
1023
1024 case DL_SUBS_BIND_REQ:
1025 result = llc1_subs_bind(q, mp);
1026 break;
1027
1028 case DL_SUBS_UNBIND_REQ:
1029 result = llc1_subs_unbind();
1030 break;
1031
1032 case DL_UNITDATA_REQ:
1033 result = llc1_unitdata(q, mp);
1034 break;
1035
1036 case DL_INFO_REQ:
1037 result = llc1_inforeq(q, mp);
1038 break;
1039
1040 case DL_ATTACH_REQ:
1041 result = llc1attach(q, mp);
1042 break;
1043
1044 case DL_DETACH_REQ:
1045 result = llc1unattach(q, mp);
1046 break;
1047
1048 case DL_ENABMULTI_REQ:
1049 result = llc1_enable_multi(q, mp);
1050 break;
1051
1052 case DL_DISABMULTI_REQ:
1053 result = llc1_disable_multi(q, mp);
1054 break;
1055
1056 case DL_XID_REQ:
1057 result = llc1_xid_req_res(q, mp, 0);
1058 break;
1059
1060 case DL_XID_RES:
1061 result = llc1_xid_req_res(q, mp, 1);
1062 break;
1063
1064 case DL_TEST_REQ:
1065 result = llc1_test_req_res(q, mp, 0);
1066 break;
1067
1068 case DL_TEST_RES:
1069 result = llc1_test_req_res(q, mp, 1);
1070 break;
1071
1072 case DL_SET_PHYS_ADDR_REQ:
1073 result = DL_NOTSUPPORTED;
1074 break;
1075
1076 case DL_PHYS_ADDR_REQ:
1077 if (llc->llc_state != DL_UNATTACHED && macinfo) {
1078 llc->llc_waiting_for = dlp->dl_primitive;
1079 putnext(WR(macinfo->llcp_queue), mp);
1080 result = LLCE_OK;
1081 } else {
1082 result = DL_OUTSTATE;
1083 }
1084 break;
1085
1086 case DL_PROMISCON_REQ:
1087 case DL_PROMISCOFF_REQ:
1088 result = DL_NOTSUPPORTED;
1089 break;
1090
1091 default:
1092 #ifdef LLC1_DEBUG
1093 if (llc1_debug & LLCERRS)
1094 printf("llc1_cmds: Received unknown primitive: %d\n",
1095 dlp->dl_primitive);
1096 #endif
1097 result = DL_BADPRIM;
1098 break;
1099 }
1100 rw_exit(&llc1_device_list.llc1_rwlock);
1101 mutex_exit(&llc->llc_lock);
1102 return (result);
1103 }
1104
1105 /*
1106 * llc1_bind - determine if a SAP is already allocated and whether it is
1107 * legal to do the bind at this time
1108 */
1109 static int
1110 llc1_bind(queue_t *q, mblk_t *mp)
1111 {
1112 int sap;
1113 dl_bind_req_t *dlp;
1114 llc1_t *lld = (llc1_t *)q->q_ptr;
1115
1116 ASSERT(lld);
1117
1118 #ifdef LLC1_DEBUG
1119 if (llc1_debug & LLCTRACE)
1120 printf("llc1_bind(%x %x)\n", q, mp);
1121 #endif
1122
1123 dlp = (dl_bind_req_t *)mp->b_rptr;
1124 sap = dlp->dl_sap;
1125
1126 #ifdef LLC1_DEBUG
1127 if (llc1_debug & LLCPROT)
1128 printf("llc1_bind: lsap=%x\n", sap);
1129 #endif
1130
1131 if (lld->llc_mac_info == NULL)
1132 return (DL_OUTSTATE);
1133
1134 if (lld->llc_qptr && lld->llc_state != DL_UNBOUND) {
1135 #ifdef LLC1_DEBUG
1136 if (llc1_debug & LLCERRS)
1137 printf("llc1_bind: stream bound/not attached (%d)\n",
1138 lld->llc_state);
1139 #endif
1140 return (DL_OUTSTATE);
1141 }
1142
1143 if (dlp->dl_service_mode != DL_CLDLS || dlp->dl_max_conind != 0) {
1144 return (DL_UNSUPPORTED);
1145 }
1146 /*
1147 * prohibit group saps. An exception is the broadcast sap which is,
1148 * unfortunately, used by SUNSelect to indicate Novell Netware in
1149 * 802.3 mode. Really should use a very non-802.2 SAP like 0xFFFF
1150 * or -2.
1151 */
1152
1153 if (sap == 0 || (sap <= 0xFF && (sap & 1 && sap != 0xFF)) ||
1154 sap > 0xFFFF) {
1155 return (DL_BADSAP);
1156 }
1157 lld->llc_state = DL_BIND_PENDING;
1158
1159 /* if we fall through, then the SAP is legal */
1160 if (sap == 0xFF) {
1161 if (lld->llc_mac_info->llcp_type == DL_CSMACD)
1162 sap = LLC_NOVELL_SAP;
1163 else
1164 return (DL_BADSAP);
1165 }
1166 lld->llc_sap = sap;
1167
1168 if (sap > 0xFF) {
1169 ushort_t snapsap = htons(sap);
1170 /* this is SNAP, so set things up */
1171 lld->llc_snap[3] = ((uchar_t *)&snapsap)[0];
1172 lld->llc_snap[4] = ((uchar_t *)&snapsap)[1];
1173 /* mark as SNAP but allow OID to be added later */
1174 lld->llc_flags |= LLC_SNAP;
1175 lld->llc_sap = LLC_SNAP_SAP;
1176 }
1177
1178 #ifdef LLC1_DEBUG
1179 if (llc1_debug & LLCPROT)
1180 printf("llc1_bind: ok - type = %d\n", lld->llc_type);
1181 #endif
1182
1183 if (dlp->dl_xidtest_flg & DL_AUTO_XID)
1184 lld->llc_flags |= LLC1_AUTO_XID;
1185 if (dlp->dl_xidtest_flg & DL_AUTO_TEST)
1186 lld->llc_flags |= LLC1_AUTO_TEST;
1187
1188 /* ACK the BIND, if possible */
1189
1190 dlbindack(q, mp, sap, lld->llc_mac_info->llcp_macaddr, 6, 0, 0);
1191
1192 lld->llc_state = DL_IDLE; /* bound and ready */
1193
1194 return (LLCE_OK);
1195 }
1196
1197 /*
1198 * llc1_unbind - perform an unbind of an LSAP or ether type on the stream.
1199 * The stream is still open and can be re-bound.
1200 */
1201 static int
1202 llc1_unbind(queue_t *q, mblk_t *mp)
1203 {
1204 llc1_t *lld;
1205
1206 #ifdef LLC1_DEBUG
1207 if (llc1_debug & LLCTRACE)
1208 printf("llc1_unbind(%x %x)\n", q, mp);
1209 #endif
1210 lld = (llc1_t *)q->q_ptr;
1211
1212 if (lld->llc_mac_info == NULL)
1213 return (DL_OUTSTATE);
1214
1215 if (lld->llc_state != DL_IDLE) {
1216 #ifdef LLC1_DEBUG
1217 if (llc1_debug & LLCERRS)
1218 printf("llc1_unbind: wrong state (%d)\n",
1219 lld->llc_state);
1220 #endif
1221 return (DL_OUTSTATE);
1222 }
1223 lld->llc_state = DL_UNBIND_PENDING;
1224 lld->llc_flags &= ~(LLC_SNAP|LLC_SNAP_OID); /* just in case */
1225 dlokack(q, mp, DL_UNBIND_REQ);
1226 lld->llc_state = DL_UNBOUND;
1227 return (LLCE_OK);
1228 }
1229
1230 /*
1231 * llc1_inforeq - generate the response to an info request
1232 */
1233 static int
1234 llc1_inforeq(queue_t *q, mblk_t *mp)
1235 {
1236 llc1_t *lld;
1237 mblk_t *nmp;
1238 dl_info_ack_t *dlp;
1239 int bufsize;
1240
1241 #ifdef LLC1_DEBUG
1242 if (llc1_debug & LLCTRACE)
1243 printf("llc1_inforeq(%x %x)\n", q, mp);
1244 #endif
1245 lld = (llc1_t *)q->q_ptr;
1246 ASSERT(lld);
1247 if (lld->llc_mac_info == NULL)
1248 bufsize = sizeof (dl_info_ack_t) + ETHERADDRL;
1249 else
1250 bufsize = sizeof (dl_info_ack_t) +
1251 2 * lld->llc_mac_info->llcp_addrlen + 2;
1252
1253 nmp = mexchange(q, mp, bufsize, M_PCPROTO, DL_INFO_ACK);
1254
1255 if (nmp) {
1256 nmp->b_wptr = nmp->b_rptr + sizeof (dl_info_ack_t);
1257 dlp = (dl_info_ack_t *)nmp->b_rptr;
1258 bzero(dlp, DL_INFO_ACK_SIZE);
1259 dlp->dl_primitive = DL_INFO_ACK;
1260 if (lld->llc_mac_info)
1261 dlp->dl_max_sdu = lld->llc_mac_info->llcp_maxpkt;
1262 dlp->dl_min_sdu = 0;
1263 dlp->dl_mac_type = lld->llc_type;
1264 dlp->dl_service_mode = DL_CLDLS;
1265 dlp->dl_current_state = lld->llc_state;
1266 dlp->dl_provider_style =
1267 (lld->llc_style == 0) ? lld->llc_style : DL_STYLE2;
1268
1269 /* now append physical address */
1270 if (lld->llc_mac_info) {
1271 dlp->dl_addr_length = lld->llc_mac_info->llcp_addrlen;
1272 dlp->dl_addr_offset = DL_INFO_ACK_SIZE;
1273 nmp->b_wptr += dlp->dl_addr_length + 1;
1274 bcopy(lld->llc_mac_info->llcp_macaddr,
1275 ((caddr_t)dlp) + dlp->dl_addr_offset,
1276 lld->llc_mac_info->llcp_addrlen);
1277 if (lld->llc_state == DL_IDLE) {
1278 dlp->dl_sap_length = -1; /* 1 byte on end */
1279 *(((caddr_t)dlp) + dlp->dl_addr_offset +
1280 dlp->dl_addr_length) = lld->llc_sap;
1281 dlp->dl_addr_length += 1;
1282 }
1283 /* and the broadcast address */
1284 dlp->dl_brdcst_addr_length =
1285 lld->llc_mac_info->llcp_addrlen;
1286 dlp->dl_brdcst_addr_offset =
1287 dlp->dl_addr_offset + dlp->dl_addr_length;
1288 nmp->b_wptr += dlp->dl_brdcst_addr_length;
1289 bcopy(lld->llc_mac_info->llcp_broadcast,
1290 ((caddr_t)dlp) + dlp->dl_brdcst_addr_offset,
1291 lld->llc_mac_info->llcp_addrlen);
1292 } else {
1293 dlp->dl_addr_length = 0; /* not attached yet */
1294 dlp->dl_addr_offset = NULL;
1295 dlp->dl_sap_length = 0; /* 1 bytes on end */
1296 }
1297 dlp->dl_version = DL_VERSION_2;
1298 qreply(q, nmp);
1299 }
1300 return (LLCE_OK);
1301 }
1302
1303 /*
1304 * llc1_unitdata
1305 * send a datagram. Destination address/lsap is in M_PROTO
1306 * message (first mblock), data is in remainder of message.
1307 *
1308 * NOTE: We are reusing the DL_unitdata_req mblock; if llc header gets any
1309 * bigger, recheck to make sure it still fits! We assume that we have a
1310 * 64-byte dblock for this, since a DL_unitdata_req is 20 bytes and the next
1311 * larger dblock size is 64.
1312 */
1313 static int
1314 llc1_unitdata(queue_t *q, mblk_t *mp)
1315 {
1316 llc1_t *lld = (llc1_t *)q->q_ptr;
1317 dl_unitdata_req_t *dlp = (dl_unitdata_req_t *)mp->b_rptr;
1318 struct ether_header *hdr;
1319 struct llcaddr *llcp;
1320 mblk_t *nmp;
1321 long msglen;
1322 struct llchdr *llchdr;
1323 llc_mac_info_t *macinfo;
1324 int xmt_type = 0;
1325
1326 #ifdef LLC1_DEBUG
1327 if (llc1_debug & LLCTRACE)
1328 printf("llc1_unitdata(%x %x)\n", q, mp);
1329 #endif
1330
1331 if ((macinfo = lld->llc_mac_info) == NULL)
1332 return (DL_OUTSTATE);
1333
1334 if (lld->llc_state != DL_IDLE) {
1335 #ifdef LLC1_DEBUG
1336 if (llc1_debug & LLCERRS)
1337 printf("llc1_unitdata: wrong state (%d)\n",
1338 lld->llc_state);
1339 #endif
1340 return (DL_OUTSTATE);
1341 }
1342
1343 /* need the destination address in all cases */
1344 llcp = (struct llcaddr *)((caddr_t)dlp + dlp->dl_dest_addr_offset);
1345
1346 if (macinfo->llcp_flags & LLC1_USING_RAW) {
1347 /*
1348 * make a valid header for transmission
1349 */
1350
1351 /* need a buffer big enough for the headers */
1352 nmp = allocb(macinfo->llcp_addrlen * 2 + 2 + 8, BPRI_MED);
1353 hdr = (struct ether_header *)nmp->b_rptr;
1354 msglen = msgdsize(mp);
1355
1356 /* fill in type dependent fields */
1357 switch (lld->llc_type) {
1358 case DL_CSMACD: /* 802.3 CSMA/CD */
1359 nmp->b_wptr = nmp->b_rptr + LLC1_CSMACD_HDR_SIZE;
1360 llchdr = (struct llchdr *)nmp->b_wptr;
1361 bcopy(llcp->llca_addr,
1362 hdr->ether_dhost.ether_addr_octet,
1363 ETHERADDRL);
1364 bcopy(macinfo->llcp_macaddr,
1365 hdr->ether_shost.ether_addr_octet,
1366 ETHERADDRL);
1367
1368 if (lld->llc_sap != LLC_NOVELL_SAP) {
1369 /* set length with llc header size */
1370 hdr->ether_type = ntohs(msglen +
1371 sizeof (struct llchdr));
1372
1373 /* need an LLC header, otherwise is Novell */
1374 /* bound sap is always source */
1375 llchdr->llc_ssap = lld->llc_sap;
1376
1377 /* destination sap */
1378 llchdr->llc_dsap = llcp->llca_sap;
1379
1380 /* always Unnumbered Information */
1381 llchdr->llc_ctl = LLC_UI;
1382
1383 nmp->b_wptr += sizeof (struct llchdr);
1384
1385 if (lld->llc_flags & LLC_SNAP) {
1386 bcopy(lld->llc_snap, nmp->b_wptr, 5);
1387 llchdr->llc_dsap = LLC_SNAP_SAP;
1388 nmp->b_wptr += 5;
1389 }
1390 } else {
1391 /* set length without llc header size */
1392 hdr->ether_type = ntohs(msglen);
1393
1394 /* we don't do anything else for Netware */
1395 }
1396
1397 if (ismulticast(hdr->ether_dhost.ether_addr_octet)) {
1398 if (bcmp(hdr->ether_dhost.ether_addr_octet,
1399 macinfo->llcp_broadcast, ETHERADDRL) == 0)
1400 xmt_type = 2;
1401 else
1402 xmt_type = 1;
1403 }
1404
1405 break;
1406
1407 default: /* either RAW or unknown, send as is */
1408 break;
1409 }
1410 DB_TYPE(nmp) = M_DATA; /* ether/llc header is data */
1411 nmp->b_cont = mp->b_cont; /* use the data given */
1412 freeb(mp);
1413 mp = nmp;
1414 } else {
1415 /* need to format a DL_UNITDATA_REQ with LLC1 header inserted */
1416 nmp = allocb(sizeof (struct llchdr)+sizeof (struct snaphdr),
1417 BPRI_MED);
1418 if (nmp == NULL)
1419 return (DL_UNDELIVERABLE);
1420 llchdr = (struct llchdr *)(nmp->b_rptr);
1421 nmp->b_wptr += sizeof (struct llchdr);
1422 llchdr->llc_dsap = llcp->llca_sap;
1423 llchdr->llc_ssap = lld->llc_sap;
1424 llchdr->llc_ctl = LLC_UI;
1425
1426 /*
1427 * if we are using SNAP, insert the header here
1428 */
1429 if (lld->llc_flags & LLC_SNAP) {
1430 bcopy(lld->llc_snap, nmp->b_wptr, 5);
1431 nmp->b_wptr += 5;
1432 }
1433 nmp->b_cont = mp->b_cont;
1434 mp->b_cont = nmp;
1435 nmp = mp;
1436 if (ismulticast(llcp->llca_addr)) {
1437 if (bcmp(llcp->llca_addr,
1438 macinfo->llcp_broadcast, ETHERADDRL) == 0)
1439 xmt_type = 2;
1440 else
1441 xmt_type = 1;
1442 }
1443 }
1444 if (canput(macinfo->llcp_queue)) {
1445 lld->llc_stats->llcs_bytexmt += msgdsize(mp);
1446 lld->llc_stats->llcs_pktxmt++;
1447 switch (xmt_type) {
1448 case 1:
1449 macinfo->llcp_stats.llcs_multixmt++;
1450 break;
1451 case 2:
1452 macinfo->llcp_stats.llcs_brdcstxmt++;
1453 break;
1454 }
1455
1456 putnext(macinfo->llcp_queue, mp);
1457 return (LLCE_OK); /* this is almost correct, the result */
1458 } else {
1459 lld->llc_stats->llcs_nobuffer++;
1460 }
1461 if (nmp != NULL)
1462 freemsg(nmp); /* free on failure */
1463 return (LLCE_OK);
1464 }
1465
1466 /*
1467 * llc1_recv(macinfo, mp)
1468 * called with an ethernet packet in a mblock; must decide
1469 * whether packet is for us and which streams to queue it to. This routine is
1470 * called with locally originated packets for loopback.
1471 */
1472 static void
1473 llc1_recv(llc_mac_info_t *macinfo, mblk_t *mp)
1474 {
1475 struct ether_addr *addr;
1476 llc1_t *lld;
1477 mblk_t *nmp, *udmp;
1478 int i, nmcast = 0, statcnt_normal = 0, statcnt_brdcst = 0;
1479 int valid, msgsap;
1480 struct llchdr *llchdr;
1481
1482 #ifdef LLC1_DEBUG
1483 if (llc1_debug & LLCTRACE)
1484 printf("llc1_recv(%x, %x)\n", mp, macinfo);
1485 #endif
1486
1487 if (DB_TYPE(mp) == M_PROTO) {
1488 dl_unitdata_ind_t *udata;
1489
1490 /* check to see if really LLC1 XXX */
1491 /* also need to make sure to keep address info */
1492 nmp = mp;
1493 udata = (dl_unitdata_ind_t *)(nmp->b_rptr);
1494 addr = (struct ether_addr *)(nmp->b_rptr +
1495 udata->dl_dest_addr_offset);
1496 llchdr = (struct llchdr *)(nmp->b_cont->b_rptr);
1497 if (macinfo->llcp_type == DL_CSMACD) {
1498 i = ((struct llcsaddr *)addr)->llca_ssap;
1499 if (i < 60) {
1500 valid = adjmsg(mp->b_cont, i - msgdsize(mp));
1501 }
1502 }
1503 } else {
1504 struct ether_header *hdr;
1505
1506 /* Note that raw mode currently assumes Ethernet */
1507 nmp = NULL;
1508 hdr = (struct ether_header *)mp->b_rptr;
1509 addr = &hdr->ether_dhost;
1510 llchdr = (struct llchdr *)(mp->b_rptr +
1511 sizeof (struct ether_header));
1512 i = (ushort_t)ntohs(hdr->ether_type);
1513 if (i < 60) {
1514 (void) adjmsg(mp, i + sizeof (struct ether_header) -
1515 msgdsize(mp));
1516 }
1517 }
1518 udmp = NULL;
1519
1520 msgsap = llchdr->llc_dsap;
1521
1522 #ifdef LLC1_DEBUG
1523 if (llc1_debug & LLCRECV) {
1524 printf("llc1_recv: machdr=<%s>\n", ether_sprintf(addr));
1525 }
1526 #endif
1527
1528 if (llc1_broadcast(addr, macinfo)) {
1529 valid = 2; /* 2 means valid but multicast */
1530 statcnt_brdcst = 1;
1531 } else {
1532 valid = llc1_local(addr, macinfo);
1533 statcnt_normal = msgdsize(mp);
1534 }
1535
1536 /*
1537 * Note that the NULL SAP is a special case. It is associated with
1538 * the MAC layer and not the LLC layer so should be handled
1539 * independently of any STREAM.
1540 */
1541 if (msgsap == LLC_NULL_SAP) {
1542 /* only XID and TEST ever processed, UI is dropped */
1543 if ((llchdr->llc_ctl & ~LLC_P) == LLC_XID)
1544 mp = llc1_xid_reply(macinfo, mp, 0);
1545 else if ((llchdr->llc_ctl & ~LLC_P) == LLC_TEST)
1546 mp = llc1_test_reply(macinfo, mp, 0);
1547 } else
1548 for (lld = llc1_device_list.llc1_str_next;
1549 lld != (llc1_t *)&llc1_device_list.llc1_str_next;
1550 lld = lld->llc_next) {
1551
1552 /*
1553 * is this a potentially usable SAP on the
1554 * right MAC layer?
1555 */
1556 if (lld->llc_qptr == NULL ||
1557 lld->llc_state != DL_IDLE ||
1558 lld->llc_mac_info != macinfo) {
1559 continue;
1560 }
1561 #ifdef LLC1_DEBUG
1562 if (llc1_debug & LLCRECV)
1563 printf(
1564 "llc1_recv: type=%d, sap=%x, pkt-dsap=%x\n",
1565 lld->llc_type, lld->llc_sap,
1566 msgsap);
1567 #endif
1568 if (!valid && ismulticast(addr->ether_addr_octet) &&
1569 lld->llc_multicnt > 0 &&
1570 llc1_multicast(addr, lld)) {
1571 valid |= 4;
1572 } else if (lld->llc_flags & LLC_PROM)
1573 /* promiscuous mode */
1574 valid = 1;
1575
1576 if ((lld->llc_flags & LLC_PROM) ||
1577 /* promiscuous streams */
1578 (valid &&
1579 (lld->llc_sap == msgsap ||
1580 msgsap == LLC_GLOBAL_SAP))) {
1581 /* sap matches */
1582 if (msgsap == LLC_SNAP_SAP &&
1583 (lld->llc_flags & (LLC_SNAP|LLC_PROM)) ==
1584 LLC_SNAP) {
1585 if (!llc1_snap_match(lld,
1586 (struct snaphdr *)(llchdr+1)))
1587 continue;
1588 }
1589 if (!canputnext(RD(lld->llc_qptr))) {
1590 #ifdef LLC1_DEBUG
1591 if (llc1_debug & LLCRECV)
1592 printf(
1593 "llc1_recv: canput failed\n");
1594 #endif
1595 lld->llc_stats->llcs_blocked++;
1596 continue;
1597 }
1598 /* check for Novell special handling */
1599 if (msgsap == LLC_GLOBAL_SAP &&
1600 lld->llc_sap == LLC_NOVELL_SAP &&
1601 llchdr->llc_ssap == LLC_GLOBAL_SAP) {
1602
1603 /* A Novell packet */
1604 nmp = llc1_form_udata(lld, macinfo, mp);
1605 continue;
1606 }
1607 switch (llchdr->llc_ctl) {
1608 case LLC_UI:
1609 /*
1610 * this is an Unnumbered Information
1611 * packet so form a DL_UNITDATA_IND and
1612 * send to user
1613 */
1614 nmp = llc1_form_udata(lld, macinfo, mp);
1615 break;
1616
1617 case LLC_XID:
1618 case LLC_XID | LLC_P:
1619 /*
1620 * this is either an XID request or
1621 * response. We either handle directly
1622 * (if user hasn't requested to handle
1623 * itself) or send to user. We also
1624 * must check if a response if user
1625 * handled so that we can send correct
1626 * message form
1627 */
1628 if (lld->llc_flags & LLC1_AUTO_XID) {
1629 nmp = llc1_xid_reply(macinfo,
1630 mp, lld->llc_sap);
1631 } else {
1632 /*
1633 * hand to the user for
1634 * handling. if this is a
1635 * "request", generate a
1636 * DL_XID_IND. If it is a
1637 * "response" to one of our
1638 * requests, generate a
1639 * DL_XID_CON.
1640 */
1641 nmp = llc1_xid_ind_con(lld,
1642 macinfo, mp);
1643 }
1644 macinfo->llcp_stats.llcs_xidrcv++;
1645 break;
1646
1647 case LLC_TEST:
1648 case LLC_TEST | LLC_P:
1649 /*
1650 * this is either a TEST request or
1651 * response. We either handle
1652 * directly (if user hasn't
1653 * requested to handle itself)
1654 * or send to user. We also
1655 * must check if a response if
1656 * user handled so that we can
1657 * send correct message form
1658 */
1659 if (lld->llc_flags & LLC1_AUTO_TEST) {
1660 nmp = llc1_test_reply(macinfo,
1661 mp, lld->llc_sap);
1662 } else {
1663 /*
1664 * hand to the user for
1665 * handling. if this is
1666 * a "request",
1667 * generate a
1668 * DL_TEST_IND. If it
1669 * is a "response" to
1670 * one of our requests,
1671 * generate a
1672 * DL_TEST_CON.
1673 */
1674 nmp = llc1_test_ind_con(lld,
1675 macinfo, mp);
1676 }
1677 macinfo->llcp_stats.llcs_testrcv++;
1678 break;
1679 default:
1680 nmp = mp;
1681 break;
1682 }
1683 mp = nmp;
1684 }
1685 }
1686 if (mp != NULL)
1687 freemsg(mp);
1688 if (udmp != NULL)
1689 freeb(udmp);
1690 if (nmcast > 0)
1691 macinfo->llcp_stats.llcs_multircv++;
1692 if (statcnt_brdcst) {
1693 macinfo->llcp_stats.llcs_brdcstrcv++;
1694 }
1695 if (statcnt_normal) {
1696 macinfo->llcp_stats.llcs_bytercv += statcnt_normal;
1697 macinfo->llcp_stats.llcs_pktrcv++;
1698 }
1699 }
1700
1701 /*
1702 * llc1_local - check to see if the message is addressed to this system by
1703 * comparing with the board's address.
1704 */
1705 static int
1706 llc1_local(struct ether_addr *addr, llc_mac_info_t *macinfo)
1707 {
1708 return (bcmp(addr->ether_addr_octet, macinfo->llcp_macaddr,
1709 macinfo->llcp_addrlen) == 0);
1710 }
1711
1712 /*
1713 * llc1_broadcast - check to see if a broadcast address is the destination of
1714 * this received packet
1715 */
1716 static int
1717 llc1_broadcast(struct ether_addr *addr, llc_mac_info_t *macinfo)
1718 {
1719 return (bcmp(addr->ether_addr_octet, macinfo->llcp_broadcast,
1720 macinfo->llcp_addrlen) == 0);
1721 }
1722
1723 /*
1724 * llc1attach(q, mp) DLPI DL_ATTACH_REQ this attaches the stream to a PPA
1725 */
1726 static int
1727 llc1attach(queue_t *q, mblk_t *mp)
1728 {
1729 dl_attach_req_t *at;
1730 llc_mac_info_t *mac;
1731 llc1_t *llc = (llc1_t *)q->q_ptr;
1732
1733 at = (dl_attach_req_t *)mp->b_rptr;
1734
1735 if (llc->llc_state != DL_UNATTACHED) {
1736 return (DL_OUTSTATE);
1737 }
1738 llc->llc_state = DL_ATTACH_PENDING;
1739
1740 if (rw_tryupgrade(&llc1_device_list.llc1_rwlock) == 0) {
1741 /*
1742 * someone else has a lock held. To avoid deadlock,
1743 * release the READER lock and block on a WRITER
1744 * lock. This will let things continue safely.
1745 */
1746 rw_exit(&llc1_device_list.llc1_rwlock);
1747 rw_enter(&llc1_device_list.llc1_rwlock, RW_WRITER);
1748 }
1749
1750 for (mac = llc1_device_list.llc1_mac_next;
1751 mac != (llc_mac_info_t *)(&llc1_device_list.llc1_mac_next);
1752 mac = mac->llcp_next) {
1753 ASSERT(mac);
1754 if (mac->llcp_ppa == at->dl_ppa && mac->llcp_lqtop == q) {
1755 /*
1756 * We may have found the correct PPA
1757 * check to see if linking has finished.
1758 * Use explicit flag checks for incorrect
1759 * state, and use negative values for "tenative"
1760 * llcp_ppas, to avoid erroneous attaches.
1761 */
1762 if (mac->llcp_flags &
1763 (LLC1_LINKED|LLC1_DEF_PPA)) {
1764 return (DL_INITFAILED);
1765 } else if (!(mac->llcp_flags & LLC1_AVAILABLE)) {
1766 return (DL_BADPPA);
1767 }
1768
1769 /* this links us to the PPA */
1770 mac->llcp_nstreams++;
1771 llc->llc_mac_info = mac;
1772
1773 llc->llc_state = DL_UNBOUND; /* now ready for action */
1774 llc->llc_stats = &mac->llcp_stats;
1775 dlokack(q, mp, DL_ATTACH_REQ);
1776
1777 return (LLCE_OK);
1778 }
1779 }
1780 llc->llc_state = DL_UNATTACHED;
1781 return (DL_BADPPA);
1782 }
1783
1784 /*
1785 * llc1unattach(q, mp) DLPI DL_DETACH_REQ detaches the mac layer from the
1786 * stream
1787 */
1788 static int
1789 llc1unattach(queue_t *q, mblk_t *mp)
1790 {
1791 llc1_t *llc = (llc1_t *)q->q_ptr;
1792 int state;
1793 int i;
1794
1795 state = llc->llc_state;
1796 if (state != DL_UNBOUND)
1797 return (DL_OUTSTATE);
1798
1799 /* can now detach from the PPA */
1800 llc->llc_state = DL_DETACH_PENDING;
1801
1802 if (rw_tryupgrade(&llc1_device_list.llc1_rwlock) == 0) {
1803 /*
1804 * someone else has a lock held. To avoid deadlock,
1805 * release the READER lock and block on a WRITER
1806 * lock. This will let things continue safely.
1807 */
1808 rw_exit(&llc1_device_list.llc1_rwlock);
1809 rw_enter(&llc1_device_list.llc1_rwlock, RW_WRITER);
1810 }
1811
1812 if (llc->llc_mcast) {
1813 for (i = 0; i < llc1_device_list.llc1_multisize; i++) {
1814 llc_mcast_t *mcast;
1815
1816 if ((mcast = llc->llc_mcast[i]) != NULL) {
1817 /* disable from stream and possibly lower */
1818 llc1_send_disable_multi(llc->llc_mac_info,
1819 mcast);
1820 llc->llc_mcast[i] = NULL;
1821 }
1822 }
1823 kmem_free(llc->llc_mcast,
1824 sizeof (llc_mcast_t *) * llc->llc_multicnt);
1825 llc->llc_mcast = NULL;
1826 }
1827 if (llc->llc_mac_info)
1828 llc->llc_mac_info->llcp_nstreams--;
1829 llc->llc_sap = 0;
1830 llc->llc_state = DL_UNATTACHED;
1831 if (mp) {
1832 dlokack(q, mp, DL_DETACH_REQ);
1833 }
1834 return (LLCE_OK);
1835 }
1836
1837 /*
1838 * llc1_enable_multi enables multicast address on the stream if the mac layer
1839 * isn't enabled for this address, enable at that level as well.
1840 */
1841 static int
1842 llc1_enable_multi(queue_t *q, mblk_t *mp)
1843 {
1844 llc1_t *llc;
1845 llc_mac_info_t *macinfo;
1846 struct ether_addr *maddr;
1847 dl_enabmulti_req_t *multi;
1848 llc_mcast_t *mcast;
1849 int status = DL_BADADDR;
1850 int i;
1851
1852 #if defined(LLC1_DEBUG)
1853 if (llc1_debug & LLCPROT) {
1854 printf("llc1_enable_multi(%x, %x)\n", q, mp);
1855 }
1856 #endif
1857
1858 llc = (llc1_t *)q->q_ptr;
1859
1860 if (llc->llc_state == DL_UNATTACHED)
1861 return (DL_OUTSTATE);
1862
1863 macinfo = llc->llc_mac_info;
1864 multi = (dl_enabmulti_req_t *)mp->b_rptr;
1865 maddr = (struct ether_addr *)(mp->b_rptr + multi->dl_addr_offset);
1866
1867 /*
1868 * check to see if this multicast address is valid if it is, then
1869 * check to see if it is already in the per stream table and the per
1870 * device table if it is already in the per stream table, if it isn't
1871 * in the per device, add it. If it is, just set a pointer. If it
1872 * isn't, allocate what's necessary.
1873 */
1874
1875 if (MBLKL(mp) >= sizeof (dl_enabmulti_req_t) &&
1876 MBLKIN(mp, multi->dl_addr_offset, multi->dl_addr_length) &&
1877 multi->dl_addr_length == macinfo->llcp_addrlen &&
1878 ismulticast(maddr->ether_addr_octet)) {
1879 /* request appears to be valid */
1880 /* does this address appear in current table? */
1881 if (llc->llc_mcast == NULL) {
1882 /* no mcast addresses -- allocate table */
1883 llc->llc_mcast =
1884 GETSTRUCT(llc_mcast_t *,
1885 llc1_device_list.llc1_multisize);
1886 if (llc->llc_mcast == NULL)
1887 return (DL_SYSERR);
1888 llc->llc_multicnt = llc1_device_list.llc1_multisize;
1889 } else {
1890 for (i = 0; i < llc1_device_list.llc1_multisize; i++) {
1891 if (llc->llc_mcast[i] &&
1892 bcmp(llc->llc_mcast[i]->llcm_addr,
1893 maddr->ether_addr_octet, ETHERADDRL)) {
1894 /* this is a match -- just succeed */
1895 dlokack(q, mp, DL_ENABMULTI_REQ);
1896 return (LLCE_OK);
1897 }
1898 }
1899 }
1900 /*
1901 * there wasn't one so check to see if the mac layer has one
1902 */
1903 if (macinfo->llcp_mcast == NULL) {
1904 macinfo->llcp_mcast =
1905 GETSTRUCT(llc_mcast_t,
1906 llc1_device_list.llc1_multisize);
1907 if (macinfo->llcp_mcast == NULL)
1908 return (DL_SYSERR);
1909 }
1910 for (mcast = NULL, i = 0;
1911 i < llc1_device_list.llc1_multisize; i++) {
1912 if (macinfo->llcp_mcast[i].llcm_refcnt &&
1913 bcmp(macinfo->llcp_mcast[i].llcm_addr,
1914 maddr->ether_addr_octet, ETHERADDRL) == 0) {
1915 mcast = &macinfo->llcp_mcast[i];
1916 break;
1917 }
1918 }
1919 if (mcast == NULL) {
1920 mblk_t *nmp;
1921
1922 nmp = dupmsg(mp);
1923 if (nmp) {
1924 nmp->b_cont = NULL;
1925 DB_TYPE(nmp) = M_PROTO;
1926 putnext(WR(macinfo->llcp_queue), nmp);
1927 }
1928 /* find an empty slot to fill in */
1929 for (mcast = macinfo->llcp_mcast, i = 0;
1930 i < llc1_device_list.llc1_multisize; i++, mcast++) {
1931 if (mcast->llcm_refcnt == 0) {
1932 bcopy(maddr->ether_addr_octet,
1933 mcast->llcm_addr, ETHERADDRL);
1934 break;
1935 }
1936 }
1937 }
1938 if (mcast != NULL) {
1939 for (i = 0; i < llc1_device_list.llc1_multisize; i++) {
1940 if (llc->llc_mcast[i] == NULL) {
1941 llc->llc_mcast[i] = mcast;
1942 mcast->llcm_refcnt++;
1943 dlokack(q, mp, DL_ENABMULTI_REQ);
1944 return (LLCE_OK);
1945 }
1946 }
1947 }
1948 status = DL_TOOMANY;
1949 }
1950 return (status);
1951 }
1952
1953 /*
1954 * llc1_disable_multi disable the multicast address on the stream if last
1955 * reference for the mac layer, disable there as well
1956 */
1957 static int
1958 llc1_disable_multi(queue_t *q, mblk_t *mp)
1959 {
1960 llc1_t *llc;
1961 llc_mac_info_t *macinfo;
1962 struct ether_addr *maddr;
1963 dl_enabmulti_req_t *multi;
1964 int status = DL_BADADDR, i;
1965 llc_mcast_t *mcast;
1966
1967 #if defined(LLC1_DEBUG)
1968 if (llc1_debug & LLCPROT) {
1969 printf("llc1_enable_multi(%x, %x)\n", q, mp);
1970 }
1971 #endif
1972
1973 llc = (llc1_t *)q->q_ptr;
1974
1975 if (llc->llc_state == DL_UNATTACHED)
1976 return (DL_OUTSTATE);
1977
1978 macinfo = llc->llc_mac_info;
1979 multi = (dl_enabmulti_req_t *)mp->b_rptr;
1980 maddr = (struct ether_addr *)(multi + 1);
1981
1982 if (MBLKL(mp) >= sizeof (dl_enabmulti_req_t) &&
1983 MBLKIN(mp, multi->dl_addr_offset, multi->dl_addr_length)) {
1984 /* request appears to be valid */
1985 /* does this address appear in current table? */
1986 if (llc->llc_mcast != NULL) {
1987 for (i = 0; i < llc->llc_multicnt; i++)
1988 if (((mcast = llc->llc_mcast[i]) != NULL) &&
1989 mcast->llcm_refcnt &&
1990 bcmp(mcast->llcm_addr,
1991 maddr->ether_addr_octet, ETHERADDRL) == 0) {
1992 llc1_send_disable_multi(macinfo,
1993 mcast);
1994 llc->llc_mcast[i] = NULL;
1995 dlokack(q, mp, DL_DISABMULTI_REQ);
1996 return (LLCE_OK);
1997 }
1998 status = DL_NOTENAB;
1999 }
2000 }
2001 return (status);
2002 }
2003
2004 /*
2005 * llc1_send_disable_multi(llc, macinfo, mcast) this function is used to
2006 * disable a multicast address if the reference count goes to zero. The
2007 * disable request will then be forwarded to the lower stream.
2008 */
2009 static void
2010 llc1_send_disable_multi(llc_mac_info_t *macinfo, llc_mcast_t *mcast)
2011 {
2012 mblk_t *mp;
2013 dl_disabmulti_req_t *dis;
2014
2015 if (mcast == NULL) {
2016 return;
2017 }
2018 if (macinfo == NULL || macinfo->llcp_queue == NULL) {
2019 return;
2020 }
2021 if (--mcast->llcm_refcnt > 0)
2022 return;
2023
2024 mp = allocb(sizeof (dl_disabmulti_req_t) + ETHERADDRL, BPRI_MED);
2025 if (mp) {
2026 dis = (dl_disabmulti_req_t *)mp->b_rptr;
2027 mp->b_wptr =
2028 mp->b_rptr + sizeof (dl_disabmulti_req_t) + ETHERADDRL;
2029 dis->dl_primitive = DL_DISABMULTI_REQ;
2030 dis->dl_addr_offset = sizeof (dl_disabmulti_req_t);
2031 dis->dl_addr_length = ETHERADDRL;
2032 bcopy(mcast->llcm_addr,
2033 (mp->b_rptr + sizeof (dl_disabmulti_req_t)), ETHERADDRL);
2034 DB_TYPE(mp) = M_PROTO;
2035 putnext(WR(macinfo->llcp_queue), mp);
2036 }
2037 }
2038
2039 /*
2040 * llc1_findminor(device) searches the per device class list of STREAMS for
2041 * the first minor number not used. Note that we currently don't allocate
2042 * minor 0.
2043 */
2044
2045 static minor_t
2046 llc1_findminor(llc1dev_t *device)
2047 {
2048 llc1_t *next;
2049 minor_t minor;
2050
2051 ASSERT(device != NULL);
2052 for (minor = 1; minor <= MAXMIN32; minor++) {
2053 for (next = device->llc1_str_next;
2054 next != NULL && next != (llc1_t *)&device->llc1_str_next;
2055 next = next->llc_next) {
2056 if (minor == next->llc_minor)
2057 goto nextminor;
2058 }
2059 return (minor);
2060 nextminor:
2061 /* don't need to do anything */
2062 ;
2063 }
2064 /*NOTREACHED*/
2065 return (0);
2066 }
2067
2068 /*
2069 * llc1_req_info(q) simply construct a DL_INFO_REQ to be sent to the lower
2070 * stream this is used to populate the macinfo structure.
2071 */
2072 static int
2073 llc1_req_info(queue_t *q)
2074 {
2075 dl_info_req_t *info;
2076 mblk_t *mp;
2077
2078 mp = allocb(DL_INFO_REQ_SIZE, BPRI_MED);
2079 if (mp == NULL)
2080 return (-1);
2081 DB_TYPE(mp) = M_PCPROTO;
2082 info = (dl_info_req_t *)mp->b_rptr;
2083 mp->b_wptr = mp->b_rptr + DL_INFO_REQ_SIZE;
2084 info->dl_primitive = DL_INFO_REQ;
2085 putnext(q, mp);
2086 return (0);
2087 }
2088
2089 /*
2090 * llc1_req_raw(macinfo) request that the lower stream enter DLIOCRAW mode
2091 */
2092 static void
2093 llc1_req_raw(llc_mac_info_t *macinfo)
2094 {
2095 mblk_t *mp;
2096
2097 mp = mkiocb(DLIOCRAW);
2098 if (mp == NULL)
2099 return;
2100
2101 macinfo->llcp_iocid = ((struct iocblk *)mp->b_rptr)->ioc_id;
2102
2103 putnext(macinfo->llcp_queue, mp);
2104 macinfo->llcp_flags |= LLC1_RAW_WAIT;
2105 }
2106
2107 /*
2108 * llc1_send_bindreq
2109 * if lower stream isn't bound, bind it to something appropriate
2110 */
2111 static void
2112 llc1_send_bindreq(llc_mac_info_t *macinfo)
2113 {
2114 mblk_t *mp;
2115 dl_bind_req_t *bind;
2116
2117 if (macinfo->llcp_sap >= 0xFF) {
2118 /* have to quite sometime if the world is failing */
2119 macinfo->llcp_sap &= ~(LLC1_BINDING|LLC1_AVAILABLE);
2120 return;
2121 }
2122
2123 mp = allocb(sizeof (dl_bind_req_t), BPRI_MED);
2124 if (mp == NULL)
2125 return;
2126
2127 bind = (dl_bind_req_t *)mp->b_rptr;
2128 mp->b_wptr = mp->b_rptr + sizeof (dl_bind_req_t);
2129
2130 bind->dl_primitive = DL_BIND_REQ;
2131 bind->dl_sap = macinfo->llcp_sap += 2; /* starts at 2, inc by 2 */
2132 macinfo->llcp_flags |= LLC1_BINDING;
2133 bind->dl_max_conind = 0;
2134 bind->dl_service_mode = DL_CLDLS;
2135 bind->dl_conn_mgmt = 0;
2136 bind->dl_xidtest_flg = 0;
2137 putnext(macinfo->llcp_queue, mp);
2138 }
2139
2140 /*
2141 * llc1_form_udata(lld, macinfo, mp) format a DL_UNITDATA_IND message to be
2142 * sent to the user
2143 */
2144 static mblk_t *
2145 llc1_form_udata(llc1_t *lld, llc_mac_info_t *macinfo, mblk_t *mp)
2146 {
2147 mblk_t *udmp, *nmp;
2148 dl_unitdata_ind_t *udata;
2149 struct ether_header *hdr;
2150 struct llchdr *llchdr;
2151 struct snaphdr *snap;
2152
2153 if (macinfo->llcp_flags & LLC1_USING_RAW) {
2154 hdr = (struct ether_header *)mp->b_rptr;
2155 llchdr = (struct llchdr *)(hdr + 1);
2156
2157 /* allocate the DL_UNITDATA_IND M_PROTO header */
2158 udmp = allocb(sizeof (dl_unitdata_ind_t) +
2159 2 * (macinfo->llcp_addrlen + 5), BPRI_MED);
2160 if (udmp == NULL) {
2161 /* might as well discard since we can't go further */
2162 freemsg(mp);
2163 return (NULL);
2164 }
2165 udata = (dl_unitdata_ind_t *)udmp->b_rptr;
2166 udmp->b_wptr += sizeof (dl_unitdata_ind_t);
2167
2168 nmp = dupmsg(mp); /* make a copy for future streams */
2169 if (lld->llc_sap != LLC_NOVELL_SAP)
2170 mp->b_rptr += sizeof (struct ether_header) +
2171 sizeof (struct llchdr);
2172 else
2173 mp->b_rptr += sizeof (struct ether_header);
2174
2175 if (lld->llc_flags & LLC_SNAP) {
2176 mp->b_rptr += sizeof (struct snaphdr);
2177 snap = (struct snaphdr *)(llchdr + 1);
2178 }
2179
2180 /*
2181 * now setup the DL_UNITDATA_IND header
2182 */
2183 DB_TYPE(udmp) = M_PROTO;
2184 udata->dl_primitive = DL_UNITDATA_IND;
2185 udata->dl_dest_addr_offset = sizeof (dl_unitdata_ind_t);
2186 bcopy(hdr->ether_dhost.ether_addr_octet,
2187 LLCADDR(udata, udata->dl_dest_addr_offset)->llca_addr,
2188 macinfo->llcp_addrlen);
2189
2190 if (lld->llc_flags & LLC_SNAP) {
2191 udata->dl_dest_addr_length = macinfo->llcp_addrlen + 2;
2192 LLCSADDR(udata, udata->dl_dest_addr_offset)->llca_ssap =
2193 ntohs(*(ushort_t *)snap->snap_type);
2194 } else {
2195 udata->dl_dest_addr_length = macinfo->llcp_addrlen + 1;
2196 LLCADDR(udata, udata->dl_dest_addr_offset)->llca_sap =
2197 llchdr->llc_dsap;
2198 }
2199 udmp->b_wptr += udata->dl_dest_addr_length;
2200 udata->dl_src_addr_offset = udata->dl_dest_addr_length +
2201 udata->dl_dest_addr_offset;
2202 bcopy(hdr->ether_shost.ether_addr_octet,
2203 LLCADDR(udata, udata->dl_src_addr_offset)->llca_addr,
2204 macinfo->llcp_addrlen);
2205 if (lld->llc_flags & LLC_SNAP) {
2206 udata->dl_src_addr_length = macinfo->llcp_addrlen + 2;
2207 LLCSADDR(udata, udata->dl_src_addr_offset)->llca_ssap =
2208 ntohs(*(ushort_t *)snap->snap_type);
2209 } else {
2210 udata->dl_src_addr_length = macinfo->llcp_addrlen + 1;
2211 LLCADDR(udata, udata->dl_src_addr_offset)->llca_sap =
2212 llchdr->llc_ssap;
2213 }
2214 udata->dl_group_address = hdr->ether_dhost.ether_addr_octet[0] &
2215 0x1;
2216 udmp->b_wptr += udata->dl_src_addr_length;
2217 udmp->b_cont = mp;
2218 } else {
2219 dl_unitdata_ind_t *ud2;
2220 if (mp->b_cont == NULL) {
2221 return (mp); /* we can't do anything */
2222 }
2223 /* if we end up here, we only want to patch the existing M_PROTO */
2224 nmp = dupmsg(mp); /* make a copy for future streams */
2225 udata = (dl_unitdata_ind_t *)(mp->b_rptr);
2226 udmp = allocb(MBLKL(mp) + 4, BPRI_MED);
2227 bcopy(mp->b_rptr, udmp->b_rptr, sizeof (dl_unitdata_ind_t));
2228 ud2 = (dl_unitdata_ind_t *)(udmp->b_rptr);
2229 udmp->b_wptr += sizeof (dl_unitdata_ind_t);
2230 bcopy((caddr_t)mp->b_rptr + udata->dl_dest_addr_offset,
2231 udmp->b_wptr, macinfo->llcp_addrlen);
2232 ud2->dl_dest_addr_offset = sizeof (dl_unitdata_ind_t);
2233 ud2->dl_dest_addr_length = macinfo->llcp_addrlen + 1;
2234 udmp->b_wptr += ud2->dl_dest_addr_length;
2235 bcopy((caddr_t)udmp->b_rptr + udata->dl_src_addr_offset,
2236 udmp->b_wptr, macinfo->llcp_addrlen);
2237 ud2->dl_src_addr_length = ud2->dl_dest_addr_length;
2238 udmp->b_wptr += ud2->dl_src_addr_length;
2239 udmp->b_cont = mp->b_cont;
2240 if (lld->llc_sap != LLC_NOVELL_SAP)
2241 mp->b_cont->b_rptr += sizeof (struct llchdr);
2242 freeb(mp);
2243
2244 DB_TYPE(udmp) = M_PROTO;
2245 udata = (dl_unitdata_ind_t *)(mp->b_rptr);
2246 llchdr = (struct llchdr *)(mp->b_cont->b_rptr);
2247 LLCADDR(udata, udata->dl_dest_addr_offset)->llca_sap =
2248 llchdr->llc_dsap;
2249 LLCADDR(udata, udata->dl_src_addr_offset)->llca_sap =
2250 llchdr->llc_ssap;
2251 }
2252 #ifdef LLC1_DEBUG
2253 if (llc1_debug & LLCRECV)
2254 printf("llc1_recv: queued message to %x (%d)\n",
2255 lld->llc_qptr, lld->llc_minor);
2256 #endif
2257 /* enqueue for the service routine to process */
2258 putnext(RD(lld->llc_qptr), udmp);
2259 mp = nmp;
2260 return (mp);
2261 }
2262
2263 /*
2264 * llc1_xid_reply(macinfo, mp) automatic reply to an XID command
2265 */
2266 static mblk_t *
2267 llc1_xid_reply(llc_mac_info_t *macinfo, mblk_t *mp, int sap)
2268 {
2269 mblk_t *nmp, *rmp;
2270 struct ether_header *hdr, *msgether;
2271 struct llchdr *llchdr;
2272 struct llchdr *msgllc;
2273 struct llchdr_xid *xid;
2274
2275 if (DB_TYPE(mp) == M_DATA) {
2276 hdr = (struct ether_header *)mp->b_rptr;
2277 llchdr = (struct llchdr *)(hdr + 1);
2278 } else {
2279 if (mp->b_cont == NULL)
2280 return (mp);
2281 llchdr = (struct llchdr *)(mp->b_cont->b_rptr);
2282 }
2283
2284 /* we only want to respond to commands to avoid response loops */
2285 if (llchdr->llc_ssap & LLC_RESPONSE)
2286 return (mp);
2287
2288 nmp = allocb(msgdsize(mp) + LLC_XID_INFO_SIZE, BPRI_MED);
2289 if (nmp == NULL) {
2290 return (mp);
2291 }
2292
2293 /*
2294 * now construct the XID reply frame
2295 */
2296 if (DB_TYPE(mp) == M_DATA) {
2297 msgether = (struct ether_header *)nmp->b_rptr;
2298 nmp->b_wptr += sizeof (struct ether_header);
2299 bcopy(hdr->ether_shost.ether_addr_octet,
2300 msgether->ether_dhost.ether_addr_octet,
2301 macinfo->llcp_addrlen);
2302 bcopy(macinfo->llcp_macaddr,
2303 msgether->ether_shost.ether_addr_octet,
2304 macinfo->llcp_addrlen);
2305 msgether->ether_type = htons(sizeof (struct llchdr_xid) +
2306 sizeof (struct llchdr));
2307 rmp = nmp;
2308 } else {
2309 dl_unitdata_req_t *ud;
2310 dl_unitdata_ind_t *rud;
2311 rud = (dl_unitdata_ind_t *)mp->b_rptr;
2312
2313 rmp = allocb(sizeof (dl_unitdata_req_t) +
2314 macinfo->llcp_addrlen + 5, BPRI_MED);
2315 if (rmp == NULL)
2316 return (mp);
2317
2318 DB_TYPE(rmp) = M_PROTO;
2319 bzero(rmp->b_rptr, sizeof (dl_unitdata_req_t));
2320 ud = (dl_unitdata_req_t *)rmp->b_rptr;
2321 ud->dl_primitive = DL_UNITDATA_REQ;
2322 ud->dl_dest_addr_offset = sizeof (dl_unitdata_req_t);
2323 ud->dl_dest_addr_length = macinfo->llcp_addrlen + 1;
2324
2325 rmp->b_wptr += sizeof (dl_unitdata_req_t);
2326 bcopy(LLCADDR(mp->b_rptr, rud->dl_src_addr_offset),
2327 LLCADDR(rmp->b_rptr, ud->dl_dest_addr_offset),
2328 macinfo->llcp_addrlen);
2329 LLCADDR(rmp->b_rptr, ud->dl_dest_addr_offset)->llca_sap =
2330 LLCADDR(mp->b_rptr, rud->dl_src_addr_offset)->llca_sap;
2331 rmp->b_wptr += sizeof (struct llcaddr);
2332 rmp->b_cont = nmp;
2333 }
2334
2335 msgllc = (struct llchdr *)nmp->b_wptr;
2336 xid = (struct llchdr_xid *)(msgllc + 1);
2337 nmp->b_wptr += sizeof (struct llchdr);
2338
2339 msgllc->llc_dsap = llchdr->llc_ssap;
2340
2341 /* mark it a response */
2342 msgllc->llc_ssap = sap | LLC_RESPONSE;
2343
2344 msgllc->llc_ctl = llchdr->llc_ctl;
2345 xid->llcx_format = LLC_XID_FMTID;
2346 xid->llcx_class = LLC_XID_TYPE_1;
2347 xid->llcx_window = 0; /* we don't have connections yet */
2348
2349 nmp->b_wptr += sizeof (struct llchdr_xid);
2350 macinfo->llcp_stats.llcs_xidxmt++;
2351 putnext(WR(macinfo->llcp_queue), rmp);
2352 return (mp);
2353 }
2354
2355 /*
2356 * llc1_xid_ind_con(lld, macinfo, mp) form a DL_XID_IND or DL_XID_CON message
2357 * to send to the user since it was requested that the user process these
2358 * messages
2359 */
2360 static mblk_t *
2361 llc1_xid_ind_con(llc1_t *lld, llc_mac_info_t *macinfo, mblk_t *mp)
2362 {
2363 mblk_t *nmp;
2364 dl_xid_ind_t *xid;
2365 struct ether_header *hdr;
2366 struct llchdr *llchdr;
2367 int raw;
2368
2369 nmp = allocb(sizeof (dl_xid_ind_t) + 2 * (macinfo->llcp_addrlen + 1),
2370 BPRI_MED);
2371 if (nmp == NULL)
2372 return (mp);
2373
2374 if ((raw = (DB_TYPE(mp) == M_DATA)) != 0) {
2375 hdr = (struct ether_header *)mp->b_rptr;
2376 llchdr = (struct llchdr *)(hdr + 1);
2377 } else {
2378 if (mp->b_rptr == NULL)
2379 return (mp);
2380 llchdr = (struct llchdr *)mp->b_cont->b_rptr;
2381 }
2382
2383 xid = (dl_xid_ind_t *)nmp->b_rptr;
2384 xid->dl_flag = (llchdr->llc_ctl & LLC_P) ? DL_POLL_FINAL : 0;
2385 xid->dl_dest_addr_offset = sizeof (dl_xid_ind_t);
2386 xid->dl_dest_addr_length = macinfo->llcp_addrlen + 1;
2387
2388 if (raw) {
2389 bcopy(hdr->ether_dhost.ether_addr_octet,
2390 (nmp->b_rptr + xid->dl_dest_addr_offset),
2391 xid->dl_dest_addr_length);
2392 } else {
2393 dl_unitdata_ind_t *ind;
2394 ind = (dl_unitdata_ind_t *)mp->b_rptr;
2395 bcopy(LLCADDR(ind, ind->dl_dest_addr_offset),
2396 (nmp->b_rptr + xid->dl_dest_addr_offset),
2397 xid->dl_dest_addr_length);
2398 }
2399
2400 LLCADDR(xid, xid->dl_dest_addr_offset)->llca_sap =
2401 llchdr->llc_dsap;
2402
2403 xid->dl_src_addr_offset =
2404 xid->dl_dest_addr_offset + xid->dl_dest_addr_length;
2405 xid->dl_src_addr_length = xid->dl_dest_addr_length;
2406
2407 if (raw) {
2408 bcopy(hdr->ether_shost.ether_addr_octet,
2409 (nmp->b_rptr + xid->dl_src_addr_offset),
2410 xid->dl_src_addr_length);
2411 } else {
2412 dl_unitdata_ind_t *ind;
2413 ind = (dl_unitdata_ind_t *)mp->b_rptr;
2414 bcopy(LLCADDR(mp->b_rptr, ind->dl_src_addr_offset),
2415 (nmp->b_rptr + xid->dl_src_addr_offset),
2416 ind->dl_src_addr_length);
2417 }
2418 LLCADDR(nmp->b_rptr, xid->dl_src_addr_offset)->llca_sap =
2419 llchdr->llc_ssap & ~LLC_RESPONSE;
2420
2421 nmp->b_wptr = nmp->b_rptr + sizeof (dl_xid_ind_t) +
2422 2 * xid->dl_dest_addr_length;
2423
2424 if (!(llchdr->llc_ssap & LLC_RESPONSE)) {
2425 xid->dl_primitive = DL_XID_IND;
2426 } else {
2427 xid->dl_primitive = DL_XID_CON;
2428 }
2429
2430 DB_TYPE(nmp) = M_PROTO;
2431 if (raw) {
2432 if (MBLKL(mp) >
2433 (sizeof (struct ether_header) + sizeof (struct llchdr))) {
2434 nmp->b_cont = dupmsg(mp);
2435 if (nmp->b_cont) {
2436 nmp->b_cont->b_rptr +=
2437 sizeof (struct ether_header) +
2438 sizeof (struct llchdr);
2439 }
2440 }
2441 } else if (mp->b_cont != NULL && MBLKL(mp->b_cont) >
2442 sizeof (struct llchdr)) {
2443 nmp->b_cont = dupmsg(mp->b_cont);
2444 (void) adjmsg(nmp->b_cont, sizeof (struct llchdr));
2445 }
2446 putnext(RD(lld->llc_qptr), nmp);
2447 return (mp);
2448 }
2449
2450 /*
2451 * llc1_xid_req_res(q, mp, req_or_res) the user wants to send an XID message
2452 * or response construct a proper message and put on the net
2453 */
2454 static int
2455 llc1_xid_req_res(queue_t *q, mblk_t *mp, int req_or_res)
2456 {
2457 dl_xid_req_t *xid = (dl_xid_req_t *)mp->b_rptr;
2458 llc1_t *llc = (llc1_t *)q->q_ptr;
2459 llc_mac_info_t *macinfo;
2460 mblk_t *nmp, *rmp;
2461 struct ether_header *hdr;
2462 struct llchdr *llchdr;
2463
2464 if (llc == NULL || llc->llc_state == DL_UNATTACHED)
2465 return (DL_OUTSTATE);
2466
2467 if (llc->llc_sap == LLC_NOVELL_SAP)
2468 return (DL_NOTSUPPORTED);
2469
2470 if (llc->llc_flags & DL_AUTO_XID)
2471 return (DL_XIDAUTO);
2472
2473 macinfo = llc->llc_mac_info;
2474 if (MBLKL(mp) < sizeof (dl_xid_req_t) ||
2475 !MBLKIN(mp, xid->dl_dest_addr_offset, xid->dl_dest_addr_length)) {
2476 return (DL_BADPRIM);
2477 }
2478
2479 nmp = allocb(sizeof (struct ether_header) + sizeof (struct llchdr) +
2480 sizeof (struct llchdr_xid), BPRI_MED);
2481
2482 if (nmp == NULL)
2483 return (LLCE_NOBUFFER);
2484
2485 if (macinfo->llcp_flags & LLC1_USING_RAW) {
2486 hdr = (struct ether_header *)nmp->b_rptr;
2487 bcopy(LLCADDR(xid, xid->dl_dest_addr_offset)->llca_addr,
2488 hdr->ether_dhost.ether_addr_octet, ETHERADDRL);
2489 bcopy(macinfo->llcp_macaddr,
2490 hdr->ether_shost.ether_addr_octet, ETHERADDRL);
2491 hdr->ether_type = htons(sizeof (struct llchdr) + msgdsize(mp));
2492 nmp->b_wptr = nmp->b_rptr +
2493 sizeof (struct ether_header) + sizeof (struct llchdr);
2494 llchdr = (struct llchdr *)(hdr + 1);
2495 rmp = nmp;
2496 } else {
2497 dl_unitdata_req_t *ud;
2498 rmp = allocb(sizeof (dl_unitdata_req_t) +
2499 (macinfo->llcp_addrlen + 2), BPRI_MED);
2500 if (rmp == NULL) {
2501 freemsg(nmp);
2502 return (LLCE_NOBUFFER);
2503 }
2504 ud = (dl_unitdata_req_t *)rmp->b_rptr;
2505 DB_TYPE(rmp) = M_PROTO;
2506 ud->dl_primitive = DL_UNITDATA_REQ;
2507 ud->dl_dest_addr_offset = sizeof (dl_unitdata_req_t);
2508 ud->dl_dest_addr_length = xid->dl_dest_addr_length;
2509 rmp->b_wptr += sizeof (dl_unitdata_req_t);
2510 bcopy(LLCADDR(xid, xid->dl_dest_addr_offset)->llca_addr,
2511 LLCADDR(ud, ud->dl_dest_addr_offset),
2512 xid->dl_dest_addr_length);
2513 LLCSADDR(ud, ud->dl_dest_addr_offset)->llca_ssap =
2514 msgdsize(mp);
2515 rmp->b_wptr += xid->dl_dest_addr_length;
2516 rmp->b_cont = nmp;
2517 llchdr = (struct llchdr *)nmp->b_rptr;
2518 nmp->b_wptr += sizeof (struct llchdr);
2519 }
2520
2521 llchdr->llc_dsap = LLCADDR(xid, xid->dl_dest_addr_offset)->llca_sap;
2522 llchdr->llc_ssap = llc->llc_sap | (req_or_res ? LLC_RESPONSE : 0);
2523 llchdr->llc_ctl =
2524 LLC_XID | ((xid->dl_flag & DL_POLL_FINAL) ? LLC_P : 0);
2525
2526 nmp->b_cont = mp->b_cont;
2527 mp->b_cont = NULL;
2528 freeb(mp);
2529 macinfo->llcp_stats.llcs_xidxmt++;
2530 putnext(WR(macinfo->llcp_queue), rmp);
2531 return (LLCE_OK);
2532 }
2533
2534 /*
2535 * llc1_test_reply(macinfo, mp)
2536 * automatic reply to a TEST message
2537 */
2538 static mblk_t *
2539 llc1_test_reply(llc_mac_info_t *macinfo, mblk_t *mp, int sap)
2540 {
2541 mblk_t *nmp;
2542 struct ether_header *hdr, *msgether;
2543 struct llchdr *llchdr;
2544 struct llchdr *msgllc;
2545 int poll_final;
2546
2547 if (DB_TYPE(mp) == M_PROTO) {
2548 if (mp->b_cont == NULL)
2549 return (mp);
2550 llchdr = (struct llchdr *)mp->b_cont->b_rptr;
2551 hdr = NULL;
2552 } else {
2553 hdr = (struct ether_header *)mp->b_rptr;
2554 llchdr = (struct llchdr *)(hdr + 1);
2555 }
2556
2557 /* we only want to respond to commands to avoid response loops */
2558 if (llchdr->llc_ssap & LLC_RESPONSE)
2559 return (mp);
2560
2561 nmp = copymsg(mp); /* so info field is duplicated */
2562 if (nmp == NULL) {
2563 nmp = mp;
2564 mp = NULL;
2565 }
2566 /*
2567 * now construct the TEST reply frame
2568 */
2569
2570
2571 poll_final = llchdr->llc_ctl & LLC_P;
2572
2573 if (DB_TYPE(nmp) == M_PROTO) {
2574 dl_unitdata_req_t *udr = (dl_unitdata_req_t *)nmp->b_rptr;
2575 dl_unitdata_ind_t *udi = (dl_unitdata_ind_t *)nmp->b_rptr;
2576
2577 /* make into a request */
2578 udr->dl_primitive = DL_UNITDATA_REQ;
2579 udr->dl_dest_addr_offset = udi->dl_src_addr_offset;
2580 udr->dl_dest_addr_length = udi->dl_src_addr_length;
2581 udr->dl_priority.dl_min = udr->dl_priority.dl_max = 0;
2582 msgllc = (struct llchdr *)nmp->b_cont->b_rptr;
2583 } else {
2584 msgether = (struct ether_header *)nmp->b_rptr;
2585 bcopy(hdr->ether_shost.ether_addr_octet,
2586 msgether->ether_dhost.ether_addr_octet,
2587 macinfo->llcp_addrlen);
2588 bcopy(macinfo->llcp_macaddr,
2589 msgether->ether_shost.ether_addr_octet,
2590 macinfo->llcp_addrlen);
2591 msgllc = (struct llchdr *)(msgether+1);
2592 }
2593
2594 msgllc->llc_dsap = llchdr->llc_ssap;
2595
2596 /* mark it as a response */
2597 msgllc->llc_ssap = sap | LLC_RESPONSE;
2598 msgllc->llc_ctl = LLC_TEST | poll_final;
2599
2600 macinfo->llcp_stats.llcs_testxmt++;
2601 putnext(WR(macinfo->llcp_queue), nmp);
2602 return (mp);
2603 }
2604
2605 /*
2606 * llc1_test_ind_con(lld, macinfo, mp) form a DL_TEST_IND or DL_TEST_CON
2607 * message to send to the user since it was requested that the user process
2608 * these messages
2609 */
2610 static mblk_t *
2611 llc1_test_ind_con(llc1_t *lld, llc_mac_info_t *macinfo, mblk_t *mp)
2612 {
2613 mblk_t *nmp;
2614 dl_test_ind_t *test;
2615 struct ether_header *hdr;
2616 struct llchdr *llchdr;
2617 int raw;
2618
2619 nmp = allocb(sizeof (dl_test_ind_t) + 2 * (ETHERADDRL + 1), BPRI_MED);
2620 if (nmp == NULL)
2621 return (NULL);
2622
2623 if ((raw = (DB_TYPE(mp) == M_DATA)) != 0) {
2624 hdr = (struct ether_header *)mp->b_rptr;
2625 llchdr = (struct llchdr *)(hdr + 1);
2626 } else {
2627 if (mp->b_rptr == NULL)
2628 return (mp);
2629 llchdr = (struct llchdr *)mp->b_cont->b_rptr;
2630 }
2631
2632 test = (dl_test_ind_t *)nmp->b_rptr;
2633 test->dl_flag = (llchdr->llc_ctl & LLC_P) ? DL_POLL_FINAL : 0;
2634 test->dl_dest_addr_offset = sizeof (dl_test_ind_t);
2635 test->dl_dest_addr_length = macinfo->llcp_addrlen + 1;
2636
2637 if (raw) {
2638 bcopy(hdr->ether_dhost.ether_addr_octet,
2639 LLCADDR(nmp->b_rptr, test->dl_dest_addr_offset)->llca_addr,
2640 test->dl_dest_addr_length);
2641 } else {
2642 dl_unitdata_ind_t *ind;
2643 ind = (dl_unitdata_ind_t *)mp->b_rptr;
2644 bcopy(LLCADDR(ind, ind->dl_dest_addr_offset),
2645 (nmp->b_rptr + test->dl_dest_addr_offset),
2646 test->dl_dest_addr_length);
2647 }
2648
2649 LLCADDR(test, test->dl_dest_addr_offset)->llca_sap =
2650 llchdr->llc_dsap;
2651
2652 test->dl_src_addr_offset = test->dl_dest_addr_offset +
2653 test->dl_dest_addr_length;
2654 test->dl_src_addr_length = test->dl_dest_addr_length;
2655
2656 if (raw) {
2657 bcopy(hdr->ether_shost.ether_addr_octet,
2658 LLCADDR(nmp->b_rptr, test->dl_src_addr_offset)->llca_addr,
2659 test->dl_src_addr_length);
2660 } else {
2661 dl_unitdata_ind_t *ind;
2662 ind = (dl_unitdata_ind_t *)mp->b_rptr;
2663 bcopy(LLCADDR(mp->b_rptr, ind->dl_src_addr_offset),
2664 (nmp->b_rptr + test->dl_src_addr_offset),
2665 ind->dl_src_addr_length);
2666 }
2667 LLCADDR(nmp->b_rptr, test->dl_src_addr_offset)->llca_sap =
2668 llchdr->llc_ssap & ~LLC_RESPONSE;
2669
2670 nmp->b_wptr = nmp->b_rptr + sizeof (dl_test_ind_t) +
2671 2 * test->dl_dest_addr_length;
2672
2673 if (!(llchdr->llc_ssap & LLC_RESPONSE)) {
2674 test->dl_primitive = DL_TEST_IND;
2675 } else {
2676 test->dl_primitive = DL_TEST_CON;
2677 }
2678
2679 DB_TYPE(nmp) = M_PROTO;
2680 if (raw) {
2681 if (MBLKL(mp) >
2682 (sizeof (struct ether_header) + sizeof (struct llchdr))) {
2683 nmp->b_cont = dupmsg(mp);
2684 if (nmp->b_cont) {
2685 nmp->b_cont->b_rptr +=
2686 sizeof (struct ether_header) +
2687 sizeof (struct llchdr);
2688 }
2689 }
2690 } else if (mp->b_cont != NULL && MBLKL(mp->b_cont) >
2691 sizeof (struct llchdr)) {
2692 nmp->b_cont = dupmsg(mp->b_cont);
2693 (void) adjmsg(nmp->b_cont, sizeof (struct llchdr));
2694 }
2695 putnext(RD(lld->llc_qptr), nmp);
2696 return (mp);
2697 }
2698
2699 /*
2700 * llc1_test_req_res(q, mp, req_or_res) the user wants to send a TEST
2701 * message or response construct a proper message and put on the net
2702 */
2703 static int
2704 llc1_test_req_res(queue_t *q, mblk_t *mp, int req_or_res)
2705 {
2706 dl_test_req_t *test = (dl_test_req_t *)mp->b_rptr;
2707 llc1_t *llc = (llc1_t *)q->q_ptr;
2708 llc_mac_info_t *macinfo;
2709 mblk_t *nmp, *rmp;
2710 struct ether_header *hdr;
2711 struct llchdr *llchdr;
2712
2713 if (llc == NULL || llc->llc_state == DL_UNATTACHED)
2714 return (DL_OUTSTATE);
2715
2716 if (llc->llc_sap == LLC_NOVELL_SAP)
2717 return (DL_NOTSUPPORTED);
2718
2719 if (llc->llc_flags & DL_AUTO_TEST)
2720 return (DL_TESTAUTO);
2721
2722 macinfo = llc->llc_mac_info;
2723 if (MBLKL(mp) < sizeof (dl_test_req_t) ||
2724 !MBLKIN(mp, test->dl_dest_addr_offset,
2725 test->dl_dest_addr_length)) {
2726 return (DL_BADPRIM);
2727 }
2728
2729 nmp = allocb(sizeof (struct ether_header) + sizeof (struct llchdr),
2730 BPRI_MED);
2731
2732 if (nmp == NULL)
2733 return (LLCE_NOBUFFER);
2734
2735 if (macinfo->llcp_flags & LLC1_USING_RAW) {
2736 hdr = (struct ether_header *)nmp->b_rptr;
2737 bcopy(LLCADDR(test, test->dl_dest_addr_offset)->llca_addr,
2738 hdr->ether_dhost.ether_addr_octet, ETHERADDRL);
2739 bcopy(macinfo->llcp_macaddr,
2740 hdr->ether_shost.ether_addr_octet, ETHERADDRL);
2741 hdr->ether_type = htons(sizeof (struct llchdr) + msgdsize(mp));
2742 nmp->b_wptr = nmp->b_rptr +
2743 sizeof (struct ether_header) + sizeof (struct llchdr);
2744 llchdr = (struct llchdr *)(hdr + 1);
2745 rmp = nmp;
2746 } else {
2747 dl_unitdata_req_t *ud;
2748
2749 rmp = allocb(sizeof (dl_unitdata_req_t) +
2750 (macinfo->llcp_addrlen + 2), BPRI_MED);
2751 if (rmp == NULL) {
2752 freemsg(nmp);
2753 return (LLCE_NOBUFFER);
2754
2755 }
2756 ud = (dl_unitdata_req_t *)rmp->b_rptr;
2757 DB_TYPE(rmp) = M_PROTO;
2758 ud->dl_primitive = DL_UNITDATA_REQ;
2759 ud->dl_dest_addr_offset = sizeof (dl_unitdata_req_t);
2760 ud->dl_dest_addr_length = test->dl_dest_addr_length;
2761 rmp->b_wptr += sizeof (dl_unitdata_req_t);
2762 bcopy(LLCADDR(test, test->dl_dest_addr_offset)->llca_addr,
2763 LLCADDR(ud, ud->dl_dest_addr_offset),
2764 test->dl_dest_addr_length);
2765 LLCSADDR(ud, ud->dl_dest_addr_offset)->llca_ssap =
2766 msgdsize(mp);
2767 rmp->b_wptr += test->dl_dest_addr_length;
2768 rmp->b_cont = nmp;
2769 llchdr = (struct llchdr *)nmp->b_rptr;
2770 nmp->b_wptr += sizeof (struct llchdr);
2771 }
2772
2773 llchdr->llc_dsap = LLCADDR(test, test->dl_dest_addr_offset)->llca_sap;
2774 llchdr->llc_ssap = llc->llc_sap | (req_or_res ? LLC_RESPONSE : 0);
2775 llchdr->llc_ctl =
2776 LLC_TEST | ((test->dl_flag & DL_POLL_FINAL) ? LLC_P : 0);
2777
2778 nmp->b_cont = mp->b_cont;
2779 mp->b_cont = NULL;
2780 freeb(mp);
2781 macinfo->llcp_stats.llcs_testxmt++;
2782 putnext(WR(macinfo->llcp_queue), rmp);
2783 return (LLCE_OK);
2784 }
2785
2786 /*
2787 * llc1_find_waiting(macinfo, mp, prim) look for a stream waiting for a
2788 * response to a message identified by prim and send it to the user.
2789 */
2790 static void
2791 llc1_find_waiting(llc_mac_info_t *macinfo, mblk_t *mp, long prim)
2792 {
2793 llc1_t *llc;
2794
2795 for (llc = llc1_device_list.llc1_str_next;
2796 llc != (llc1_t *)&llc1_device_list.llc1_str_next;
2797 llc = llc->llc_next)
2798 if (llc->llc_mac_info == macinfo &&
2799 prim == llc->llc_waiting_for) {
2800 putnext(RD(llc->llc_qptr), mp);
2801 llc->llc_waiting_for = -1;
2802 return;
2803 }
2804 freemsg(mp);
2805 }
2806
2807 static void
2808 llc1insque(void *elem, void *pred)
2809 {
2810 struct qelem *pelem = elem;
2811 struct qelem *ppred = pred;
2812 struct qelem *pnext = ppred->q_forw;
2813
2814 pelem->q_forw = pnext;
2815 pelem->q_back = ppred;
2816 ppred->q_forw = pelem;
2817 pnext->q_back = pelem;
2818 }
2819
2820 static void
2821 llc1remque(void *arg)
2822 {
2823 struct qelem *pelem = arg;
2824 struct qelem *elem = arg;
2825
2826 ASSERT(pelem->q_forw != NULL);
2827 pelem->q_forw->q_back = pelem->q_back;
2828 pelem->q_back->q_forw = pelem->q_forw;
2829 elem->q_back = elem->q_forw = NULL;
2830 }
2831
2832 /* VARARGS */
2833 static void
2834 llc1error(dip, fmt, a1, a2, a3, a4, a5, a6)
2835 dev_info_t *dip;
2836 char *fmt, *a1, *a2, *a3, *a4, *a5, *a6;
2837 {
2838 static long last;
2839 static char *lastfmt;
2840 time_t now;
2841
2842 /*
2843 * Don't print same error message too often.
2844 */
2845 now = gethrestime_sec();
2846 if ((last == (now & ~1)) && (lastfmt == fmt))
2847 return;
2848 last = now & ~1;
2849 lastfmt = fmt;
2850
2851 cmn_err(CE_CONT, "%s%d: ",
2852 ddi_get_name(dip), ddi_get_instance(dip));
2853 cmn_err(CE_CONT, fmt, a1, a2, a3, a4, a5, a6);
2854 cmn_err(CE_CONT, "\n");
2855 }
2856
2857 /*ARGSUSED1*/
2858 static int
2859 llc1_update_kstat(kstat_t *ksp, int rw)
2860 {
2861 llc_mac_info_t *macinfo;
2862 kstat_named_t *kstat;
2863 struct llc_stats *stats;
2864
2865 if (ksp == NULL)
2866 return (0);
2867
2868 kstat = (kstat_named_t *)(ksp->ks_data);
2869 macinfo = (llc_mac_info_t *)(ksp->ks_private);
2870 stats = &macinfo->llcp_stats;
2871
2872 kstat[LLCS_NOBUFFER].value.ul = stats->llcs_nobuffer;
2873 kstat[LLCS_MULTIXMT].value.ul = stats->llcs_multixmt;
2874 kstat[LLCS_MULTIRCV].value.ul = stats->llcs_multircv;
2875 kstat[LLCS_BRDCSTXMT].value.ul = stats->llcs_brdcstxmt;
2876 kstat[LLCS_BRDCSTRCV].value.ul = stats->llcs_brdcstrcv;
2877 kstat[LLCS_BLOCKED].value.ul = stats->llcs_blocked;
2878 kstat[LLCS_PKTXMT].value.ul = stats->llcs_pktxmt;
2879 kstat[LLCS_PKTRCV].value.ul = stats->llcs_pktrcv;
2880 kstat[LLCS_BYTEXMT].value.ul = stats->llcs_bytexmt;
2881 kstat[LLCS_BYTERCV].value.ul = stats->llcs_bytercv;
2882 kstat[LLCS_XIDXMT].value.ul = stats->llcs_xidxmt;
2883 kstat[LLCS_XIDRCV].value.ul = stats->llcs_xidrcv;
2884 kstat[LLCS_TESTXMT].value.ul = stats->llcs_testxmt;
2885 kstat[LLCS_TESTRCV].value.ul = stats->llcs_testrcv;
2886 kstat[LLCS_IERRORS].value.ul = stats->llcs_ierrors;
2887 kstat[LLCS_OERRORS].value.ul = stats->llcs_oerrors;
2888 return (0);
2889 }
2890
2891 static void
2892 llc1_init_kstat(llc_mac_info_t *macinfo)
2893 {
2894 kstat_named_t *ksp;
2895
2896 /*
2897 * Note that the temporary macinfo->llcp_ppa number is negative.
2898 */
2899 macinfo->llcp_kstatp = kstat_create("llc", (-macinfo->llcp_ppa - 1),
2900 NULL, "net", KSTAT_TYPE_NAMED,
2901 sizeof (struct llc_stats) / sizeof (long), 0);
2902 if (macinfo->llcp_kstatp == NULL)
2903 return;
2904
2905 macinfo->llcp_kstatp->ks_update = llc1_update_kstat;
2906 macinfo->llcp_kstatp->ks_private = (void *)macinfo;
2907
2908 ksp = (kstat_named_t *)(macinfo->llcp_kstatp->ks_data);
2909
2910 kstat_named_init(&ksp[LLCS_NOBUFFER], "nobuffer", KSTAT_DATA_ULONG);
2911 kstat_named_init(&ksp[LLCS_MULTIXMT], "multixmt", KSTAT_DATA_ULONG);
2912 kstat_named_init(&ksp[LLCS_MULTIRCV], "multircv", KSTAT_DATA_ULONG);
2913 kstat_named_init(&ksp[LLCS_BRDCSTXMT], "brdcstxmt", KSTAT_DATA_ULONG);
2914 kstat_named_init(&ksp[LLCS_BRDCSTRCV], "brdcstrcv", KSTAT_DATA_ULONG);
2915 kstat_named_init(&ksp[LLCS_BLOCKED], "blocked", KSTAT_DATA_ULONG);
2916 kstat_named_init(&ksp[LLCS_PKTXMT], "pktxmt", KSTAT_DATA_ULONG);
2917 kstat_named_init(&ksp[LLCS_PKTRCV], "pktrcv", KSTAT_DATA_ULONG);
2918 kstat_named_init(&ksp[LLCS_BYTEXMT], "bytexmt", KSTAT_DATA_ULONG);
2919 kstat_named_init(&ksp[LLCS_BYTERCV], "bytercv", KSTAT_DATA_ULONG);
2920 kstat_named_init(&ksp[LLCS_XIDXMT], "xidxmt", KSTAT_DATA_ULONG);
2921 kstat_named_init(&ksp[LLCS_XIDRCV], "xidrcv", KSTAT_DATA_ULONG);
2922 kstat_named_init(&ksp[LLCS_TESTXMT], "testxmt", KSTAT_DATA_ULONG);
2923 kstat_named_init(&ksp[LLCS_TESTRCV], "testrcv", KSTAT_DATA_ULONG);
2924 kstat_named_init(&ksp[LLCS_IERRORS], "ierrors", KSTAT_DATA_ULONG);
2925 kstat_named_init(&ksp[LLCS_OERRORS], "oerrors", KSTAT_DATA_ULONG);
2926 kstat_install(macinfo->llcp_kstatp);
2927 }
2928
2929 static void
2930 llc1_uninit_kstat(llc_mac_info_t *macinfo)
2931 {
2932 if (macinfo->llcp_kstatp) {
2933 kstat_delete(macinfo->llcp_kstatp);
2934 macinfo->llcp_kstatp = NULL;
2935 }
2936 }
2937
2938 /*
2939 * llc1_subs_bind(q, mp)
2940 * implements the DL_SUBS_BIND_REQ primitive
2941 * this only works for a STREAM bound to LLC_SNAP_SAP
2942 * or one bound to the automatic SNAP mode.
2943 * If bound to LLC_SNAP_SAP, the subs bind can be:
2944 * - 2 octets treated as a native byte order short (ethertype)
2945 * - 3 octets treated as a network order byte string (OID part)
2946 * - 5 octets treated as a network order byte string (full SNAP header)
2947 * If bound to an automatic SNAP mode sap, then only the 3 octet
2948 * form is allowed
2949 */
2950 static int
2951 llc1_subs_bind(queue_t *q, mblk_t *mp)
2952 {
2953 llc1_t *lld = (llc1_t *)q->q_ptr;
2954 dl_subs_bind_req_t *subs = (dl_subs_bind_req_t *)mp->b_rptr;
2955 ushort_t subssap;
2956 uchar_t *sapstr;
2957 int result;
2958
2959
2960 #if defined(LLC1_DEBUG)
2961 if (llc1_debug & (LLCTRACE|LLCPROT)) {
2962 printf("llc1_subs_bind (%x, %x)\n", q, mp);
2963 }
2964 #endif
2965
2966 if (lld == NULL || lld->llc_state != DL_IDLE) {
2967 result = DL_OUTSTATE;
2968 } else if (lld->llc_sap != LLC_SNAP_SAP ||
2969 subs->dl_subs_bind_class != DL_HIERARCHICAL_BIND) {
2970 /* we only want to support this for SNAP at present */
2971 result = DL_UNSUPPORTED;
2972 } else {
2973
2974 lld->llc_state = DL_SUBS_BIND_PND;
2975
2976 sapstr = (uchar_t *)(mp->b_rptr + subs->dl_subs_sap_offset);
2977
2978 result = LLCE_OK;
2979 switch (subs->dl_subs_sap_length) {
2980 case 2: /* just the ethertype part */
2981 if (lld->llc_flags & LLC_SNAP) {
2982 result = DL_BADADDR;
2983 break;
2984 }
2985 ((uchar_t *)&subssap)[0] = sapstr[0];
2986 ((uchar_t *)&subssap)[1] = sapstr[1];
2987 subssap = htons(subssap);
2988 lld->llc_snap[3] = ((uchar_t *)&subssap)[0];
2989 lld->llc_snap[4] = ((uchar_t *)&subssap)[1];
2990 lld->llc_flags |= LLC_SNAP;
2991 break;
2992
2993 case 3: /* just the OID part */
2994 if ((lld->llc_flags & (LLC_SNAP|LLC_SNAP_OID)) ==
2995 (LLC_SNAP|LLC_SNAP_OID)) {
2996 result = DL_BADADDR;
2997 break;
2998 }
2999 bcopy(sapstr, lld->llc_snap, 3);
3000 lld->llc_flags |= LLC_SNAP_OID;
3001 break;
3002
3003 case 5: /* full SNAP header */
3004 if (lld->llc_flags & (LLC_SNAP|LLC_SNAP_OID)) {
3005 result = DL_BADADDR;
3006 break;
3007 }
3008 bcopy(sapstr, lld->llc_snap, 5);
3009 lld->llc_flags |= LLC_SNAP|LLC_SNAP_OID;
3010 break;
3011 }
3012 /* if successful, acknowledge and enter the proper state */
3013 if (result == LLCE_OK) {
3014 mblk_t *nmp = mp;
3015 dl_subs_bind_ack_t *ack;
3016
3017 if (DB_REF(mp) != 1 ||
3018 MBLKL(mp) < (sizeof (dl_subs_bind_ack_t) + 5)) {
3019 freemsg(mp);
3020 nmp = allocb(sizeof (dl_subs_bind_ack_t) + 5,
3021 BPRI_MED);
3022 }
3023 ack = (dl_subs_bind_ack_t *)nmp->b_rptr;
3024 nmp->b_wptr = nmp->b_rptr +
3025 sizeof (dl_subs_bind_ack_t) + 5;
3026 ack->dl_primitive = DL_SUBS_BIND_ACK;
3027 ack->dl_subs_sap_offset = sizeof (dl_subs_bind_ack_t);
3028 ack->dl_subs_sap_length = 5;
3029 bcopy(lld->llc_snap,
3030 (caddr_t)nmp->b_rptr + ack->dl_subs_sap_offset + 5,
3031 5);
3032 DB_TYPE(nmp) = M_PCPROTO;
3033 qreply(q, nmp);
3034
3035 }
3036 lld->llc_state = DL_IDLE;
3037 }
3038 return (result);
3039 }
3040
3041 /*
3042 *
3043 */
3044 static int
3045 llc1_subs_unbind(void)
3046 {
3047 return (DL_UNSUPPORTED);
3048 }
3049
3050 char *
3051 snapdmp(uchar_t *bstr)
3052 {
3053 static char buff[32];
3054
3055 (void) sprintf(buff, "%x.%x.%x.%x.%x",
3056 bstr[0],
3057 bstr[1],
3058 bstr[2],
3059 bstr[3],
3060 bstr[4]);
3061 return (buff);
3062 }
3063
3064 static int
3065 llc1_snap_match(llc1_t *lld, struct snaphdr *snap)
3066 {
3067 return (bcmp(snap->snap_oid, lld->llc_snap, 5) == 0);
3068 }