pcap_t *pfq_create(const char *device, char *ebuf, size_t size) { pcap_t *p; p = pcap_create_common(device, ebuf, size); if (p == NULL) return NULL; p->activate_op = pfq_activate_linux; return p; }
pcap_t * usb_create(const char *device, char *ebuf) { pcap_t *p; p = pcap_create_common(device, ebuf); if (p == NULL) return (NULL); p->activate_op = usb_activate; return (p); }
pcap_t * pcap_create_interface(const char *device, char *ebuf) { pcap_t *p; p = pcap_create_common(device, ebuf, sizeof (struct pcap_nit)); if (p == NULL) return (NULL); p->activate_op = pcap_activate_nit; return (p); }
pcap_t * rdmasniff_create(const char *device, char *ebuf, int *is_ours) { struct pcap_rdmasniff *priv; struct ibv_device **dev_list; int numdev; size_t namelen; const char *port; unsigned long port_num; int i; pcap_t *p = NULL; *is_ours = 0; dev_list = ibv_get_device_list(&numdev); if (!dev_list || !numdev) { return NULL; } namelen = strlen(device); port = strchr(device, ':'); if (port) { port_num = strtoul(port + 1, NULL, 10); if (port_num > 0) { namelen = port - device; } else { port_num = 1; } } else { port_num = 1; } for (i = 0; i < numdev; ++i) { if (strlen(dev_list[i]->name) == namelen && !strncmp(device, dev_list[i]->name, namelen)) { *is_ours = 1; p = pcap_create_common(ebuf, sizeof (struct pcap_rdmasniff)); if (p) { p->activate_op = rdmasniff_activate; priv = p->priv; priv->rdma_device = dev_list[i]; priv->port_num = port_num; } break; } } ibv_free_device_list(dev_list); return p; }
pcap_t * canusb_create(const char *device, char *ebuf, int *is_ours) { const char *cp; char *cpend; long devnum; pcap_t* p; struct pcap_canusb *canusb; /* Does this look like a DAG device? */ cp = strrchr(device, '/'); if (cp == NULL) cp = device; /* Does it begin with "canusb"? */ if (strncmp(cp, "canusb", 6) != 0) { /* Nope, doesn't begin with "canusb" */ *is_ours = 0; return NULL; } /* Yes - is "canusb" followed by a number? */ cp += 6; devnum = strtol(cp, &cpend, 10); if (cpend == cp || *cpend != '\0') { /* Not followed by a number. */ *is_ours = 0; return NULL; } if (devnum < 0) { /* Followed by a non-valid number. */ *is_ours = 0; return NULL; } /* OK, it's probably ours. */ *is_ours = 1; p = pcap_create_common(device, ebuf, sizeof (struct pcap_canusb)); if (p == NULL) return (NULL); canusb = p->priv; canusb->ctx = NULL; canusb->dev = NULL; canusb->rdpipe = -1; canusb->wrpipe = -1; p->activate_op = canusb_activate; return (p); }
pcap_t * can_create(const char *device, char *ebuf, int *is_ours) { const char *cp; char *cpend; long devnum; pcap_t* p; /* Does this look like a CANbus device? */ cp = strrchr(device, '/'); if (cp == NULL) cp = device; /* Does it begin with "can" or "vcan"? */ if (strncmp(cp, "can", 3) == 0) { /* Begins with "can" */ cp += 3; /* skip past "can" */ } else if (strncmp(cp, "vcan", 4) == 0) { /* Begins with "vcan" */ cp += 4; } else { /* Nope, doesn't begin with "can" or "vcan" */ *is_ours = 0; return NULL; } /* Yes - is "can" or "vcan" followed by a number from 0? */ devnum = strtol(cp, &cpend, 10); if (cpend == cp || *cpend != '\0') { /* Not followed by a number. */ *is_ours = 0; return NULL; } if (devnum < 0) { /* Followed by a non-valid number. */ *is_ours = 0; return NULL; } /* OK, it's probably ours. */ *is_ours = 1; p = pcap_create_common(device, ebuf, sizeof (struct pcap_can)); if (p == NULL) return (NULL); p->activate_op = can_activate; return (p); }
pcap_t * snf_create(const char *device, char *ebuf) { pcap_t *p; int boardnum = -1; struct snf_ifaddrs *ifaddrs, *ifa; size_t devlen; if (snf_init(SNF_VERSION_API)) return NULL; /* * Match a given interface name to our list of interface names, from * which we can obtain the intended board number */ if (snf_getifaddrs(&ifaddrs) || ifaddrs == NULL) return NULL; devlen = strlen(device) + 1; ifa = ifaddrs; while (ifa) { if (!strncmp(device, ifa->snf_ifa_name, devlen)) { boardnum = ifa->snf_ifa_boardnum; break; } ifa = ifa->snf_ifa_next; } snf_freeifaddrs(ifaddrs); if (ifa == NULL) { /* * If we can't find the device by name, support the name "snfX" * and "snf10gX" where X is the board number. */ if (sscanf(device, "snf10g%d", &boardnum) != 1 && sscanf(device, "snf%d", &boardnum) != 1) return NULL; } p = pcap_create_common(device, ebuf); if (p == NULL) return NULL; p->activate_op = snf_activate; p->md.snf_boardnum = boardnum; return p; }
pcap_t * usb_create(const char *device, char *ebuf, int *is_ours) { const char *cp; char *cpend; long devnum; pcap_t *p; /* Does this look like a USB monitoring device? */ cp = strrchr(device, '/'); if (cp == NULL) cp = device; /* Does it begin with USB_IFACE? */ if (strncmp(cp, USB_IFACE, sizeof USB_IFACE - 1) != 0) { /* Nope, doesn't begin with USB_IFACE */ *is_ours = 0; return NULL; } /* Yes - is USB_IFACE followed by a number? */ cp += sizeof USB_IFACE - 1; devnum = strtol(cp, &cpend, 10); if (cpend == cp || *cpend != '\0') { /* Not followed by a number. */ *is_ours = 0; return NULL; } if (devnum < 0) { /* Followed by a non-valid number. */ *is_ours = 0; return NULL; } /* OK, it's probably ours. */ *is_ours = 1; p = pcap_create_common(device, ebuf, sizeof (struct pcap_usb_linux)); if (p == NULL) return (NULL); p->activate_op = usb_activate; return (p); }
pcap_t * pcap_create_interface(const char *device, char *ebuf) { pcap_t *p; #ifdef DL_HP_RAWDLS struct pcap_dlpi *pd; #endif p = pcap_create_common(device, ebuf, sizeof (struct pcap_dlpi)); if (p == NULL) return (NULL); #ifdef DL_HP_RAWDLS pd = p->priv; pd->send_fd = -1; /* it hasn't been opened yet */ #endif p->activate_op = pcap_activate_dlpi; return (p); }
pcap_t * dbus_create(const char *device, char *ebuf, int *is_ours) { pcap_t *p; if (strcmp(device, "dbus-system") && strcmp(device, "dbus-session") && strncmp(device, "dbus://", 7)) { *is_ours = 0; return NULL; } *is_ours = 1; p = pcap_create_common(device, ebuf, sizeof (struct pcap_dbus)); if (p == NULL) return (NULL); p->activate_op = dbus_activate; return (p); }
static inline struct timeval snf_timestamp_to_timeval(const int64_t ts_nanosec) { struct timeval tv; int32_t rem; if (ts_nanosec == 0) return (struct timeval) { 0, 0 }; tv.tv_sec = ts_nanosec / _NSEC_PER_SEC; tv.tv_usec = (ts_nanosec % _NSEC_PER_SEC) / 1000; return tv; } static int snf_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user) { struct pcap_snf *ps = p->priv; struct pcap_pkthdr hdr; int i, flags, err, caplen, n; struct snf_recv_req req; if (!p || cnt == 0) return -1; n = 0; while (n < cnt || PACKET_COUNT_IS_UNLIMITED(cnt)) { /* * Has "pcap_breakloop()" been called? */ if (p->break_loop) { if (n == 0) { p->break_loop = 0; return (-2); } else { return (n); } } err = snf_ring_recv(ps->snf_ring, ps->snf_timeout, &req); if (err) { if (err == EBUSY || err == EAGAIN) return (0); if (err == EINTR) continue; if (err != 0) { snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snf_read: %s", pcap_strerror(err)); return -1; } } caplen = req.length; if (caplen > p->snapshot) caplen = p->snapshot; if ((p->fcode.bf_insns == NULL) || bpf_filter(p->fcode.bf_insns, req.pkt_addr, req.length, caplen)) { hdr.ts = snf_timestamp_to_timeval(req.timestamp); hdr.caplen = caplen; hdr.len = req.length; callback(user, &hdr, req.pkt_addr); } n++; } return (n); } static int snf_setfilter(pcap_t *p, struct bpf_program *fp) { if (!p) return -1; if (!fp) { strncpy(p->errbuf, "setfilter: No filter specified", sizeof(p->errbuf)); return -1; } /* Make our private copy of the filter */ if (install_bpf_program(p, fp) < 0) return -1; return (0); } static int snf_inject(pcap_t *p, const void *buf _U_, size_t size _U_) { strlcpy(p->errbuf, "Sending packets isn't supported with snf", PCAP_ERRBUF_SIZE); return (-1); } static int snf_activate(pcap_t* p) { struct pcap_snf *ps = p->priv; char *device = p->opt.source; const char *nr = NULL; int err; int flags = 0; if (device == NULL) { snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "device is NULL: %s", pcap_strerror(errno)); return -1; } /* In Libpcap, we set pshared by default if NUM_RINGS is set to > 1. * Since libpcap isn't thread-safe */ if ((nr = getenv("SNF_NUM_RINGS")) && *nr && atoi(nr) > 1) flags |= SNF_F_PSHARED; else nr = NULL; err = snf_open(ps->snf_boardnum, 0, /* let SNF API parse SNF_NUM_RINGS, if set */ NULL, /* default RSS, or use SNF_RSS_FLAGS env */ 0, /* default to SNF_DATARING_SIZE from env */ flags, /* may want pshared */ &ps->snf_handle); if (err != 0) { snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snf_open failed: %s", pcap_strerror(err)); return -1; } err = snf_ring_open(ps->snf_handle, &ps->snf_ring); if (err != 0) { snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snf_ring_open failed: %s", pcap_strerror(err)); return -1; } if (p->opt.timeout <= 0) ps->snf_timeout = -1; else ps->snf_timeout = p->opt.timeout; err = snf_start(ps->snf_handle); if (err != 0) { snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snf_start failed: %s", pcap_strerror(err)); return -1; } /* * "select()" and "poll()" don't work on snf descriptors. */ p->selectable_fd = -1; p->linktype = DLT_EN10MB; p->read_op = snf_read; p->inject_op = snf_inject; p->setfilter_op = snf_setfilter; p->setdirection_op = NULL; /* Not implemented.*/ p->set_datalink_op = snf_set_datalink; p->getnonblock_op = snf_getnonblock; p->setnonblock_op = snf_setnonblock; p->stats_op = snf_pcap_stats; p->cleanup_op = snf_platform_cleanup; return 0; } int snf_findalldevs(pcap_if_t **devlistp, char *errbuf) { /* * There are no platform-specific devices since each device * exists as a regular Ethernet device. */ return 0; } pcap_t * snf_create(const char *device, char *ebuf, int *is_ours) { pcap_t *p; int boardnum = -1; struct snf_ifaddrs *ifaddrs, *ifa; size_t devlen; struct pcap_snf *ps; if (snf_init(SNF_VERSION_API)) { /* Can't initialize the API, so no SNF devices */ *is_ours = 0; return NULL; } /* * Match a given interface name to our list of interface names, from * which we can obtain the intended board number */ if (snf_getifaddrs(&ifaddrs) || ifaddrs == NULL) { /* Can't get SNF addresses */ *is_ours = 0; return NULL; } devlen = strlen(device) + 1; ifa = ifaddrs; while (ifa) { if (!strncmp(device, ifa->snf_ifa_name, devlen)) { boardnum = ifa->snf_ifa_boardnum; break; } ifa = ifa->snf_ifa_next; } snf_freeifaddrs(ifaddrs); if (ifa == NULL) { /* * If we can't find the device by name, support the name "snfX" * and "snf10gX" where X is the board number. */ if (sscanf(device, "snf10g%d", &boardnum) != 1 && sscanf(device, "snf%d", &boardnum) != 1) { /* Nope, not a supported name */ *is_ours = 0; return NULL; } } /* OK, it's probably ours. */ *is_ours = 1; p = pcap_create_common(device, ebuf, sizeof (struct pcap_snf)); if (p == NULL) return NULL; ps = p->priv; p->activate_op = snf_activate; ps->snf_boardnum = boardnum; return p; }
static int pcap_netmap_dispatch(pcap_t *p, int cnt, pcap_handler cb, u_char *user) { int ret; struct pcap_netmap *pn = p->priv; struct nm_desc *d = pn->d; struct pollfd pfd = { .fd = p->fd, .events = POLLIN, .revents = 0 }; pn->cb = cb; pn->cb_arg = user; for (;;) { if (p->break_loop) { p->break_loop = 0; return PCAP_ERROR_BREAK; } /* nm_dispatch won't run forever */ ret = nm_dispatch((void *)d, cnt, (void *)pcap_netmap_filter, (void *)p); if (ret != 0) break; errno = 0; ret = poll(&pfd, 1, p->opt.timeout); } return ret; } /* XXX need to check the NIOCTXSYNC/poll */ static int pcap_netmap_inject(pcap_t *p, const void *buf, size_t size) { struct pcap_netmap *pn = p->priv; struct nm_desc *d = pn->d; return nm_inject(d, buf, size); } static int pcap_netmap_ioctl(pcap_t *p, u_long what, uint32_t *if_flags) { struct pcap_netmap *pn = p->priv; struct nm_desc *d = pn->d; struct ifreq ifr; int error, fd = d->fd; #ifdef linux fd = socket(AF_INET, SOCK_DGRAM, 0); if (fd < 0) { fprintf(stderr, "Error: cannot get device control socket.\n"); return -1; } #endif /* linux */ bzero(&ifr, sizeof(ifr)); strncpy(ifr.ifr_name, d->req.nr_name, sizeof(ifr.ifr_name)); switch (what) { case SIOCSIFFLAGS: /* * The flags we pass in are 32-bit and unsigned. * * On most if not all UN*Xes, ifr_flags is 16-bit and * signed, and the result of assigning a longer * unsigned value to a shorter signed value is * implementation-defined (even if, in practice, it'll * do what's intended on all platforms we support * result of assigning a 32-bit unsigned value). * So we mask out the upper 16 bits. */ ifr.ifr_flags = *if_flags & 0xffff; #ifdef __FreeBSD__ /* * In FreeBSD, we need to set the high-order flags, * as we're using IFF_PPROMISC, which is in those bits. * * XXX - DragonFly BSD? */ ifr.ifr_flagshigh = *if_flags >> 16; #endif /* __FreeBSD__ */ break; } error = ioctl(fd, what, &ifr); if (!error) { switch (what) { case SIOCGIFFLAGS: /* * The flags we return are 32-bit. * * On most if not all UN*Xes, ifr_flags is * 16-bit and signed, and will get sign- * extended, so that the upper 16 bits of * those flags will be forced on. So we * mask out the upper 16 bits of the * sign-extended value. */ *if_flags = ifr.ifr_flags & 0xffff; #ifdef __FreeBSD__ /* * In FreeBSD, we need to return the * high-order flags, as we're using * IFF_PPROMISC, which is in those bits. * * XXX - DragonFly BSD? */ *if_flags |= (ifr.ifr_flagshigh << 16); #endif /* __FreeBSD__ */ } } #ifdef linux close(fd); #endif /* linux */ return error ? -1 : 0; } static void pcap_netmap_close(pcap_t *p) { struct pcap_netmap *pn = p->priv; struct nm_desc *d = pn->d; uint32_t if_flags = 0; if (pn->must_clear_promisc) { pcap_netmap_ioctl(p, SIOCGIFFLAGS, &if_flags); /* fetch flags */ if (if_flags & IFF_PPROMISC) { if_flags &= ~IFF_PPROMISC; pcap_netmap_ioctl(p, SIOCSIFFLAGS, &if_flags); } } nm_close(d); pcap_cleanup_live_common(p); } static int pcap_netmap_activate(pcap_t *p) { struct pcap_netmap *pn = p->priv; struct nm_desc *d; uint32_t if_flags = 0; d = nm_open(p->opt.device, NULL, 0, NULL); if (d == NULL) { pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE, errno, "netmap open: cannot access %s", p->opt.device); pcap_cleanup_live_common(p); return (PCAP_ERROR); } if (0) fprintf(stderr, "%s device %s priv %p fd %d ports %d..%d\n", __FUNCTION__, p->opt.device, d, d->fd, d->first_rx_ring, d->last_rx_ring); pn->d = d; p->fd = d->fd; /* * Turn a negative snapshot value (invalid), a snapshot value of * 0 (unspecified), or a value bigger than the normal maximum * value, into the maximum allowed value. * * If some application really *needs* a bigger snapshot * length, we should just increase MAXIMUM_SNAPLEN. */ if (p->snapshot <= 0 || p->snapshot > MAXIMUM_SNAPLEN) p->snapshot = MAXIMUM_SNAPLEN; if (p->opt.promisc && !(d->req.nr_ringid & NETMAP_SW_RING)) { pcap_netmap_ioctl(p, SIOCGIFFLAGS, &if_flags); /* fetch flags */ if (!(if_flags & IFF_PPROMISC)) { pn->must_clear_promisc = 1; if_flags |= IFF_PPROMISC; pcap_netmap_ioctl(p, SIOCSIFFLAGS, &if_flags); } } p->linktype = DLT_EN10MB; p->selectable_fd = p->fd; p->read_op = pcap_netmap_dispatch; p->inject_op = pcap_netmap_inject, p->setfilter_op = install_bpf_program; p->setdirection_op = NULL; p->set_datalink_op = NULL; p->getnonblock_op = pcap_getnonblock_fd; p->setnonblock_op = pcap_setnonblock_fd; p->stats_op = pcap_netmap_stats; p->cleanup_op = pcap_netmap_close; return (0); } pcap_t * pcap_netmap_create(const char *device, char *ebuf, int *is_ours) { pcap_t *p; *is_ours = (!strncmp(device, "netmap:", 7) || !strncmp(device, "vale", 4)); if (! *is_ours) return NULL; p = pcap_create_common(ebuf, sizeof (struct pcap_netmap)); if (p == NULL) return (NULL); p->activate_op = pcap_netmap_activate; return (p); }
p->getnonblock_op = pcap_getnonblock_fd; p->setnonblock_op = pcap_setnonblock_fd; p->stats_op = pcap_stats_nit; return (0); bad: pcap_cleanup_live_common(p); return (PCAP_ERROR); } pcap_t * pcap_create_interface(const char *device _U_, char *ebuf) { pcap_t *p; p = pcap_create_common(ebuf, sizeof (struct pcap_nit)); if (p == NULL) return (NULL); p->activate_op = pcap_activate_nit; return (p); } /* * XXX - there's probably a particular bind error that means "that device * doesn't support NIT"; if so, we should try a bind and use that. */ static int can_be_bound(const char *name _U_) { return (1);
pcap_t * TcCreate(const char *device, char *ebuf, int *is_ours) { ULONG numPorts; PTC_PORT pPorts = NULL; TC_STATUS status; int is_tc; ULONG i; pcap_t *p; if (LoadTcFunctions() != TC_API_LOADED) { /* * XXX - report this as an error rather than as * "not a TurboCap device"? */ *is_ours = 0; return NULL; } /* * enumerate the ports, and add them to the list */ status = g_TcFunctions.QueryPortList(&pPorts, &numPorts); if (status != TC_SUCCESS) { /* * XXX - report this as an error rather than as * "not a TurboCap device"? */ *is_ours = 0; return NULL; } is_tc = FALSE; for (i = 0; i < numPorts; i++) { if (strcmp(g_TcFunctions.PortGetName(pPorts[i]), device) == 0) { is_tc = TRUE; break; } } if (numPorts > 0) { /* * ignore the result here */ (void)g_TcFunctions.FreePortList(pPorts); } if (!is_tc) { *is_ours = 0; return NULL; } /* OK, it's probably ours. */ *is_ours = 1; p = pcap_create_common(ebuf, sizeof (struct pcap_tc)); if (p == NULL) return NULL; p->activate_op = TcActivate; return p; }
pcap_t * snf_create(const char *device, char *ebuf, int *is_ours) { pcap_t *p; int boardnum = -1; struct snf_ifaddrs *ifaddrs, *ifa; size_t devlen; struct pcap_snf *ps; if (snf_init(SNF_VERSION_API)) { /* Can't initialize the API, so no SNF devices */ *is_ours = 0; return NULL; } /* * Match a given interface name to our list of interface names, from * which we can obtain the intended board number */ if (snf_getifaddrs(&ifaddrs) || ifaddrs == NULL) { /* Can't get SNF addresses */ *is_ours = 0; return NULL; } devlen = strlen(device) + 1; ifa = ifaddrs; while (ifa) { if (!strncmp(device, ifa->snf_ifa_name, devlen)) { boardnum = ifa->snf_ifa_boardnum; break; } ifa = ifa->snf_ifa_next; } snf_freeifaddrs(ifaddrs); if (ifa == NULL) { /* * If we can't find the device by name, support the name "snfX" * and "snf10gX" where X is the board number. */ if (sscanf(device, "snf10g%d", &boardnum) != 1 && sscanf(device, "snf%d", &boardnum) != 1) { /* Nope, not a supported name */ *is_ours = 0; return NULL; } } /* OK, it's probably ours. */ *is_ours = 1; p = pcap_create_common(device, ebuf, sizeof (struct pcap_snf)); if (p == NULL) return NULL; ps = p->priv; /* * We support microsecond and nanosecond time stamps. */ p->tstamp_precision_count = 2; p->tstamp_precision_list = malloc(2 * sizeof(u_int)); if (p->tstamp_precision_list == NULL) { pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno)); pcap_close(p); return NULL; } p->tstamp_precision_list[0] = PCAP_TSTAMP_PRECISION_MICRO; p->tstamp_precision_list[1] = PCAP_TSTAMP_PRECISION_NANO; p->activate_op = snf_activate; ps->snf_boardnum = boardnum; return p; }
static int pcap_netmap_dispatch(pcap_t *p, int cnt, pcap_handler cb, u_char *user) { int ret; struct pcap_netmap *pn = NM_PRIV(p); struct nm_desc *d = pn->d; struct pollfd pfd = { .fd = p->fd, .events = POLLIN, .revents = 0 }; pn->cb = cb; pn->cb_arg = user; for (;;) { if (p->break_loop) { p->break_loop = 0; return PCAP_ERROR_BREAK; } /* nm_dispatch won't run forever */ ret = nm_dispatch((void *)d, cnt, (void *)pcap_netmap_filter, (void *)p); if (ret != 0) break; errno = 0; ret = poll(&pfd, 1, p->the_timeout); } return ret; } /* XXX need to check the NIOCTXSYNC/poll */ static int pcap_netmap_inject(pcap_t *p, const void *buf, size_t size) { struct nm_desc *d = NM_PRIV(p)->d; return nm_inject(d, buf, size); } static int pcap_netmap_ioctl(pcap_t *p, u_long what, uint32_t *if_flags) { struct pcap_netmap *pn = NM_PRIV(p); struct nm_desc *d = pn->d; struct ifreq ifr; int error, fd = d->fd; #ifdef linux fd = socket(AF_INET, SOCK_DGRAM, 0); if (fd < 0) { fprintf(stderr, "Error: cannot get device control socket.\n"); return -1; } #endif /* linux */ bzero(&ifr, sizeof(ifr)); strncpy(ifr.ifr_name, d->req.nr_name, sizeof(ifr.ifr_name)); switch (what) { case SIOCSIFFLAGS: ifr.ifr_flags = *if_flags; #ifdef __FreeBSD__ ifr.ifr_flagshigh = *if_flags >> 16; #endif /* __FreeBSD__ */ break; } error = ioctl(fd, what, &ifr); if (!error) { switch (what) { case SIOCGIFFLAGS: *if_flags = ifr.ifr_flags; #ifdef __FreeBSD__ *if_flags |= (ifr.ifr_flagshigh << 16); #endif /* __FreeBSD__ */ } } #ifdef linux close(fd); #endif /* linux */ return error ? -1 : 0; } static void pcap_netmap_close(pcap_t *p) { struct pcap_netmap *pn = NM_PRIV(p); struct nm_desc *d = pn->d; uint32_t if_flags = 0; if (pn->must_clear_promisc) { pcap_netmap_ioctl(p, SIOCGIFFLAGS, &if_flags); /* fetch flags */ if (if_flags & IFF_PPROMISC) { if_flags &= ~IFF_PPROMISC; pcap_netmap_ioctl(p, SIOCSIFFLAGS, &if_flags); } } nm_close(d); #ifdef HAVE_NO_PRIV free(pn); SET_PRIV(p, NULL); // unnecessary #endif pcap_cleanup_live_common(p); } static int pcap_netmap_activate(pcap_t *p) { struct pcap_netmap *pn = NM_PRIV(p); struct nm_desc *d = nm_open(p->opt.source, NULL, 0, NULL); uint32_t if_flags = 0; if (d == NULL) { snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "netmap open: cannot access %s: %s\n", p->opt.source, pcap_strerror(errno)); #ifdef HAVE_NO_PRIV free(pn); SET_PRIV(p, NULL); // unnecessary #endif pcap_cleanup_live_common(p); return (PCAP_ERROR); } if (0) fprintf(stderr, "%s device %s priv %p fd %d ports %d..%d\n", __FUNCTION__, p->opt.source, d, d->fd, d->first_rx_ring, d->last_rx_ring); pn->d = d; p->fd = d->fd; if (p->opt.promisc && !(d->req.nr_ringid & NETMAP_SW_RING)) { pcap_netmap_ioctl(p, SIOCGIFFLAGS, &if_flags); /* fetch flags */ if (!(if_flags & IFF_PPROMISC)) { pn->must_clear_promisc = 1; if_flags |= IFF_PPROMISC; pcap_netmap_ioctl(p, SIOCSIFFLAGS, &if_flags); } } p->linktype = DLT_EN10MB; p->selectable_fd = p->fd; p->read_op = pcap_netmap_dispatch; p->inject_op = pcap_netmap_inject, p->setfilter_op = install_bpf_program; p->setdirection_op = NULL; p->set_datalink_op = NULL; p->getnonblock_op = pcap_getnonblock_fd; p->setnonblock_op = pcap_setnonblock_fd; p->stats_op = pcap_netmap_stats; p->cleanup_op = pcap_netmap_close; return (0); } pcap_t * pcap_netmap_create(const char *device, char *ebuf, int *is_ours) { pcap_t *p; *is_ours = (!strncmp(device, "netmap:", 7) || !strncmp(device, "vale", 4)); if (! *is_ours) return NULL; #ifdef HAVE_NO_PRIV { void *pn = calloc(1, sizeof(struct pcap_netmap)); if (pn == NULL) return NULL; p = pcap_create_common(device, ebuf); if (p == NULL) { free(pn); return NULL; } SET_PRIV(p, pn); } #else p = pcap_create_common(device, ebuf, sizeof (struct pcap_netmap)); if (p == NULL) return (NULL); #endif p->activate_op = pcap_netmap_activate; return (p); }
len); return (-1); } return (cc); } #endif pcap_t * pcap_create_interface(const char *device _U_, char *ebuf) { pcap_t *p; #ifdef DL_HP_RAWDLS struct pcap_dlpi *pd; #endif p = pcap_create_common(ebuf, sizeof (struct pcap_dlpi)); if (p == NULL) return (NULL); #ifdef DL_HP_RAWDLS pd = p->priv; pd->send_fd = -1; /* it hasn't been opened yet */ #endif p->activate_op = pcap_activate_dlpi; return (p); } /* * No platform-specific information. */
extern "C" pcap_t * pcap_create_interface(const char *device, char *errorBuffer) { // TODO: handle promiscous mode! // we need a socket to talk to the networking stack int socket = ::socket(AF_INET, SOCK_DGRAM, 0); if (socket < 0) { snprintf(errorBuffer, PCAP_ERRBUF_SIZE, "The networking stack doesn't seem to be available.\n"); return NULL; } struct ifreq request; if (!prepare_request(request, device)) { snprintf(errorBuffer, PCAP_ERRBUF_SIZE, "Interface name \"%s\" is too long.", device); close(socket); return NULL; } // check if the interface exist if (ioctl(socket, SIOCGIFINDEX, &request, sizeof(request)) < 0) { snprintf(errorBuffer, PCAP_ERRBUF_SIZE, "Interface \"%s\" does not exist.\n", device); close(socket); return NULL; } close(socket); // no longer needed after this point // get link level interface for this interface socket = ::socket(AF_LINK, SOCK_DGRAM, 0); if (socket < 0) { snprintf(errorBuffer, PCAP_ERRBUF_SIZE, "No link level: %s\n", strerror(errno)); return NULL; } // start monitoring if (ioctl(socket, SIOCSPACKETCAP, &request, sizeof(struct ifreq)) < 0) { snprintf(errorBuffer, PCAP_ERRBUF_SIZE, "Cannot start monitoring: %s\n", strerror(errno)); close(socket); return NULL; } pcap_t* handle = pcap_create_common(errorBuffer, sizeof (struct pcap_haiku)); if (handle == NULL) { snprintf(errorBuffer, PCAP_ERRBUF_SIZE, "malloc: %s", strerror(errno)); close(socket); return NULL; } handle->selectable_fd = socket; handle->fd = socket; handle->activate_op = pcap_activate_haiku; return handle; }