2 * Copyright (c) 1993, 1994, 1995, 1996, 1997
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that: (1) source code distributions
7 * retain the above copyright notice and this paragraph in its entirety, (2)
8 * distributions including binary code include the above copyright notice and
9 * this paragraph in its entirety in the documentation or other materials
10 * provided with the distribution, and (3) all advertising materials mentioning
11 * features or use of this software display the following acknowledgement:
12 * ``This product includes software developed by the University of California,
13 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
14 * the University nor the names of its contributors may be used to endorse
15 * or promote products derived from this software without specific prior
17 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
18 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21 * This code contributed by Atanu Ghosh (atanu@cs.ucl.ac.uk),
22 * University College London.
26 * Packet capture routine for dlpi under SunOS 5
30 * - Apparently the DLIOCRAW ioctl() is specific to SunOS.
32 * - There is a bug in bufmod(7) such that setting the snapshot
33 * length results in data being left of the front of the packet.
35 * - It might be desirable to use pfmod(7) to filter packets in the
40 static const char rcsid[] =
41 "@(#) $Header: /tcpdump/master/libpcap/pcap-dlpi.c,v 1.63 2000/11/22 05:32:55 guy Exp $ (LBL)";
48 #include <sys/types.h>
50 #ifdef HAVE_SYS_BUFMOD_H
51 #include <sys/bufmod.h>
54 #ifdef HAVE_SYS_DLPI_EXT_H
55 #include <sys/dlpi_ext.h>
58 #include <sys/socket.h>
60 #ifdef DL_HP_PPA_ACK_OBS
63 #include <sys/stream.h>
64 #if defined(HAVE_SOLARIS) && defined(HAVE_SYS_BUFMOD_H)
65 #include <sys/systeminfo.h>
87 #ifdef HAVE_OS_PROTO_H
91 #ifndef PCAP_DEV_PREFIX
92 #define PCAP_DEV_PREFIX "/dev"
98 static int dlattachreq(int, bpf_u_int32, char *);
99 static int dlbindack(int, char *, char *);
100 static int dlbindreq(int, bpf_u_int32, char *);
101 static int dlinfoack(int, char *, char *);
102 static int dlinforeq(int, char *);
103 static int dlokack(int, const char *, char *, char *);
104 static int recv_ack(int, int, const char *, char *, char *);
105 static int dlpromisconreq(int, bpf_u_int32, char *);
106 #if defined(HAVE_SOLARIS) && defined(HAVE_SYS_BUFMOD_H)
107 static char *get_release(bpf_u_int32 *, bpf_u_int32 *, bpf_u_int32 *);
109 static int send_request(int, char *, int, char *, char *);
110 #ifdef HAVE_SYS_BUFMOD_H
111 static int strioctl(int, int, int, char *);
114 static int dlpi_kread(int, off_t, void *, u_int, char *);
117 static int get_dlpi_ppa(int, const char *, int, char *);
121 pcap_stats(pcap_t *p, struct pcap_stat *ps)
128 /* XXX Needed by HP-UX (at least) */
129 static bpf_u_int32 ctlbuf[MAXDLBUF];
130 static struct strbuf ctl = {
137 pcap_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
139 register int cc, n, caplen, origlen;
140 register u_char *bp, *ep, *pk;
141 register struct bpf_insn *fcode;
142 #ifdef HAVE_SYS_BUFMOD_H
143 register struct sb_hdr *sbp;
150 struct pcap_pkthdr pkthdr;
155 data.buf = (char *)p->buffer + p->offset;
156 data.maxlen = MAXDLBUF;
159 if (getmsg(p->fd, &ctl, &data, &flags) < 0) {
160 /* Don't choke when we get ptraced */
161 if (errno == EINTR) {
165 strlcpy(p->errbuf, pcap_strerror(errno),
171 bp = p->buffer + p->offset;
175 /* Loop through packets */
176 fcode = p->fcode.bf_insns;
179 #ifdef HAVE_SYS_BUFMOD_H
184 memcpy(sbp, bp, sizeof(*sbp));
187 sbp = (struct sb_hdr *)bp;
188 p->md.stat.ps_drop += sbp->sbh_drops;
189 pk = bp + sizeof(*sbp);
190 bp += sbp->sbh_totlen;
191 origlen = sbp->sbh_origlen;
192 caplen = sbp->sbh_msglen;
195 caplen = min(p->snapshot, cc);
199 ++p->md.stat.ps_recv;
200 if (bpf_filter(fcode, pk, origlen, caplen)) {
201 #ifdef HAVE_SYS_BUFMOD_H
202 pkthdr.ts = sbp->sbh_timestamp;
204 (void)gettimeofday(&pkthdr.ts, NULL);
206 pkthdr.len = origlen;
207 pkthdr.caplen = caplen;
208 /* Insure caplen does not exceed snapshot */
209 if (pkthdr.caplen > p->snapshot)
210 pkthdr.caplen = p->snapshot;
211 (*callback)(user, &pkthdr, pk);
212 if (++n >= cnt && cnt >= 0) {
218 #ifdef HAVE_SYS_BUFMOD_H
226 pcap_open_live(char *device, int snaplen, int promisc, int to_ms, char *ebuf)
232 register dl_info_ack_t *infop;
233 #ifdef HAVE_SYS_BUFMOD_H
234 bpf_u_int32 ss, flag;
236 register char *release;
237 bpf_u_int32 osmajor, osminor, osmicro;
240 bpf_u_int32 buf[MAXDLBUF];
242 #ifndef HAVE_DEV_DLPI
246 p = (pcap_t *)malloc(sizeof(*p));
248 strlcpy(ebuf, pcap_strerror(errno), PCAP_ERRBUF_SIZE);
251 memset(p, 0, sizeof(*p));
255 ** Remove any "/dev/" on the front of the device.
257 cp = strrchr(device, '/');
262 strlcpy(dname, cp, sizeof(dname));
265 * Split the name into a device type and a unit number.
267 cp = strpbrk(dname, "0123456789");
269 snprintf(ebuf, PCAP_ERRBUF_SIZE,
270 "%s missing unit number", device);
273 ppa = strtol(cp, &eos, 10);
275 snprintf(ebuf, PCAP_ERRBUF_SIZE,
276 "%s bad unit number", device);
282 * Use "/dev/dlpi" as the device.
284 * XXX - HP's DLPI Programmer's Guide for HP-UX 11.00 says that
285 * the "dl_mjr_num" field is for the "major number of interface
286 * driver"; that's the major of "/dev/dlpi" on the system on
287 * which I tried this, but there may be DLPI devices that
288 * use a different driver, in which case we may need to
289 * search "/dev" for the appropriate device with that major
290 * device number, rather than hardwiring "/dev/dlpi".
293 if ((p->fd = open(cp, O_RDWR)) < 0) {
294 snprintf(ebuf, PCAP_ERRBUF_SIZE,
295 "%s: %s", cp, pcap_strerror(errno));
300 * Get a table of all PPAs for that device, and search that
301 * table for the specified device type name and unit number.
303 ppa = get_dlpi_ppa(p->fd, dname, ppa, ebuf);
308 ** Determine device and ppa
310 cp = strpbrk(device, "0123456789");
312 snprintf(ebuf, PCAP_ERRBUF_SIZE, "%s missing unit number",
316 ppa = strtol(cp, &eos, 10);
318 snprintf(ebuf, PCAP_ERRBUF_SIZE, "%s bad unit number", device);
323 strlcpy(dname, device, sizeof(dname));
325 snprintf(dname, sizeof(dname), "%s/%s", PCAP_DEV_PREFIX,
328 /* Try device without unit number */
329 strlcpy(dname2, dname, sizeof(dname2));
330 cp = strchr(dname, *cp);
332 if ((p->fd = open(dname, O_RDWR)) < 0) {
333 if (errno != ENOENT) {
334 snprintf(ebuf, PCAP_ERRBUF_SIZE, "%s: %s", dname,
335 pcap_strerror(errno));
339 /* Try again with unit number */
340 if ((p->fd = open(dname2, O_RDWR)) < 0) {
341 snprintf(ebuf, PCAP_ERRBUF_SIZE, "%s: %s", dname2,
342 pcap_strerror(errno));
345 /* XXX Assume unit zero */
350 p->snapshot = snaplen;
353 ** Attach if "style 2" provider
355 if (dlinforeq(p->fd, ebuf) < 0 ||
356 dlinfoack(p->fd, (char *)buf, ebuf) < 0)
358 infop = &((union DL_primitives *)buf)->info_ack;
359 if (infop->dl_provider_style == DL_STYLE2 &&
360 (dlattachreq(p->fd, ppa, ebuf) < 0 ||
361 dlokack(p->fd, "attach", (char *)buf, ebuf) < 0))
364 ** Bind (defer if using HP-UX 9 or HP-UX 10.20, totally skip if
367 #if !defined(HAVE_HPUX9) && !defined(HAVE_HPUX10_20) && !defined(sinix)
369 /* According to IBM's AIX Support Line, the dl_sap value
370 ** should not be less than 0x600 (1536) for standard ethernet
372 if (dlbindreq(p->fd, 1537, ebuf) < 0 ||
374 if (dlbindreq(p->fd, 0, ebuf) < 0 ||
376 dlbindack(p->fd, (char *)buf, ebuf) < 0)
382 ** Enable promiscuous
384 if (dlpromisconreq(p->fd, DL_PROMISC_PHYS, ebuf) < 0 ||
385 dlokack(p->fd, "promisc_phys", (char *)buf, ebuf) < 0)
389 ** Try to enable multicast (you would have thought
390 ** promiscuous would be sufficient). (Skip if using
393 #if !defined(__hpux) && !defined(sinix)
394 if (dlpromisconreq(p->fd, DL_PROMISC_MULTI, ebuf) < 0 ||
395 dlokack(p->fd, "promisc_multi", (char *)buf, ebuf) < 0)
397 "WARNING: DL_PROMISC_MULTI failed (%s)\n", ebuf);
401 ** Try to enable sap (when not in promiscuous mode when using
402 ** using HP-UX and never under SINIX)
409 (dlpromisconreq(p->fd, DL_PROMISC_SAP, ebuf) < 0 ||
410 dlokack(p->fd, "promisc_sap", (char *)buf, ebuf) < 0)) {
411 /* Not fatal if promisc since the DL_PROMISC_PHYS worked */
414 "WARNING: DL_PROMISC_SAP failed (%s)\n", ebuf);
421 ** HP-UX 9 and HP-UX 10.20 must bind after setting promiscuous
424 #if defined(HAVE_HPUX9) || defined(HAVE_HPUX10_20)
425 if (dlbindreq(p->fd, 0, ebuf) < 0 ||
426 dlbindack(p->fd, (char *)buf, ebuf) < 0)
431 ** Determine link type
433 if (dlinforeq(p->fd, ebuf) < 0 ||
434 dlinfoack(p->fd, (char *)buf, ebuf) < 0)
437 infop = &((union DL_primitives *)buf)->info_ack;
438 switch (infop->dl_mac_type) {
442 p->linktype = DLT_EN10MB;
447 p->linktype = DLT_FDDI;
452 snprintf(ebuf, PCAP_ERRBUF_SIZE, "unknown mac type %lu",
459 ** This is a non standard SunOS hack to get the ethernet header.
461 if (strioctl(p->fd, DLIOCRAW, 0, NULL) < 0) {
462 snprintf(ebuf, PCAP_ERRBUF_SIZE, "DLIOCRAW: %s",
463 pcap_strerror(errno));
468 #ifdef HAVE_SYS_BUFMOD_H
470 ** Another non standard call to get the data nicely buffered
472 if (ioctl(p->fd, I_PUSH, "bufmod") != 0) {
473 snprintf(ebuf, PCAP_ERRBUF_SIZE, "I_PUSH bufmod: %s",
474 pcap_strerror(errno));
479 ** Now that the bufmod is pushed lets configure it.
481 ** There is a bug in bufmod(7). When dealing with messages of
482 ** less than snaplen size it strips data from the beginning not
485 ** This bug is supposed to be fixed in 5.3.2. Also, there is a
486 ** patch available. Ask for bugid 1149065.
490 release = get_release(&osmajor, &osminor, &osmicro);
491 if (osmajor == 5 && (osminor <= 2 || (osminor == 3 && osmicro < 2)) &&
492 getenv("BUFMOD_FIXED") == NULL) {
494 "WARNING: bufmod is broken in SunOS %s; ignoring snaplen.\n",
500 strioctl(p->fd, SBIOCSSNAP, sizeof(ss), (char *)&ss) != 0) {
501 snprintf(ebuf, PCAP_ERRBUF_SIZE, "SBIOCSSNAP: %s",
502 pcap_strerror(errno));
507 ** Set up the bufmod flags
509 if (strioctl(p->fd, SBIOCGFLAGS, sizeof(flag), (char *)&flag) < 0) {
510 snprintf(ebuf, PCAP_ERRBUF_SIZE, "SBIOCGFLAGS: %s",
511 pcap_strerror(errno));
515 if (strioctl(p->fd, SBIOCSFLAGS, sizeof(flag), (char *)&flag) != 0) {
516 snprintf(ebuf, PCAP_ERRBUF_SIZE, "SBIOCSFLAGS: %s",
517 pcap_strerror(errno));
521 ** Set up the bufmod timeout
526 to.tv_sec = to_ms / 1000;
527 to.tv_usec = (to_ms * 1000) % 1000000;
528 if (strioctl(p->fd, SBIOCSTIME, sizeof(to), (char *)&to) != 0) {
529 snprintf(ebuf, PCAP_ERRBUF_SIZE, "SBIOCSTIME: %s",
530 pcap_strerror(errno));
537 ** As the last operation flush the read side.
539 if (ioctl(p->fd, I_FLUSH, FLUSHR) != 0) {
540 snprintf(ebuf, PCAP_ERRBUF_SIZE, "FLUSHR: %s",
541 pcap_strerror(errno));
544 /* Allocate data buffer */
545 p->bufsize = MAXDLBUF * sizeof(bpf_u_int32);
546 p->buffer = (u_char *)malloc(p->bufsize + p->offset);
555 pcap_setfilter(pcap_t *p, struct bpf_program *fp)
558 if (install_bpf_program(p, fp) < 0)
564 send_request(int fd, char *ptr, int len, char *what, char *ebuf)
574 if (putmsg(fd, &ctl, (struct strbuf *) NULL, flags) < 0) {
575 snprintf(ebuf, PCAP_ERRBUF_SIZE,
576 "send_request: putmsg \"%s\": %s",
577 what, pcap_strerror(errno));
584 recv_ack(int fd, int size, const char *what, char *bufp, char *ebuf)
586 union DL_primitives *dlp;
590 ctl.maxlen = MAXDLBUF;
595 if (getmsg(fd, &ctl, (struct strbuf*)NULL, &flags) < 0) {
596 snprintf(ebuf, PCAP_ERRBUF_SIZE, "recv_ack: %s getmsg: %s",
597 what, pcap_strerror(errno));
601 dlp = (union DL_primitives *) ctl.buf;
602 switch (dlp->dl_primitive) {
615 switch (dlp->error_ack.dl_errno) {
618 snprintf(ebuf, PCAP_ERRBUF_SIZE,
619 "recv_ack: %s bad ppa (device unit)", what);
624 snprintf(ebuf, PCAP_ERRBUF_SIZE, "recv_ack: %s: %s",
625 what, pcap_strerror(dlp->error_ack.dl_unix_errno));
629 snprintf(ebuf, PCAP_ERRBUF_SIZE,
630 "recv_ack: %s: Service not supplied by provider",
635 snprintf(ebuf, PCAP_ERRBUF_SIZE,
636 "recv_ack: %s error 0x%x",
637 what, (bpf_u_int32)dlp->error_ack.dl_errno);
643 snprintf(ebuf, PCAP_ERRBUF_SIZE,
644 "recv_ack: %s unexpected primitive ack 0x%x ",
645 what, (bpf_u_int32)dlp->dl_primitive);
649 if (ctl.len < size) {
650 snprintf(ebuf, PCAP_ERRBUF_SIZE,
651 "recv_ack: %s ack too small (%d < %d)",
652 what, ctl.len, size);
659 dlattachreq(int fd, bpf_u_int32 ppa, char *ebuf)
663 req.dl_primitive = DL_ATTACH_REQ;
666 return (send_request(fd, (char *)&req, sizeof(req), "attach", ebuf));
670 dlbindreq(int fd, bpf_u_int32 sap, char *ebuf)
675 memset((char *)&req, 0, sizeof(req));
676 req.dl_primitive = DL_BIND_REQ;
678 req.dl_max_conind = 1; /* XXX magic number */
679 /* 22 is INSAP as per the HP-UX DLPI Programmer's Guide */
681 req.dl_service_mode = DL_HP_RAWDLS;
685 req.dl_service_mode = DL_CLDLS;
689 return (send_request(fd, (char *)&req, sizeof(req), "bind", ebuf));
693 dlbindack(int fd, char *bufp, char *ebuf)
696 return (recv_ack(fd, DL_BIND_ACK_SIZE, "bind", bufp, ebuf));
700 dlpromisconreq(int fd, bpf_u_int32 level, char *ebuf)
702 dl_promiscon_req_t req;
704 req.dl_primitive = DL_PROMISCON_REQ;
705 req.dl_level = level;
707 return (send_request(fd, (char *)&req, sizeof(req), "promiscon", ebuf));
711 dlokack(int fd, const char *what, char *bufp, char *ebuf)
714 return (recv_ack(fd, DL_OK_ACK_SIZE, what, bufp, ebuf));
719 dlinforeq(int fd, char *ebuf)
723 req.dl_primitive = DL_INFO_REQ;
725 return (send_request(fd, (char *)&req, sizeof(req), "info", ebuf));
729 dlinfoack(int fd, char *bufp, char *ebuf)
732 return (recv_ack(fd, DL_INFO_ACK_SIZE, "info", bufp, ebuf));
735 #ifdef HAVE_SYS_BUFMOD_H
737 strioctl(int fd, int cmd, int len, char *dp)
746 rc = ioctl(fd, I_STR, &str);
755 #if defined(HAVE_SOLARIS) && defined(HAVE_SYS_BUFMOD_H)
757 get_release(bpf_u_int32 *majorp, bpf_u_int32 *minorp, bpf_u_int32 *microp)
765 if (sysinfo(SI_RELEASE, buf, sizeof(buf)) < 0)
770 *majorp = strtol(cp, &cp, 10);
773 *minorp = strtol(cp, &cp, 10);
776 *microp = strtol(cp, &cp, 10);
781 #ifdef DL_HP_PPA_ACK_OBS
783 * Under HP-UX 10 and HP-UX 11, we can ask for the ppa
788 * Determine ppa number that specifies ifname.
790 * If the "dl_hp_ppa_info_t" doesn't have a "dl_module_id_1" member,
791 * the code that's used here is the old code for HP-UX 10.x.
793 * However, HP-UX 10.20, at least, appears to have such a member
794 * in its "dl_hp_ppa_info_t" structure, so the new code is used.
795 * The new code didn't work on an old 10.20 system on which Rick
796 * Jones of HP tried it, but with later patches installed, it
797 * worked - it appears that the older system had those members but
798 * didn't put anything in them, so, if the search by name fails, we
801 * Rick suggests that making sure your system is "up on the latest
802 * lancommon/DLPI/driver patches" is probably a good idea; it'd fix
803 * that problem, as well as allowing libpcap to see packets sent
804 * from the system on which the libpcap application is being run.
805 * (On 10.20, in addition to getting the latest patches, you need
806 * to turn the kernel "lanc_outbound_promisc_flag" flag on with ADB;
807 * a posting to "comp.sys.hp.hpux" at
809 * http://www.deja.com/[ST_rn=ps]/getdoc.xp?AN=558092266
811 * says that, to see the machine's outgoing traffic, you'd need to
812 * apply the right patches to your system, and also set that variable
815 echo 'lanc_outbound_promisc_flag/W1' | /usr/bin/adb -w /stand/vmunix /dev/kmem
817 * which could be put in, for example, "/sbin/init.d/lan".
819 * Setting the variable is not necessary on HP-UX 11.x.
822 get_dlpi_ppa(register int fd, register const char *device, register int unit,
825 register dl_hp_ppa_ack_t *ap;
826 register dl_hp_ppa_info_t *ipstart, *ip;
829 register u_long majdev;
832 bpf_u_int32 buf[MAXDLBUF];
834 memset((char *)&req, 0, sizeof(req));
835 req.dl_primitive = DL_HP_PPA_REQ;
837 memset((char *)buf, 0, sizeof(buf));
838 if (send_request(fd, (char *)&req, sizeof(req), "hpppa", ebuf) < 0 ||
839 recv_ack(fd, DL_HP_PPA_ACK_SIZE, "hpppa", (char *)buf, ebuf) < 0)
842 ap = (dl_hp_ppa_ack_t *)buf;
843 ipstart = (dl_hp_ppa_info_t *)((u_char *)ap + ap->dl_offset);
846 #ifdef HAVE_HP_PPA_INFO_T_DL_MODULE_ID_1
848 * The "dl_hp_ppa_info_t" structure has a "dl_module_id_1"
849 * member that should, in theory, contain the part of the
850 * name for the device that comes before the unit number,
851 * and should also have a "dl_module_id_2" member that may
852 * contain an alternate name (e.g., I think Ethernet devices
853 * have both "lan", for "lanN", and "snap", for "snapN", with
854 * the former being for Ethernet packets and the latter being
855 * for 802.3/802.2 packets).
857 * Search for the device that has the specified name and
860 for (i = 0; i < ap->dl_count; i++) {
861 if ((strcmp(ip->dl_module_id_1, device) == 0 ||
862 strcmp(ip->dl_module_id_2, device) == 0) &&
863 ip->dl_instance_num == unit)
866 ip = (dl_hp_ppa_info_t *)((u_char *)ipstart + ip->dl_next_offset);
870 * We don't have that member, so the search is impossible; make it
871 * look as if the search failed.
876 if (i == ap->dl_count) {
878 * Well, we didn't, or can't, find the device by name.
880 * HP-UX 10.20, whilst it has "dl_module_id_1" and
881 * "dl_module_id_2" fields in the "dl_hp_ppa_info_t",
882 * doesn't seem to fill them in unless the system is
883 * at a reasonably up-to-date patch level.
885 * Older HP-UX 10.x systems might not have those fields
888 * Therefore, we'll search for the entry with the major
889 * device number of a device with the name "/dev/<dev><unit>",
890 * if such a device exists, as the old code did.
892 snprintf(dname, sizeof(dname), "/dev/%s%d", device, unit);
893 if (stat(dname, &statbuf) < 0) {
894 snprintf(ebuf, PCAP_ERRBUF_SIZE, "stat: %s: %s",
895 dname, pcap_strerror(errno));
898 majdev = major(statbuf.st_rdev);
902 for (i = 0; i < ap->dl_count; i++) {
903 if (ip->dl_mjr_num == majdev &&
904 ip->dl_instance_num == unit)
907 ip = (dl_hp_ppa_info_t *)((u_char *)ipstart + ip->dl_next_offset);
910 if (i == ap->dl_count) {
911 snprintf(ebuf, PCAP_ERRBUF_SIZE,
912 "can't find /dev/dlpi PPA for %s%d", device, unit);
915 if (ip->dl_hdw_state == HDW_DEAD) {
916 snprintf(ebuf, PCAP_ERRBUF_SIZE,
917 "%s%d: hardware state: DOWN\n", device, unit);
920 return ((int)ip->dl_ppa);
926 * Under HP-UX 9, there is no good way to determine the ppa.
927 * So punt and read it from /dev/kmem.
929 static struct nlist nl[] = {
935 static char path_vmunix[] = "/hp-ux";
937 /* Determine ppa number that specifies ifname */
939 get_dlpi_ppa(register int fd, register const char *ifname, register int unit,
942 register const char *cp;
946 char if_name[sizeof(ifnet.if_name) + 1];
948 cp = strrchr(ifname, '/');
951 if (nlist(path_vmunix, &nl) < 0) {
952 snprintf(ebuf, PCAP_ERRBUF_SIZE, "nlist %s failed",
956 if (nl[NL_IFNET].n_value == 0) {
957 snprintf(ebuf, PCAP_ERRBUF_SIZE,
958 "could't find %s kernel symbol",
959 nl[NL_IFNET].n_name);
962 kd = open("/dev/kmem", O_RDONLY);
964 snprintf(ebuf, PCAP_ERRBUF_SIZE, "kmem open: %s",
965 pcap_strerror(errno));
968 if (dlpi_kread(kd, nl[NL_IFNET].n_value,
969 &addr, sizeof(addr), ebuf) < 0) {
973 for (; addr != NULL; addr = ifnet.if_next) {
974 if (dlpi_kread(kd, (off_t)addr,
975 &ifnet, sizeof(ifnet), ebuf) < 0 ||
976 dlpi_kread(kd, (off_t)ifnet.if_name,
977 if_name, sizeof(ifnet.if_name), ebuf) < 0) {
981 if_name[sizeof(ifnet.if_name)] = '\0';
982 if (strcmp(if_name, ifname) == 0 && ifnet.if_unit == unit)
983 return (ifnet.if_index);
986 snprintf(ebuf, PCAP_ERRBUF_SIZE, "Can't find %s", ifname);
991 dlpi_kread(register int fd, register off_t addr,
992 register void *buf, register u_int len, register char *ebuf)
996 if (lseek(fd, addr, SEEK_SET) < 0) {
997 snprintf(ebuf, PCAP_ERRBUF_SIZE, "lseek: %s",
998 pcap_strerror(errno));
1001 cc = read(fd, buf, len);
1003 snprintf(ebuf, PCAP_ERRBUF_SIZE, "read: %s",
1004 pcap_strerror(errno));
1006 } else if (cc != len) {
1007 snprintf(ebuf, PCAP_ERRBUF_SIZE, "short read (%d != %d)", cc,