pcap-dlpi.c
上传用户:tjescc
上传日期:2021-02-23
资源大小:419k
文件大小:19k
源码类别:

Telnet服务器

开发平台:

Unix_Linux

  1. /*
  2.  * Copyright (c) 1993, 1994, 1995, 1996, 1997
  3.  * The Regents of the University of California.  All rights reserved.
  4.  *
  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
  16.  * written permission.
  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.
  20.  *
  21.  * This code contributed by Atanu Ghosh (atanu@cs.ucl.ac.uk),
  22.  * University College London.
  23.  */
  24. /*
  25.  * Packet capture routine for dlpi under SunOS 5
  26.  *
  27.  * Notes:
  28.  *
  29.  *    - Apparently the DLIOCRAW ioctl() is specific to SunOS.
  30.  *
  31.  *    - There is a bug in bufmod(7) such that setting the snapshot
  32.  *      length results in data being left of the front of the packet.
  33.  *
  34.  *    - It might be desirable to use pfmod(7) to filter packets in the
  35.  *      kernel.
  36.  */
  37. #ifndef lint
  38. static const char rcsid[] =
  39.     "@(#) $Header: /usr/local/cvs/nessus-libraries/libpcap-nessus/pcap-dlpi.c,v 1.6.4.1 2007/06/05 13:28:01 renaud Exp $ (LBL)";
  40. #endif
  41. #include <sys/types.h>
  42. #include <sys/time.h>
  43. #ifdef HAVE_SYS_BUFMOD_H
  44. #include <sys/bufmod.h>
  45. #endif
  46. #include <sys/dlpi.h>
  47. #ifdef HAVE_SYS_DLPI_EXT_H
  48. #include <sys/dlpi_ext.h>
  49. #endif
  50. #ifdef HAVE_HPUX9
  51. #include <sys/socket.h>
  52. #endif
  53. #ifdef DL_HP_PPA_ACK_OBS
  54. #include <sys/stat.h>
  55. #endif
  56. #include <sys/stream.h>
  57. #if defined(HAVE_SOLARIS) && defined(HAVE_SYS_BUFMOD_H)
  58. #include <sys/systeminfo.h>
  59. #endif
  60. #ifdef HAVE_HPUX9
  61. #include <net/if.h>
  62. #endif
  63. #include <ctype.h>
  64. #ifdef HAVE_HPUX9
  65. #include <nlist.h>
  66. #endif
  67. #include <errno.h>
  68. #include <fcntl.h>
  69. #include <memory.h>
  70. #include <stdio.h>
  71. #include <stdlib.h>
  72. #include <string.h>
  73. #include <stropts.h>
  74. #include <unistd.h>
  75. #include "pcap-int.h"
  76. #include "gnuc.h"
  77. #ifdef HAVE_OS_PROTO_H
  78. #include "os-proto.h"
  79. #endif
  80. #ifndef PCAP_DEV_PREFIX
  81. #define PCAP_DEV_PREFIX "/dev"
  82. #endif
  83. #define MAXDLBUF 8192
  84. /* Forwards */
  85. static int dlattachreq(int, bpf_u_int32, char *);
  86. static int dlbindack(int, char *, char *);
  87. static int dlbindreq(int, bpf_u_int32, char *);
  88. static int dlinfoack(int, char *, char *);
  89. static int dlinforeq(int, char *);
  90. static int dlokack(int, const char *, char *, char *);
  91. static int recv_ack(int, int, const char *, char *, char *);
  92. static int dlpromisconreq(int, bpf_u_int32, char *);
  93. #if defined(HAVE_SOLARIS) && defined(HAVE_SYS_BUFMOD_H)
  94. static char *get_release(bpf_u_int32 *, bpf_u_int32 *, bpf_u_int32 *);
  95. #endif
  96. static int send_request(int, char *, int, char *, char *);
  97. static int strioctl(int, int, int, char *);
  98. #ifdef HAVE_HPUX9
  99. static int dlpi_kread(int, off_t, void *, u_int, char *);
  100. #endif
  101. #ifdef HAVE_DEV_DLPI
  102. static int get_dlpi_ppa(int, const char *, int, char *);
  103. #endif
  104. int
  105. pcap_stats(pcap_t *p, struct pcap_stat *ps)
  106. {
  107. *ps = p->md.stat;
  108. return (0);
  109. }
  110. /* XXX Needed by HP-UX (at least) */
  111. static bpf_u_int32 ctlbuf[MAXDLBUF];
  112. static struct strbuf ctl = {
  113. MAXDLBUF,
  114. 0,
  115. (char *)ctlbuf
  116. };
  117. int
  118. pcap_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
  119. {
  120. register int cc, n, caplen, origlen;
  121. register u_char *bp, *ep, *pk;
  122. register struct bpf_insn *fcode;
  123. #ifdef HAVE_SYS_BUFMOD_H
  124. register struct sb_hdr *sbp;
  125. #ifdef LBL_ALIGN
  126. struct sb_hdr sbhdr;
  127. #endif
  128. #endif
  129. int flags;
  130. struct strbuf data;
  131. struct pcap_pkthdr pkthdr;
  132. flags = 0;
  133. cc = p->cc;
  134. if (cc == 0) {
  135. data.buf = (char *)p->buffer + p->offset;
  136. data.maxlen = MAXDLBUF;
  137. data.len = 0;
  138. do {
  139. if (getmsg(p->fd, &ctl, &data, &flags) < 0) {
  140. /* Don't choke when we get ptraced */
  141. if (errno == EINTR) {
  142. cc = 0;
  143. continue;
  144. }
  145. strcpy(p->errbuf, pcap_strerror(errno));
  146. return (-1);
  147. }
  148. cc = data.len;
  149. } while (cc == 0);
  150. bp = p->buffer + p->offset;
  151. } else
  152. bp = p->bp;
  153. /* Loop through packets */
  154. fcode = p->fcode.bf_insns;
  155. ep = bp + cc;
  156. n = 0;
  157. #ifdef HAVE_SYS_BUFMOD_H
  158. while (bp < ep) {
  159. #ifdef LBL_ALIGN
  160. if ((long)bp & 3) {
  161. sbp = &sbhdr;
  162. memcpy(sbp, bp, sizeof(*sbp));
  163. } else
  164. #endif
  165. sbp = (struct sb_hdr *)bp;
  166. p->md.stat.ps_drop += sbp->sbh_drops;
  167. pk = bp + sizeof(*sbp);
  168. bp += sbp->sbh_totlen;
  169. origlen = sbp->sbh_origlen;
  170. caplen = sbp->sbh_msglen;
  171. #else
  172. origlen = cc;
  173. caplen = min(p->snapshot, cc);
  174. pk = bp;
  175. bp += caplen;
  176. #endif
  177. ++p->md.stat.ps_recv;
  178. if (bpf_filter(fcode, pk, origlen, caplen)) {
  179. #ifdef HAVE_SYS_BUFMOD_H
  180. pkthdr.ts = sbp->sbh_timestamp;
  181. #else
  182. (void)gettimeofday(&pkthdr.ts, NULL);
  183. #endif
  184. pkthdr.len = origlen;
  185. pkthdr.caplen = caplen;
  186. /* Insure caplen does not exceed snapshot */
  187. if (pkthdr.caplen > p->snapshot)
  188. pkthdr.caplen = p->snapshot;
  189. (*callback)(user, &pkthdr, pk);
  190. if (++n >= cnt && cnt >= 0) {
  191. p->cc = ep - bp;
  192. p->bp = bp;
  193. return (n);
  194. }
  195. }
  196. #ifdef HAVE_SYS_BUFMOD_H
  197. }
  198. #endif
  199. p->cc = 0;
  200. return (n);
  201. }
  202. pcap_t *
  203. pcap_open_live(char *device, int snaplen, int promisc, int to_ms, char *ebuf)
  204. {
  205. register char *cp;
  206. char *eos;
  207. register pcap_t *p;
  208. register int ppa;
  209. register dl_info_ack_t *infop;
  210. #ifdef HAVE_SYS_BUFMOD_H
  211. bpf_u_int32 ss, flag;
  212. #ifdef HAVE_SOLARIS
  213. register char *release;
  214. bpf_u_int32 osmajor, osminor, osmicro;
  215. #endif
  216. #endif
  217. bpf_u_int32 buf[MAXDLBUF];
  218. char dname[100];
  219. #ifndef HAVE_DEV_DLPI
  220. char dname2[100];
  221. #endif
  222. p = (pcap_t *)malloc(sizeof(*p));
  223. if (p == NULL) {
  224. strcpy(ebuf, pcap_strerror(errno));
  225. return (NULL);
  226. }
  227. memset(p, 0, sizeof(*p));
  228. p->fd = -1;
  229. /*
  230. ** Determine device and ppa
  231. */
  232. cp = device + strlen(device) - 1;
  233.         if ( *cp < '0' || *cp > '9' ) {
  234. sprintf(ebuf, "%s missing unit number", device);
  235. goto bad;
  236. }
  237.         while ( cp - 1 >= device && *(cp - 1) >= '0' && *(cp - 1) <= '9' )
  238. cp--;
  239. ppa = strtol(cp, &eos, 10);
  240. if (*eos != '') {
  241. sprintf(ebuf, "%s bad unit number", device);
  242. goto bad;
  243. }
  244. if (*device == '/')
  245. strcpy(dname, device);
  246. else
  247. sprintf(dname, "%s/%s", PCAP_DEV_PREFIX, device);
  248. #ifdef HAVE_DEV_DLPI
  249. /* Map network device to /dev/dlpi unit */
  250. cp = "/dev/dlpi";
  251. if ((p->fd = open(cp, O_RDWR)) < 0) {
  252. sprintf(ebuf, "%s: %s", cp, pcap_strerror(errno));
  253. goto bad;
  254. }
  255. /* Map network interface to /dev/dlpi unit */
  256. ppa = get_dlpi_ppa(p->fd, dname, ppa, ebuf);
  257. if (ppa < 0)
  258. goto bad;
  259. #else
  260. /* Try device without unit number */
  261. strcpy(dname2, dname);
  262. cp = strchr(dname, *cp);
  263. *cp = '';
  264. if ((p->fd = open(dname, O_RDWR)) < 0) {
  265. if (errno != ENOENT) {
  266. sprintf(ebuf, "%s: %s", dname, pcap_strerror(errno));
  267. goto bad;
  268. }
  269. /* Try again with unit number */
  270. if ((p->fd = open(dname2, O_RDWR)) < 0) {
  271. sprintf(ebuf, "%s: %s", dname2, pcap_strerror(errno));
  272. goto bad;
  273. }
  274. /* XXX Assume unit zero */
  275. ppa = 0;
  276. }
  277. #endif
  278. p->snapshot = snaplen;
  279. /*
  280. ** Attach if "style 2" provider
  281. */
  282. if (dlinforeq(p->fd, ebuf) < 0 ||
  283.     dlinfoack(p->fd, (char *)buf, ebuf) < 0)
  284. goto bad;
  285. infop = &((union DL_primitives *)buf)->info_ack;
  286. if (infop->dl_provider_style == DL_STYLE2 &&
  287.     (dlattachreq(p->fd, ppa, ebuf) < 0 ||
  288.     dlokack(p->fd, "attach", (char *)buf, ebuf) < 0))
  289. goto bad;
  290. /*
  291. ** Bind (defer if using HP-UX 9 or HP-UX 10.20, totally skip if
  292. ** using SINIX)
  293. */
  294. #if !defined(HAVE_HPUX9) && !defined(HAVE_HPUX10_20) && !defined(sinix)
  295. if (dlbindreq(p->fd, 0, ebuf) < 0 ||
  296.     dlbindack(p->fd, (char *)buf, ebuf) < 0)
  297. goto bad;
  298. #endif
  299. if (promisc) {
  300. /*
  301. ** Enable promiscuous
  302. */
  303. if (dlpromisconreq(p->fd, DL_PROMISC_PHYS, ebuf) < 0 ||
  304.     dlokack(p->fd, "promisc_phys", (char *)buf, ebuf) < 0)
  305. goto bad;
  306. /*
  307. ** Try to enable multicast (you would have thought
  308. ** promiscuous would be sufficient). (Skip if using
  309. ** HP-UX or SINIX)
  310. */
  311. #if !defined(__hpux) && !defined(sinix)
  312. if (dlpromisconreq(p->fd, DL_PROMISC_MULTI, ebuf) < 0 ||
  313.     dlokack(p->fd, "promisc_multi", (char *)buf, ebuf) < 0)
  314. fprintf(stderr,
  315.     "WARNING: DL_PROMISC_MULTI failed (%s)n", ebuf);
  316. #endif
  317. }
  318. /*
  319. ** Try to enable sap (when not in promiscuous mode when using
  320. ** using HP-UX and never under SINIX)
  321. */
  322. #ifndef sinix
  323. if (
  324. #ifdef __hpux
  325.     !promisc &&
  326. #endif
  327.     (dlpromisconreq(p->fd, DL_PROMISC_SAP, ebuf) < 0 ||
  328.     dlokack(p->fd, "promisc_sap", (char *)buf, ebuf) < 0)) {
  329. /* Not fatal if promisc since the DL_PROMISC_PHYS worked */
  330. if (promisc)
  331. fprintf(stderr,
  332.     "WARNING: DL_PROMISC_SAP failed (%s)n", ebuf);
  333. else
  334. goto bad;
  335. }
  336. #endif
  337. /*
  338. ** HP-UX 9 and HP-UX 10.20 must bind after setting promiscuous
  339. ** options)
  340. */
  341. #if defined(HAVE_HPUX9) || defined(HAVE_HPUX10_20)
  342. if (dlbindreq(p->fd, 0, ebuf) < 0 ||
  343.     dlbindack(p->fd, (char *)buf, ebuf) < 0)
  344. goto bad;
  345. #endif
  346. /*
  347. ** Determine link type
  348. */
  349. if (dlinforeq(p->fd, ebuf) < 0 ||
  350.     dlinfoack(p->fd, (char *)buf, ebuf) < 0)
  351. goto bad;
  352. infop = &((union DL_primitives *)buf)->info_ack;
  353. switch (infop->dl_mac_type) {
  354. case DL_CSMACD:
  355. case DL_ETHER:
  356. p->linktype = DLT_EN10MB;
  357. p->offset = 2;
  358. break;
  359. case DL_FDDI:
  360. p->linktype = DLT_FDDI;
  361. p->offset = 3;
  362. break;
  363. default:
  364. sprintf(ebuf, "unknown mac type 0x%lu", infop->dl_mac_type);
  365. goto bad;
  366. }
  367. #ifdef DLIOCRAW
  368. /*
  369. ** This is a non standard SunOS hack to get the ethernet header.
  370. */
  371. if (strioctl(p->fd, DLIOCRAW, 0, NULL) < 0) {
  372. sprintf(ebuf, "DLIOCRAW: %s", pcap_strerror(errno));
  373. goto bad;
  374. }
  375. #endif
  376. #ifdef HAVE_SYS_BUFMOD_H
  377. /*
  378. ** Another non standard call to get the data nicely buffered
  379. */
  380. if (ioctl(p->fd, I_PUSH, "bufmod") != 0) {
  381. sprintf(ebuf, "I_PUSH bufmod: %s", pcap_strerror(errno));
  382. goto bad;
  383. }
  384. /*
  385. ** Now that the bufmod is pushed lets configure it.
  386. **
  387. ** There is a bug in bufmod(7). When dealing with messages of
  388. ** less than snaplen size it strips data from the beginning not
  389. ** the end.
  390. **
  391. ** This bug is supposed to be fixed in 5.3.2. Also, there is a
  392. ** patch available. Ask for bugid 1149065.
  393. */
  394. ss = snaplen;
  395. #ifdef HAVE_SOLARIS
  396. release = get_release(&osmajor, &osminor, &osmicro);
  397. if (osmajor == 5 && (osminor <= 2 || (osminor == 3 && osmicro < 2)) &&
  398.     getenv("BUFMOD_FIXED") == NULL) {
  399. fprintf(stderr,
  400. "WARNING: bufmod is broken in SunOS %s; ignoring snaplen.n",
  401.     release);
  402. ss = 0;
  403. }
  404. #endif
  405. if (ss > 0 &&
  406.     strioctl(p->fd, SBIOCSSNAP, sizeof(ss), (char *)&ss) != 0) {
  407. sprintf(ebuf, "SBIOCSSNAP: %s", pcap_strerror(errno));
  408. goto bad;
  409. }
  410. /*
  411. ** Set up the bufmod flags
  412. */
  413. if (strioctl(p->fd, SBIOCGFLAGS, sizeof(flag), (char *)&flag) < 0) {
  414. sprintf(ebuf, "SBIOCGFLAGS: %s", pcap_strerror(errno));
  415. goto bad;
  416. }
  417. flag |= SB_NO_DROPS;
  418. if (strioctl(p->fd, SBIOCSFLAGS, sizeof(flag), (char *)&flag) != 0) {
  419. sprintf(ebuf, "SBIOCSFLAGS: %s", pcap_strerror(errno));
  420. goto bad;
  421. }
  422. /*
  423. ** Set up the bufmod timeout
  424. */
  425. if (to_ms != 0) {
  426. struct timeval to;
  427. to.tv_sec = to_ms / 1000;
  428. to.tv_usec = (to_ms * 1000) % 1000000;
  429. if (strioctl(p->fd, SBIOCSTIME, sizeof(to), (char *)&to) != 0) {
  430. sprintf(ebuf, "SBIOCSTIME: %s", pcap_strerror(errno));
  431. goto bad;
  432. }
  433. }
  434. #endif
  435. /*
  436. ** As the last operation flush the read side.
  437. */
  438. if (ioctl(p->fd, I_FLUSH, FLUSHR) != 0) {
  439. sprintf(ebuf, "FLUSHR: %s", pcap_strerror(errno));
  440. goto bad;
  441. }
  442. /* Allocate data buffer */
  443. p->bufsize = MAXDLBUF * sizeof(bpf_u_int32);
  444. p->buffer = (u_char *)malloc(p->bufsize + p->offset);
  445. return (p);
  446. bad:
  447. if(p->fd >= 0)close(p->fd);
  448. free(p);
  449. return (NULL);
  450. }
  451. int
  452. pcap_setfilter(pcap_t *p, struct bpf_program *fp)
  453. {
  454. p->fcode = *fp;
  455. return (0);
  456. }
  457. static int
  458. send_request(int fd, char *ptr, int len, char *what, char *ebuf)
  459. {
  460. struct strbuf ctl;
  461. int flags;
  462. ctl.maxlen = 0;
  463. ctl.len = len;
  464. ctl.buf = ptr;
  465. flags = 0;
  466. if (putmsg(fd, &ctl, (struct strbuf *) NULL, flags) < 0) {
  467. sprintf(ebuf, "send_request: putmsg "%s": %s",
  468.     what, pcap_strerror(errno));
  469. return (-1);
  470. }
  471. return (0);
  472. }
  473. static int
  474. recv_ack(int fd, int size, const char *what, char *bufp, char *ebuf)
  475. {
  476. union DL_primitives *dlp;
  477. struct strbuf ctl;
  478. int flags;
  479. ctl.maxlen = MAXDLBUF;
  480. ctl.len = 0;
  481. ctl.buf = bufp;
  482. flags = 0;
  483. if (getmsg(fd, &ctl, (struct strbuf*)NULL, &flags) < 0) {
  484. sprintf(ebuf, "recv_ack: %s getmsg: %s",
  485.     what, pcap_strerror(errno));
  486. return (-1);
  487. }
  488. dlp = (union DL_primitives *) ctl.buf;
  489. switch (dlp->dl_primitive) {
  490. case DL_INFO_ACK:
  491. case DL_BIND_ACK:
  492. case DL_OK_ACK:
  493. #ifdef DL_HP_PPA_ACK
  494. case DL_HP_PPA_ACK:
  495. #endif
  496. /* These are OK */
  497. break;
  498. case DL_ERROR_ACK:
  499. switch (dlp->error_ack.dl_errno) {
  500. case DL_BADPPA:
  501. sprintf(ebuf, "recv_ack: %s bad ppa (device unit)",
  502.     what);
  503. break;
  504. case DL_SYSERR:
  505. sprintf(ebuf, "recv_ack: %s: %s",
  506.     what, pcap_strerror(dlp->error_ack.dl_unix_errno));
  507. break;
  508. case DL_UNSUPPORTED:
  509. sprintf(ebuf,
  510.     "recv_ack: %s: Service not supplied by provider",
  511.     what);
  512. break;
  513. default:
  514. sprintf(ebuf, "recv_ack: %s error 0x%x",
  515.     what, (bpf_u_int32)dlp->error_ack.dl_errno);
  516. break;
  517. }
  518. return (-1);
  519. default:
  520. sprintf(ebuf, "recv_ack: %s unexpected primitive ack 0x%x ",
  521.     what, (bpf_u_int32)dlp->dl_primitive);
  522. return (-1);
  523. }
  524. if (ctl.len < size) {
  525. sprintf(ebuf, "recv_ack: %s ack too small (%d < %d)",
  526.     what, ctl.len, size);
  527. return (-1);
  528. }
  529. return (ctl.len);
  530. }
  531. static int
  532. dlattachreq(int fd, bpf_u_int32 ppa, char *ebuf)
  533. {
  534. dl_attach_req_t req;
  535. req.dl_primitive = DL_ATTACH_REQ;
  536. req.dl_ppa = ppa;
  537. return (send_request(fd, (char *)&req, sizeof(req), "attach", ebuf));
  538. }
  539. static int
  540. dlbindreq(int fd, bpf_u_int32 sap, char *ebuf)
  541. {
  542. dl_bind_req_t req;
  543. memset((char *)&req, 0, sizeof(req));
  544. req.dl_primitive = DL_BIND_REQ;
  545. #ifdef DL_HP_RAWDLS
  546. req.dl_max_conind = 1; /* XXX magic number */
  547. /* 22 is INSAP as per the HP-UX DLPI Programmer's Guide */
  548. req.dl_sap = 22;
  549. req.dl_service_mode = DL_HP_RAWDLS;
  550. #else
  551. req.dl_sap = sap;
  552. #ifdef DL_CLDLS
  553. req.dl_service_mode = DL_CLDLS;
  554. #endif
  555. #endif
  556. return (send_request(fd, (char *)&req, sizeof(req), "bind", ebuf));
  557. }
  558. static int
  559. dlbindack(int fd, char *bufp, char *ebuf)
  560. {
  561. return (recv_ack(fd, DL_BIND_ACK_SIZE, "bind", bufp, ebuf));
  562. }
  563. static int
  564. dlpromisconreq(int fd, bpf_u_int32 level, char *ebuf)
  565. {
  566. dl_promiscon_req_t req;
  567. req.dl_primitive = DL_PROMISCON_REQ;
  568. req.dl_level = level;
  569. return (send_request(fd, (char *)&req, sizeof(req), "promiscon", ebuf));
  570. }
  571. static int
  572. dlokack(int fd, const char *what, char *bufp, char *ebuf)
  573. {
  574. return (recv_ack(fd, DL_OK_ACK_SIZE, what, bufp, ebuf));
  575. }
  576. static int
  577. dlinforeq(int fd, char *ebuf)
  578. {
  579. dl_info_req_t req;
  580. req.dl_primitive = DL_INFO_REQ;
  581. return (send_request(fd, (char *)&req, sizeof(req), "info", ebuf));
  582. }
  583. static int
  584. dlinfoack(int fd, char *bufp, char *ebuf)
  585. {
  586. return (recv_ack(fd, DL_INFO_ACK_SIZE, "info", bufp, ebuf));
  587. }
  588. static int
  589. strioctl(int fd, int cmd, int len, char *dp)
  590. {
  591. struct strioctl str;
  592. int rc;
  593. str.ic_cmd = cmd;
  594. str.ic_timout = -1;
  595. str.ic_len = len;
  596. str.ic_dp = dp;
  597. rc = ioctl(fd, I_STR, &str);
  598. if (rc < 0)
  599. return (rc);
  600. else
  601. return (str.ic_len);
  602. }
  603. #if defined(HAVE_SOLARIS) && defined(HAVE_SYS_BUFMOD_H)
  604. static char *
  605. get_release(bpf_u_int32 *majorp, bpf_u_int32 *minorp, bpf_u_int32 *microp)
  606. {
  607. char *cp;
  608. static char buf[32];
  609. *majorp = 0;
  610. *minorp = 0;
  611. *microp = 0;
  612. if (sysinfo(SI_RELEASE, buf, sizeof(buf)) < 0)
  613. return ("?");
  614. cp = buf;
  615. if (!isdigit(*cp))
  616. return (buf);
  617. *majorp = strtol(cp, &cp, 10);
  618. if (*cp++ != '.')
  619. return (buf);
  620. *minorp =  strtol(cp, &cp, 10);
  621. if (*cp++ != '.')
  622. return (buf);
  623. *microp =  strtol(cp, &cp, 10);
  624. return (buf);
  625. }
  626. #endif
  627. #ifdef DL_HP_PPA_ACK_OBS
  628. /*
  629.  * Under HP-UX 10, we can ask for the ppa
  630.  */
  631. /* Determine ppa number that specifies ifname */
  632. static int
  633. get_dlpi_ppa(register int fd, register const char *device, register int unit,
  634.     register char *ebuf)
  635. {
  636. register dl_hp_ppa_ack_t *ap;
  637. register dl_hp_ppa_info_t *ip;
  638. register int i;
  639. register u_long majdev;
  640. dl_hp_ppa_req_t req;
  641. struct stat statbuf;
  642. bpf_u_int32 buf[MAXDLBUF];
  643. if (stat(device, &statbuf) < 0) {
  644. sprintf(ebuf, "stat: %s: %s", device, pcap_strerror(errno));
  645. return (-1);
  646. }
  647. majdev = major(statbuf.st_rdev);
  648. memset((char *)&req, 0, sizeof(req));
  649. req.dl_primitive = DL_HP_PPA_REQ;
  650. memset((char *)buf, 0, sizeof(buf));
  651. if (send_request(fd, (char *)&req, sizeof(req), "hpppa", ebuf) < 0 ||
  652.     recv_ack(fd, DL_HP_PPA_ACK_SIZE, "hpppa", (char *)buf, ebuf) < 0)
  653. return (-1);
  654. ap = (dl_hp_ppa_ack_t *)buf;
  655. ip = (dl_hp_ppa_info_t *)((u_char *)ap + ap->dl_offset);
  656.         for(i = 0; i < ap->dl_count; i++) {
  657.                 if (ip->dl_mjr_num == majdev && ip->dl_instance_num == unit)
  658.                         break;
  659.                 ip = (dl_hp_ppa_info_t *)((u_char *)ip + ip->dl_next_offset);
  660.         }
  661.         if (i == ap->dl_count) {
  662.                 sprintf(ebuf, "can't find PPA for %s", device);
  663. return (-1);
  664.         }
  665.         if (ip->dl_hdw_state == HDW_DEAD) {
  666.                 sprintf(ebuf, "%s: hardware state: DOWNn", device);
  667. return (-1);
  668.         }
  669.         return ((int)ip->dl_ppa);
  670. }
  671. #endif
  672. #ifdef HAVE_HPUX9
  673. /*
  674.  * Under HP-UX 9, there is no good way to determine the ppa.
  675.  * So punt and read it from /dev/kmem.
  676.  */
  677. static struct nlist nl[] = {
  678. #define NL_IFNET 0
  679. { "ifnet" },
  680. { "" }
  681. };
  682. static char path_vmunix[] = "/hp-ux";
  683. /* Determine ppa number that specifies ifname */
  684. static int
  685. get_dlpi_ppa(register int fd, register const char *ifname, register int unit,
  686.     register char *ebuf)
  687. {
  688. register const char *cp;
  689. register int kd;
  690. void *addr;
  691. struct ifnet ifnet;
  692. char if_name[sizeof(ifnet.if_name)], tifname[32];
  693. cp = strrchr(ifname, '/');
  694. if (cp != NULL)
  695. ifname = cp + 1;
  696. if (nlist(path_vmunix, &nl) < 0) {
  697. sprintf(ebuf, "nlist %s failed", path_vmunix);
  698. return (-1);
  699. }
  700. if (nl[NL_IFNET].n_value == 0) {
  701. sprintf(ebuf, "could't find %s kernel symbol",
  702.     nl[NL_IFNET].n_name);
  703. return (-1);
  704. }
  705. kd = open("/dev/kmem", O_RDONLY);
  706. if (kd < 0) {
  707. sprintf(ebuf, "kmem open: %s", pcap_strerror(errno));
  708. return (-1);
  709. }
  710. if (dlpi_kread(kd, nl[NL_IFNET].n_value,
  711.     &addr, sizeof(addr), ebuf) < 0) {
  712. close(kd);
  713. return (-1);
  714. }
  715. for (; addr != NULL; addr = ifnet.if_next) {
  716. if (dlpi_kread(kd, (off_t)addr,
  717.     &ifnet, sizeof(ifnet), ebuf) < 0 ||
  718.     dlpi_kread(kd, (off_t)ifnet.if_name,
  719.     if_name, sizeof(if_name), ebuf) < 0) {
  720. (void)close(kd);
  721. return (-1);
  722. }
  723. sprintf(tifname, "%.*s%d",
  724.     (int)sizeof(if_name), if_name, ifnet.if_unit);
  725. if (strcmp(tifname, ifname) == 0)
  726. return (ifnet.if_index);
  727. }
  728. sprintf(ebuf, "Can't find %s", ifname);
  729. return (-1);
  730. }
  731. static int
  732. dlpi_kread(register int fd, register off_t addr,
  733.     register void *buf, register u_int len, register char *ebuf)
  734. {
  735. register int cc;
  736. if (lseek(fd, addr, SEEK_SET) < 0) {
  737. sprintf(ebuf, "lseek: %s", pcap_strerror(errno));
  738. return (-1);
  739. }
  740. cc = read(fd, buf, len);
  741. if (cc < 0) {
  742. sprintf(ebuf, "read: %s", pcap_strerror(errno));
  743. return (-1);
  744. } else if (cc != len) {
  745. sprintf(ebuf, "short read (%d != %d)", cc, len);
  746. return (-1);
  747. }
  748. return (cc);
  749. }
  750. #endif