#include <signal.h>
#include <float.h>
#include <fcntl.h>
+#include <limits.h> /* for INT_MAX */
#include <io.h>
#if defined(USE_32BIT_DRIVERS)
{
pcap_t *p;
- p = pcap_create_common(ebuf, sizeof (struct pcap_dos));
+ p = PCAP_CREATE_COMMON(ebuf, struct pcap_dos);
if (p == NULL)
return (NULL);
return (PCAP_ERROR_RFMON_NOTSUP);
}
+ /*
+ * 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 (pcap->snapshot <= 0 || pcap->snapshot > MAXIMUM_SNAPLEN)
+ pcap->snapshot = MAXIMUM_SNAPLEN;
+
if (pcap->snapshot < ETH_MIN+8)
pcap->snapshot = ETH_MIN+8;
if (!init_watt32(pcap, pcap->opt.device, pcap->errbuf) ||
!first_init(pcap->opt.device, pcap->errbuf, pcap->opt.promisc))
{
+ /* XXX - free pcap->buffer? */
return (PCAP_ERROR);
}
atexit (close_driver);
}
else if (stricmp(active_dev->name,pcap->opt.device))
{
- pcap_snprintf (pcap->errbuf, PCAP_ERRBUF_SIZE,
+ snprintf (pcap->errbuf, PCAP_ERRBUF_SIZE,
"Cannot use different devices simultaneously "
"(`%s' vs. `%s')", active_dev->name, pcap->opt.device);
+ /* XXX - free pcap->buffer? */
return (PCAP_ERROR);
}
handle_to_device [pcap->fd-1] = active_dev;
pcap.len = rx_len;
if (callback &&
- (!p->fcode.bf_insns || bpf_filter(p->fcode.bf_insns, p->buffer, pcap.len, pcap.caplen)))
+ (!p->fcode.bf_insns || pcap_filter(p->fcode.bf_insns, p->buffer, pcap.len, pcap.caplen)))
{
filter_count++;
{
int rc, num = 0;
- while (num <= cnt || PACKET_COUNT_IS_UNLIMITED(cnt))
+ /*
+ * This can conceivably process more than INT_MAX packets,
+ * which would overflow the packet count, causing it either
+ * to look like a negative number, and thus cause us to
+ * return a value that looks like an error, or overflow
+ * back into positive territory, and thus cause us to
+ * return a too-low count.
+ *
+ * Therefore, if the packet count is unlimited, we clip
+ * it at INT_MAX; this routine is not expected to
+ * process packets indefinitely, so that's not an issue.
+ */
+ if (PACKET_COUNT_IS_UNLIMITED(cnt))
+ cnt = INT_MAX;
+
+ while (num <= cnt)
{
if (p->fd <= 0)
return (-1);
if (!dev || !dev->get_stats)
{
- strlcpy (p->errbuf, "detailed device statistics not available",
+ pcap_strlcpy (p->errbuf, "detailed device statistics not available",
PCAP_ERRBUF_SIZE);
return (-1);
}
if (!strnicmp(dev->name,"pkt",3))
{
- strlcpy (p->errbuf, "pktdrvr doesn't have detailed statistics",
+ pcap_strlcpy (p->errbuf, "pktdrvr doesn't have detailed statistics",
PCAP_ERRBUF_SIZE);
return (-1);
}
return;
}
close_driver();
+ /* XXX - call pcap_cleanup_live_common? */
}
/*
net = IN_CLASSC_NET;
else
{
- pcap_snprintf (errbuf, PCAP_ERRBUF_SIZE, "inet class for 0x%lx unknown", mask);
+ snprintf (errbuf, PCAP_ERRBUF_SIZE, "inet class for 0x%lx unknown", mask);
return (-1);
}
}
/*
* Get a list of all interfaces that are present and that we probe okay.
* Returns -1 on error, 0 otherwise.
- * The list, as returned through "alldevsp", may be NULL if no interfaces
- * were up and could be opened.
+ * The list may be NULL empty if no interfaces were up and could be opened.
*/
-int pcap_platform_finddevs (pcap_if_t **alldevsp, char *errbuf)
+int pcap_platform_finddevs (pcap_if_list_t *devlistp, char *errbuf)
{
struct device *dev;
+ pcap_if_t *curdev;
+#if 0 /* Pkt drivers should have no addresses */
struct sockaddr_in sa_ll_1, sa_ll_2;
struct sockaddr *addr, *netmask, *broadaddr, *dstaddr;
- pcap_if_t *devlist = NULL;
+#endif
int ret = 0;
- size_t addr_size = sizeof(*addr);
+ int found = 0;
for (dev = (struct device*)dev_base; dev; dev = dev->next)
{
FLUSHK();
(*dev->close) (dev);
+ /*
+ * XXX - find out whether it's up or running? Does that apply here?
+ * Can we find out if anything's plugged into the adapter, if it's
+ * a wired device, and set PCAP_IF_CONNECTION_STATUS_CONNECTED
+ * or PCAP_IF_CONNECTION_STATUS_DISCONNECTED?
+ */
+ if ((curdev = add_dev(devlistp, dev->name, 0,
+ dev->long_name, errbuf)) == NULL)
+ {
+ ret = -1;
+ break;
+ }
+ found = 1;
+#if 0 /* Pkt drivers should have no addresses */
memset (&sa_ll_1, 0, sizeof(sa_ll_1));
memset (&sa_ll_2, 0, sizeof(sa_ll_2));
sa_ll_1.sin_family = AF_INET;
broadaddr = (struct sockaddr*) &sa_ll_2;
memset (&sa_ll_2.sin_addr, 0xFF, sizeof(sa_ll_2.sin_addr));
- if (pcap_add_if(&devlist, dev->name, dev->flags,
- dev->long_name, errbuf) < 0)
- {
- ret = -1;
- break;
- }
-#if 0 /* Pkt drivers should have no addresses */
- if (add_addr_to_iflist(&devlist, dev->name, dev->flags, addr, addr_size,
- netmask, addr_size, broadaddr, addr_size,
- dstaddr, addr_size, errbuf) < 0)
+ if (add_addr_to_dev(curdev, addr, sizeof(*addr),
+ netmask, sizeof(*netmask),
+ broadaddr, sizeof(*broadaddr),
+ dstaddr, sizeof(*dstaddr), errbuf) < 0)
{
ret = -1;
break;
#endif
}
- if (devlist && ret < 0)
- {
- pcap_freealldevs (devlist);
- devlist = NULL;
- }
- else
- if (!devlist)
+ if (ret == 0 && !found)
strcpy (errbuf, "No drivers found");
- *alldevsp = devlist;
return (ret);
}
if (!(*dev->probe)(dev)) /* call the xx_probe() function */
{
- pcap_snprintf (ebuf, PCAP_ERRBUF_SIZE, "failed to detect device `%s'", dev_name);
+ snprintf (ebuf, PCAP_ERRBUF_SIZE, "failed to detect device `%s'", dev_name);
return (NULL);
}
probed_dev = dev; /* device is probed okay and may be used */
if (!(*dev->open)(dev))
{
- pcap_snprintf (ebuf, PCAP_ERRBUF_SIZE, "failed to activate device `%s'", dev_name);
+ snprintf (ebuf, PCAP_ERRBUF_SIZE, "failed to activate device `%s'", dev_name);
if (pktInfo.error && !strncmp(dev->name,"pkt",3))
{
strcat (ebuf, ": ");
return (NULL);
}
- /* Some devices need this to operate in promiscous mode
+ /* Some devices need this to operate in promiscuous mode
*/
if (promisc && dev->set_multicast_list)
(*dev->set_multicast_list) (dev);
*/
if (!dev)
{
- pcap_snprintf (ebuf, PCAP_ERRBUF_SIZE, "device `%s' not supported", dev_name);
+ snprintf (ebuf, PCAP_ERRBUF_SIZE, "device `%s' not supported", dev_name);
return (NULL);
}
not_probed:
if (!probed_dev)
{
- pcap_snprintf (ebuf, PCAP_ERRBUF_SIZE, "device `%s' not probed", dev_name);
+ snprintf (ebuf, PCAP_ERRBUF_SIZE, "device `%s' not probed", dev_name);
return (NULL);
}
return (dev);
}
/*
- * Supress PRINT message from Watt-32's sock_init()
+ * Suppress PRINT message from Watt-32's sock_init()
*/
static void null_print (void) {}
}
else if (rc && using_pktdrv)
{
- pcap_snprintf (err_buf, PCAP_ERRBUF_SIZE, "sock_init() failed, code %d", rc);
+ snprintf (err_buf, PCAP_ERRBUF_SIZE, "sock_init() failed, code %d", rc);
return (0);
}
pcap_save.linktype = _eth_get_hwtype (NULL, NULL);
pcap_save.snapshot = MTU > 0 ? MTU : ETH_MAX; /* assume 1514 */
-#if 1
/* prevent use of resolve() and resolve_ip()
*/
last_nameserver = 0;
-#endif
return (1);
}
static int ndis_open (struct device *dev)
{
- int promis = (dev->flags & IFF_PROMISC);
+ int promisc = (dev->flags & IFF_PROMISC);
#ifdef USE_NDIS2
- if (!NdisInit(promis))
+ if (!NdisInit(promisc))
return (0);
return (1);
#else
- ARGSUSED (promis);
+ ARGSUSED (promisc);
return (0);
#endif
}
#endif /* USE_32BIT_DRIVERS */
+/*
+ * Libpcap version string.
+ */
+const char *
+pcap_lib_version(void)
+{
+ return ("DOS-" PCAP_VERSION_STRING);
+}
projects / libpcap / blobdiff