15 #include <netinet/in.h>
17 #include <sys/socket.h>
18 #include <sys/types.h>
23 #if SNF_VERSION_API >= 0x0003
24 #define SNF_HAVE_INJECT_API
31 * Private data for capturing on SNF devices.
34 snf_handle_t snf_handle; /* opaque device handle */
35 snf_ring_t snf_ring; /* opaque device ring handle */
36 #ifdef SNF_HAVE_INJECT_API
37 snf_inject_t snf_inj; /* inject handle, if inject is used */
44 snf_set_datalink(pcap_t *p, int dlt)
51 snf_pcap_stats(pcap_t *p, struct pcap_stat *ps)
53 struct snf_ring_stats stats;
54 struct pcap_snf *snfps = p->priv;
57 if ((rc = snf_ring_getstats(snfps->snf_ring, &stats))) {
58 pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
62 ps->ps_recv = stats.ring_pkt_recv + stats.ring_pkt_overflow;
63 ps->ps_drop = stats.ring_pkt_overflow;
64 ps->ps_ifdrop = stats.nic_pkt_overflow + stats.nic_pkt_bad;
69 snf_platform_cleanup(pcap_t *p)
71 struct pcap_snf *ps = p->priv;
73 #ifdef SNF_HAVE_INJECT_API
75 snf_inject_close(ps->snf_inj);
77 snf_ring_close(ps->snf_ring);
78 snf_close(ps->snf_handle);
79 pcap_cleanup_live_common(p);
83 snf_getnonblock(pcap_t *p)
85 struct pcap_snf *ps = p->priv;
87 return (ps->snf_timeout == 0);
91 snf_setnonblock(pcap_t *p, int nonblock)
93 struct pcap_snf *ps = p->priv;
98 if (p->opt.timeout <= 0)
99 ps->snf_timeout = -1; /* forever */
101 ps->snf_timeout = p->opt.timeout;
106 #define _NSEC_PER_SEC 1000000000
110 snf_timestamp_to_timeval(const int64_t ts_nanosec, const int tstamp_precision)
114 const static struct timeval zero_timeval;
119 tv.tv_sec = ts_nanosec / _NSEC_PER_SEC;
120 tv_nsec = (ts_nanosec % _NSEC_PER_SEC);
122 /* libpcap expects tv_usec to be nanos if using nanosecond precision. */
123 if (tstamp_precision == PCAP_TSTAMP_PRECISION_NANO)
124 tv.tv_usec = tv_nsec;
126 tv.tv_usec = tv_nsec / 1000;
132 snf_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
134 struct pcap_snf *ps = p->priv;
135 struct pcap_pkthdr hdr;
136 int i, flags, err, caplen, n;
137 struct snf_recv_req req;
138 int nonblock, timeout;
144 timeout = ps->snf_timeout;
145 while (n < cnt || PACKET_COUNT_IS_UNLIMITED(cnt)) {
147 * Has "pcap_breakloop()" been called?
158 err = snf_ring_recv(ps->snf_ring, timeout, &req);
161 if (err == EBUSY || err == EAGAIN) {
164 else if (err == EINTR) {
169 pcap_fmt_errmsg_for_errno(p->errbuf,
170 PCAP_ERRBUF_SIZE, err, "snf_read");
176 if (caplen > p->snapshot)
177 caplen = p->snapshot;
179 if ((p->fcode.bf_insns == NULL) ||
180 bpf_filter(p->fcode.bf_insns, req.pkt_addr, req.length, caplen)) {
181 hdr.ts = snf_timestamp_to_timeval(req.timestamp, p->opt.tstamp_precision);
183 hdr.len = req.length;
184 callback(user, &hdr, req.pkt_addr);
188 /* After one successful packet is received, we won't block
189 * again for that timeout. */
197 snf_setfilter(pcap_t *p, struct bpf_program *fp)
202 strncpy(p->errbuf, "setfilter: No filter specified",
207 /* Make our private copy of the filter */
209 if (install_bpf_program(p, fp) < 0)
216 snf_inject(pcap_t *p, const void *buf _U_, size_t size _U_)
218 #ifdef SNF_HAVE_INJECT_API
219 struct pcap_snf *ps = p->priv;
221 if (ps->snf_inj == NULL) {
222 rc = snf_inject_open(ps->snf_boardnum, 0, &ps->snf_inj);
224 pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
225 rc, "snf_inject_open");
230 rc = snf_inject_send(ps->snf_inj, -1, 0, buf, size);
235 pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
236 rc, "snf_inject_send");
240 strlcpy(p->errbuf, "Sending packets isn't supported with this snf version",
247 snf_activate(pcap_t* p)
249 struct pcap_snf *ps = p->priv;
250 char *device = p->opt.device;
251 const char *nr = NULL;
253 int flags = -1, ring_id = -1;
255 if (device == NULL) {
256 pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "device is NULL");
260 /* In Libpcap, we set pshared by default if NUM_RINGS is set to > 1.
261 * Since libpcap isn't thread-safe */
262 if ((nr = getenv("SNF_FLAGS")) && *nr)
263 flags = strtol(nr, NULL, 0);
264 else if ((nr = getenv("SNF_NUM_RINGS")) && *nr && atoi(nr) > 1)
265 flags = SNF_F_PSHARED;
270 /* Allow pcap_set_buffer_size() to set dataring_size.
271 * Default is zero which allows setting from env SNF_DATARING_SIZE.
272 * pcap_set_buffer_size() is in bytes while snf_open() accepts values
273 * between 0 and 1048576 in Megabytes. Values in this range are
276 err = snf_open(ps->snf_boardnum,
277 0, /* let SNF API parse SNF_NUM_RINGS, if set */
278 NULL, /* default RSS, or use SNF_RSS_FLAGS env */
279 (p->opt.buffer_size > 0 && p->opt.buffer_size < 1048576) ? 1048576 : p->opt.buffer_size, /* default to SNF_DATARING_SIZE from env */
280 flags, /* may want pshared */
283 pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
284 err, "snf_open failed");
288 if ((nr = getenv("SNF_PCAP_RING_ID")) && *nr) {
289 ring_id = (int) strtol(nr, NULL, 0);
291 err = snf_ring_open_id(ps->snf_handle, ring_id, &ps->snf_ring);
293 pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
294 err, "snf_ring_open_id(ring=%d) failed", ring_id);
299 * Turn a negative snapshot value (invalid), a snapshot value of
300 * 0 (unspecified), or a value bigger than the normal maximum
301 * value, into the maximum allowed value.
303 * If some application really *needs* a bigger snapshot
304 * length, we should just increase MAXIMUM_SNAPLEN.
306 if (p->snapshot <= 0 || p->snapshot > MAXIMUM_SNAPLEN)
307 p->snapshot = MAXIMUM_SNAPLEN;
309 if (p->opt.timeout <= 0)
310 ps->snf_timeout = -1;
312 ps->snf_timeout = p->opt.timeout;
314 err = snf_start(ps->snf_handle);
316 pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
317 err, "snf_start failed");
322 * "select()" and "poll()" don't work on snf descriptors.
325 p->selectable_fd = -1;
327 p->linktype = DLT_EN10MB;
328 p->read_op = snf_read;
329 p->inject_op = snf_inject;
330 p->setfilter_op = snf_setfilter;
331 p->setdirection_op = NULL; /* Not implemented.*/
332 p->set_datalink_op = snf_set_datalink;
333 p->getnonblock_op = snf_getnonblock;
334 p->setnonblock_op = snf_setnonblock;
335 p->stats_op = snf_pcap_stats;
336 p->cleanup_op = snf_platform_cleanup;
337 #ifdef SNF_HAVE_INJECT_API
343 #define MAX_DESC_LENGTH 128
345 snf_findalldevs(pcap_if_list_t *devlistp, char *errbuf)
349 struct sockaddr_in addr;
351 struct snf_ifaddrs *ifaddrs, *ifa;
352 char name[MAX_DESC_LENGTH];
353 char desc[MAX_DESC_LENGTH];
354 int ret, allports = 0, merge = 0;
355 const char *nr = NULL;
357 if (snf_init(SNF_VERSION_API)) {
358 (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
359 "snf_getifaddrs: snf_init failed");
363 if (snf_getifaddrs(&ifaddrs) || ifaddrs == NULL)
365 pcap_fmt_errmsg_for_errno(errbuf, PCAP_ERRBUF_SIZE,
366 errno, "snf_getifaddrs");
369 if ((nr = getenv("SNF_FLAGS")) && *nr) {
371 merge = strtol(nr, NULL, 0);
373 (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
374 "snf_getifaddrs: SNF_FLAGS is not a valid number");
377 merge = merge & SNF_F_AGGREGATE_PORTMASK;
380 for (ifa = ifaddrs; ifa != NULL; ifa = ifa->snf_ifa_next) {
382 * Myricom SNF adapter ports may appear as regular
383 * network interfaces, which would already have been
384 * added to the list of adapters by pcap_platform_finddevs()
385 * if this isn't an SNF-only version of libpcap.
387 * Our create routine intercepts pcap_create() calls for
388 * those interfaces and arranges that they will be
389 * opened using the SNF API instead.
391 * So if we already have an entry for the device, we
392 * don't add an additional entry for it, we just
393 * update the description for it, if any, to indicate
394 * which snfN device it is. Otherwise, we add an entry
397 * In either case, if SNF_F_AGGREGATE_PORTMASK is set
398 * in SNF_FLAGS, we add this port to the bitmask
399 * of ports, which we use to generate a device
400 * we can use to capture on all ports.
402 * Generate the description string. If port aggregation
403 * is set, use 2^{port number} as the unit number,
404 * rather than {port number}.
406 * XXX - do entries in this list have IP addresses for
407 * the port? If so, should we add them to the
408 * entry for the device, if they're not already in the
409 * list of IP addresses for the device?
411 (void)pcap_snprintf(desc,MAX_DESC_LENGTH,"Myricom %ssnf%d",
412 merge ? "Merge Bitmask Port " : "",
413 merge ? 1 << ifa->snf_ifa_portnum : ifa->snf_ifa_portnum);
415 * Add the port to the bitmask.
418 allports |= 1 << ifa->snf_ifa_portnum;
420 * See if there's already an entry for the device
421 * with the name ifa->snf_ifa_name.
423 dev = find_dev(devlistp, ifa->snf_ifa_name);
426 * Yes. Update its description.
430 desc_str = strdup(desc);
431 if (desc_str == NULL) {
432 pcap_fmt_errmsg_for_errno(errbuf,
433 PCAP_ERRBUF_SIZE, errno,
434 "snf_findalldevs strdup");
437 free(dev->description);
438 dev->description = desc_str;
441 * No. Add an entry for it.
443 * XXX - is there a notion of "up" or "running",
444 * and can we determine whether something's
445 * plugged into the adapter and set
446 * PCAP_IF_CONNECTION_STATUS_CONNECTED or
447 * PCAP_IF_CONNECTION_STATUS_DISCONNECTED?
449 dev = add_dev(devlistp, ifa->snf_ifa_name, 0, desc,
455 * On Windows, fill in IP# from device name
457 ret = inet_pton(AF_INET, dev->name, &addr.sin_addr);
460 * Successful conversion of device name
463 addr.sin_family = AF_INET;
464 if (add_addr_to_dev(dev, &addr, sizeof(addr),
465 NULL, 0, NULL, 0, NULL, 0, errbuf) == -1)
467 } else if (ret == -1) {
471 pcap_fmt_errmsg_for_errno(errbuf,
472 PCAP_ERRBUF_SIZE, errno,
473 "sinf_findalldevs inet_pton");
479 snf_freeifaddrs(ifaddrs);
481 * Create a snfX entry if port aggregation is enabled
485 * Add a new entry with all ports bitmask
487 (void)pcap_snprintf(name,MAX_DESC_LENGTH,"snf%d",allports);
488 (void)pcap_snprintf(desc,MAX_DESC_LENGTH,"Myricom Merge Bitmask All Ports snf%d",
491 * XXX - is there any notion of "up" and "running" that
492 * would apply to this device, given that it handles
495 * Presumably, there's no notion of "connected" vs.
496 * "disconnected", as "is this plugged into a network?"
497 * would be a per-port property.
499 if (add_dev(devlistp, name,
500 PCAP_IF_CONNECTION_STATUS_NOT_APPLICABLE, desc,
504 * XXX - should we give it a list of addresses with all
505 * the addresses for all the ports?
513 snf_create(const char *device, char *ebuf, int *is_ours)
517 struct snf_ifaddrs *ifaddrs, *ifa;
521 if (snf_init(SNF_VERSION_API)) {
522 /* Can't initialize the API, so no SNF devices */
528 * Match a given interface name to our list of interface names, from
529 * which we can obtain the intended board number
531 if (snf_getifaddrs(&ifaddrs) || ifaddrs == NULL) {
532 /* Can't get SNF addresses */
536 devlen = strlen(device) + 1;
539 if (strncmp(device, ifa->snf_ifa_name, devlen) == 0) {
540 boardnum = ifa->snf_ifa_boardnum;
543 ifa = ifa->snf_ifa_next;
545 snf_freeifaddrs(ifaddrs);
549 * If we can't find the device by name, support the name "snfX"
550 * and "snf10gX" where X is the board number.
552 if (sscanf(device, "snf10g%d", &boardnum) != 1 &&
553 sscanf(device, "snf%d", &boardnum) != 1) {
554 /* Nope, not a supported name */
560 /* OK, it's probably ours. */
563 p = pcap_create_common(ebuf, sizeof (struct pcap_snf));
569 * We support microsecond and nanosecond time stamps.
571 p->tstamp_precision_count = 2;
572 p->tstamp_precision_list = malloc(2 * sizeof(u_int));
573 if (p->tstamp_precision_list == NULL) {
574 pcap_fmt_errmsg_for_errno(ebuf, PCAP_ERRBUF_SIZE, errno,
579 p->tstamp_precision_list[0] = PCAP_TSTAMP_PRECISION_MICRO;
580 p->tstamp_precision_list[1] = PCAP_TSTAMP_PRECISION_NANO;
582 p->activate_op = snf_activate;
583 ps->snf_boardnum = boardnum;
589 * This libpcap build supports only SNF cards, not regular network
594 * There are no regular interfaces, just SNF interfaces.
597 pcap_platform_finddevs(pcap_if_list_t *devlistp, char *errbuf)
603 * Attempts to open a regular interface fail.
606 pcap_create_interface(const char *device, char *errbuf)
608 pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
609 "This version of libpcap only supports SNF cards");
614 * Libpcap version string.
617 pcap_lib_version(void)
619 return (PCAP_VERSION_STRING " (SNF-only)");