1a0ee43a1SRui Paulo #ifdef HAVE_CONFIG_H
2b00ab754SHans Petter Selasky #include <config.h>
3a0ee43a1SRui Paulo #endif
4a0ee43a1SRui Paulo
5b00ab754SHans Petter Selasky #ifndef _WIN32
6a0ee43a1SRui Paulo #include <sys/param.h>
7b00ab754SHans Petter Selasky #endif /* !_WIN32 */
8a0ee43a1SRui Paulo
9a0ee43a1SRui Paulo #include <stdlib.h>
10a0ee43a1SRui Paulo #include <string.h>
11a0ee43a1SRui Paulo #include <errno.h>
126f9cba8fSJoseph Mingrone #include <limits.h> /* for INT_MAX */
13a0ee43a1SRui Paulo
14b00ab754SHans Petter Selasky #ifndef _WIN32
15a0ee43a1SRui Paulo #include <netinet/in.h>
16a0ee43a1SRui Paulo #include <sys/mman.h>
17a0ee43a1SRui Paulo #include <sys/socket.h>
18a0ee43a1SRui Paulo #include <sys/types.h>
19a0ee43a1SRui Paulo #include <unistd.h>
20b00ab754SHans Petter Selasky #endif /* !_WIN32 */
21a0ee43a1SRui Paulo
22681ed54cSXin LI #include <snf.h>
23ada6f083SXin LI #if SNF_VERSION_API >= 0x0003
24ada6f083SXin LI #define SNF_HAVE_INJECT_API
25ada6f083SXin LI #endif
26681ed54cSXin LI
27a0ee43a1SRui Paulo #include "pcap-int.h"
28681ed54cSXin LI #include "pcap-snf.h"
29681ed54cSXin LI
30681ed54cSXin LI /*
31681ed54cSXin LI * Private data for capturing on SNF devices.
32681ed54cSXin LI */
33681ed54cSXin LI struct pcap_snf {
34681ed54cSXin LI snf_handle_t snf_handle; /* opaque device handle */
35681ed54cSXin LI snf_ring_t snf_ring; /* opaque device ring handle */
36ada6f083SXin LI #ifdef SNF_HAVE_INJECT_API
37ada6f083SXin LI snf_inject_t snf_inj; /* inject handle, if inject is used */
38ada6f083SXin LI #endif
39681ed54cSXin LI int snf_timeout;
40681ed54cSXin LI int snf_boardnum;
41681ed54cSXin LI };
42a0ee43a1SRui Paulo
43a0ee43a1SRui Paulo static int
snf_set_datalink(pcap_t * p,int dlt)44a0ee43a1SRui Paulo snf_set_datalink(pcap_t *p, int dlt)
45a0ee43a1SRui Paulo {
46a0ee43a1SRui Paulo p->linktype = dlt;
47a0ee43a1SRui Paulo return (0);
48a0ee43a1SRui Paulo }
49a0ee43a1SRui Paulo
50a0ee43a1SRui Paulo static int
snf_pcap_stats(pcap_t * p,struct pcap_stat * ps)51a0ee43a1SRui Paulo snf_pcap_stats(pcap_t *p, struct pcap_stat *ps)
52a0ee43a1SRui Paulo {
53a0ee43a1SRui Paulo struct snf_ring_stats stats;
54ada6f083SXin LI struct pcap_snf *snfps = p->priv;
55a0ee43a1SRui Paulo int rc;
56a0ee43a1SRui Paulo
57ada6f083SXin LI if ((rc = snf_ring_getstats(snfps->snf_ring, &stats))) {
58b00ab754SHans Petter Selasky pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
59b00ab754SHans Petter Selasky rc, "snf_get_stats");
60a0ee43a1SRui Paulo return -1;
61a0ee43a1SRui Paulo }
62a0ee43a1SRui Paulo ps->ps_recv = stats.ring_pkt_recv + stats.ring_pkt_overflow;
63a0ee43a1SRui Paulo ps->ps_drop = stats.ring_pkt_overflow;
64a0ee43a1SRui Paulo ps->ps_ifdrop = stats.nic_pkt_overflow + stats.nic_pkt_bad;
65a0ee43a1SRui Paulo return 0;
66a0ee43a1SRui Paulo }
67a0ee43a1SRui Paulo
68a0ee43a1SRui Paulo static void
snf_platform_cleanup(pcap_t * p)69a0ee43a1SRui Paulo snf_platform_cleanup(pcap_t *p)
70a0ee43a1SRui Paulo {
71ada6f083SXin LI struct pcap_snf *ps = p->priv;
72681ed54cSXin LI
73ada6f083SXin LI #ifdef SNF_HAVE_INJECT_API
74ada6f083SXin LI if (ps->snf_inj)
75ada6f083SXin LI snf_inject_close(ps->snf_inj);
76ada6f083SXin LI #endif
77681ed54cSXin LI snf_ring_close(ps->snf_ring);
78681ed54cSXin LI snf_close(ps->snf_handle);
79a0ee43a1SRui Paulo pcap_cleanup_live_common(p);
80a0ee43a1SRui Paulo }
81a0ee43a1SRui Paulo
82a0ee43a1SRui Paulo static int
snf_getnonblock(pcap_t * p)83b00ab754SHans Petter Selasky snf_getnonblock(pcap_t *p)
84a0ee43a1SRui Paulo {
85681ed54cSXin LI struct pcap_snf *ps = p->priv;
86681ed54cSXin LI
87681ed54cSXin LI return (ps->snf_timeout == 0);
88a0ee43a1SRui Paulo }
89a0ee43a1SRui Paulo
90a0ee43a1SRui Paulo static int
snf_setnonblock(pcap_t * p,int nonblock)91b00ab754SHans Petter Selasky snf_setnonblock(pcap_t *p, int nonblock)
92a0ee43a1SRui Paulo {
93681ed54cSXin LI struct pcap_snf *ps = p->priv;
94681ed54cSXin LI
95a0ee43a1SRui Paulo if (nonblock)
96681ed54cSXin LI ps->snf_timeout = 0;
97a0ee43a1SRui Paulo else {
98681ed54cSXin LI if (p->opt.timeout <= 0)
99681ed54cSXin LI ps->snf_timeout = -1; /* forever */
100a0ee43a1SRui Paulo else
101681ed54cSXin LI ps->snf_timeout = p->opt.timeout;
102a0ee43a1SRui Paulo }
103a0ee43a1SRui Paulo return (0);
104a0ee43a1SRui Paulo }
105a0ee43a1SRui Paulo
106a0ee43a1SRui Paulo #define _NSEC_PER_SEC 1000000000
107a0ee43a1SRui Paulo
108a0ee43a1SRui Paulo static inline
109a0ee43a1SRui Paulo struct timeval
snf_timestamp_to_timeval(const int64_t ts_nanosec,const int tstamp_precision)110ada6f083SXin LI snf_timestamp_to_timeval(const int64_t ts_nanosec, const int tstamp_precision)
111a0ee43a1SRui Paulo {
112a0ee43a1SRui Paulo struct timeval tv;
113ada6f083SXin LI long tv_nsec;
114b00ab754SHans Petter Selasky const static struct timeval zero_timeval;
115ada6f083SXin LI
116a0ee43a1SRui Paulo if (ts_nanosec == 0)
117b00ab754SHans Petter Selasky return zero_timeval;
118ada6f083SXin LI
119a0ee43a1SRui Paulo tv.tv_sec = ts_nanosec / _NSEC_PER_SEC;
120ada6f083SXin LI tv_nsec = (ts_nanosec % _NSEC_PER_SEC);
121ada6f083SXin LI
122ada6f083SXin LI /* libpcap expects tv_usec to be nanos if using nanosecond precision. */
123ada6f083SXin LI if (tstamp_precision == PCAP_TSTAMP_PRECISION_NANO)
124ada6f083SXin LI tv.tv_usec = tv_nsec;
125ada6f083SXin LI else
126ada6f083SXin LI tv.tv_usec = tv_nsec / 1000;
127ada6f083SXin LI
128a0ee43a1SRui Paulo return tv;
129a0ee43a1SRui Paulo }
130a0ee43a1SRui Paulo
131a0ee43a1SRui Paulo static int
snf_read(pcap_t * p,int cnt,pcap_handler callback,u_char * user)132a0ee43a1SRui Paulo snf_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
133a0ee43a1SRui Paulo {
134681ed54cSXin LI struct pcap_snf *ps = p->priv;
135a0ee43a1SRui Paulo struct pcap_pkthdr hdr;
136a0ee43a1SRui Paulo int i, flags, err, caplen, n;
137a0ee43a1SRui Paulo struct snf_recv_req req;
138ada6f083SXin LI int nonblock, timeout;
139a0ee43a1SRui Paulo
140ada6f083SXin LI if (!p)
141a0ee43a1SRui Paulo return -1;
142a0ee43a1SRui Paulo
1436f9cba8fSJoseph Mingrone /*
1446f9cba8fSJoseph Mingrone * This can conceivably process more than INT_MAX packets,
1456f9cba8fSJoseph Mingrone * which would overflow the packet count, causing it either
1466f9cba8fSJoseph Mingrone * to look like a negative number, and thus cause us to
1476f9cba8fSJoseph Mingrone * return a value that looks like an error, or overflow
1486f9cba8fSJoseph Mingrone * back into positive territory, and thus cause us to
1496f9cba8fSJoseph Mingrone * return a too-low count.
1506f9cba8fSJoseph Mingrone *
1516f9cba8fSJoseph Mingrone * Therefore, if the packet count is unlimited, we clip
1526f9cba8fSJoseph Mingrone * it at INT_MAX; this routine is not expected to
1536f9cba8fSJoseph Mingrone * process packets indefinitely, so that's not an issue.
1546f9cba8fSJoseph Mingrone */
1556f9cba8fSJoseph Mingrone if (PACKET_COUNT_IS_UNLIMITED(cnt))
1566f9cba8fSJoseph Mingrone cnt = INT_MAX;
1576f9cba8fSJoseph Mingrone
158a0ee43a1SRui Paulo n = 0;
159ada6f083SXin LI timeout = ps->snf_timeout;
1606f9cba8fSJoseph Mingrone while (n < cnt) {
161a0ee43a1SRui Paulo /*
162a0ee43a1SRui Paulo * Has "pcap_breakloop()" been called?
163a0ee43a1SRui Paulo */
164a0ee43a1SRui Paulo if (p->break_loop) {
165a0ee43a1SRui Paulo if (n == 0) {
166a0ee43a1SRui Paulo p->break_loop = 0;
167a0ee43a1SRui Paulo return (-2);
168a0ee43a1SRui Paulo } else {
169a0ee43a1SRui Paulo return (n);
170a0ee43a1SRui Paulo }
171a0ee43a1SRui Paulo }
172a0ee43a1SRui Paulo
173ada6f083SXin LI err = snf_ring_recv(ps->snf_ring, timeout, &req);
174a0ee43a1SRui Paulo
175a0ee43a1SRui Paulo if (err) {
176ada6f083SXin LI if (err == EBUSY || err == EAGAIN) {
177ada6f083SXin LI return (n);
178ada6f083SXin LI }
179ada6f083SXin LI else if (err == EINTR) {
180ada6f083SXin LI timeout = 0;
181a0ee43a1SRui Paulo continue;
182ada6f083SXin LI }
183ada6f083SXin LI else {
184b00ab754SHans Petter Selasky pcap_fmt_errmsg_for_errno(p->errbuf,
185b00ab754SHans Petter Selasky PCAP_ERRBUF_SIZE, err, "snf_read");
186a0ee43a1SRui Paulo return -1;
187a0ee43a1SRui Paulo }
188a0ee43a1SRui Paulo }
189a0ee43a1SRui Paulo
190a0ee43a1SRui Paulo caplen = req.length;
191a0ee43a1SRui Paulo if (caplen > p->snapshot)
192a0ee43a1SRui Paulo caplen = p->snapshot;
193a0ee43a1SRui Paulo
194a0ee43a1SRui Paulo if ((p->fcode.bf_insns == NULL) ||
1956f9cba8fSJoseph Mingrone pcap_filter(p->fcode.bf_insns, req.pkt_addr, req.length, caplen)) {
196ada6f083SXin LI hdr.ts = snf_timestamp_to_timeval(req.timestamp, p->opt.tstamp_precision);
197a0ee43a1SRui Paulo hdr.caplen = caplen;
198a0ee43a1SRui Paulo hdr.len = req.length;
199a0ee43a1SRui Paulo callback(user, &hdr, req.pkt_addr);
200a0ee43a1SRui Paulo n++;
20157e22627SCy Schubert }
202ada6f083SXin LI
203ada6f083SXin LI /* After one successful packet is received, we won't block
204ada6f083SXin LI * again for that timeout. */
205ada6f083SXin LI if (timeout != 0)
206ada6f083SXin LI timeout = 0;
207a0ee43a1SRui Paulo }
208a0ee43a1SRui Paulo return (n);
209a0ee43a1SRui Paulo }
210a0ee43a1SRui Paulo
211a0ee43a1SRui Paulo static int
snf_inject(pcap_t * p,const void * buf _U_,int size _U_)2126f9cba8fSJoseph Mingrone snf_inject(pcap_t *p, const void *buf _U_, int size _U_)
213a0ee43a1SRui Paulo {
214ada6f083SXin LI #ifdef SNF_HAVE_INJECT_API
215ada6f083SXin LI struct pcap_snf *ps = p->priv;
216ada6f083SXin LI int rc;
217ada6f083SXin LI if (ps->snf_inj == NULL) {
218ada6f083SXin LI rc = snf_inject_open(ps->snf_boardnum, 0, &ps->snf_inj);
219ada6f083SXin LI if (rc) {
220b00ab754SHans Petter Selasky pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
221b00ab754SHans Petter Selasky rc, "snf_inject_open");
222ada6f083SXin LI return (-1);
223ada6f083SXin LI }
224ada6f083SXin LI }
225ada6f083SXin LI
226ada6f083SXin LI rc = snf_inject_send(ps->snf_inj, -1, 0, buf, size);
227ada6f083SXin LI if (!rc) {
228ada6f083SXin LI return (size);
229ada6f083SXin LI }
230ada6f083SXin LI else {
231b00ab754SHans Petter Selasky pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
232b00ab754SHans Petter Selasky rc, "snf_inject_send");
233ada6f083SXin LI return (-1);
234ada6f083SXin LI }
235ada6f083SXin LI #else
23657e22627SCy Schubert pcap_strlcpy(p->errbuf, "Sending packets isn't supported with this snf version",
237a0ee43a1SRui Paulo PCAP_ERRBUF_SIZE);
238a0ee43a1SRui Paulo return (-1);
239ada6f083SXin LI #endif
240a0ee43a1SRui Paulo }
241a0ee43a1SRui Paulo
242a0ee43a1SRui Paulo static int
snf_activate(pcap_t * p)243a0ee43a1SRui Paulo snf_activate(pcap_t* p)
244a0ee43a1SRui Paulo {
245681ed54cSXin LI struct pcap_snf *ps = p->priv;
246ada6f083SXin LI char *device = p->opt.device;
247a0ee43a1SRui Paulo const char *nr = NULL;
248a0ee43a1SRui Paulo int err;
249ada6f083SXin LI int flags = -1, ring_id = -1;
250a0ee43a1SRui Paulo
251a0ee43a1SRui Paulo if (device == NULL) {
2526f9cba8fSJoseph Mingrone snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "device is NULL");
253a0ee43a1SRui Paulo return -1;
254a0ee43a1SRui Paulo }
255a0ee43a1SRui Paulo
256a0ee43a1SRui Paulo /* In Libpcap, we set pshared by default if NUM_RINGS is set to > 1.
257a0ee43a1SRui Paulo * Since libpcap isn't thread-safe */
258ada6f083SXin LI if ((nr = getenv("SNF_FLAGS")) && *nr)
259ada6f083SXin LI flags = strtol(nr, NULL, 0);
260ada6f083SXin LI else if ((nr = getenv("SNF_NUM_RINGS")) && *nr && atoi(nr) > 1)
261ada6f083SXin LI flags = SNF_F_PSHARED;
262a0ee43a1SRui Paulo else
263a0ee43a1SRui Paulo nr = NULL;
264a0ee43a1SRui Paulo
265b00ab754SHans Petter Selasky
266b00ab754SHans Petter Selasky /* Allow pcap_set_buffer_size() to set dataring_size.
267b00ab754SHans Petter Selasky * Default is zero which allows setting from env SNF_DATARING_SIZE.
268b00ab754SHans Petter Selasky * pcap_set_buffer_size() is in bytes while snf_open() accepts values
269b00ab754SHans Petter Selasky * between 0 and 1048576 in Megabytes. Values in this range are
270b00ab754SHans Petter Selasky * mapped to 1MB.
271b00ab754SHans Petter Selasky */
272681ed54cSXin LI err = snf_open(ps->snf_boardnum,
273a0ee43a1SRui Paulo 0, /* let SNF API parse SNF_NUM_RINGS, if set */
274a0ee43a1SRui Paulo NULL, /* default RSS, or use SNF_RSS_FLAGS env */
275b00ab754SHans Petter Selasky (p->opt.buffer_size > 0 && p->opt.buffer_size < 1048576) ? 1048576 : p->opt.buffer_size, /* default to SNF_DATARING_SIZE from env */
276a0ee43a1SRui Paulo flags, /* may want pshared */
277681ed54cSXin LI &ps->snf_handle);
278a0ee43a1SRui Paulo if (err != 0) {
279b00ab754SHans Petter Selasky pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
280b00ab754SHans Petter Selasky err, "snf_open failed");
281a0ee43a1SRui Paulo return -1;
282a0ee43a1SRui Paulo }
283a0ee43a1SRui Paulo
284ada6f083SXin LI if ((nr = getenv("SNF_PCAP_RING_ID")) && *nr) {
285ada6f083SXin LI ring_id = (int) strtol(nr, NULL, 0);
286ada6f083SXin LI }
287ada6f083SXin LI err = snf_ring_open_id(ps->snf_handle, ring_id, &ps->snf_ring);
288a0ee43a1SRui Paulo if (err != 0) {
289b00ab754SHans Petter Selasky pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
290b00ab754SHans Petter Selasky err, "snf_ring_open_id(ring=%d) failed", ring_id);
291a0ee43a1SRui Paulo return -1;
292a0ee43a1SRui Paulo }
293a0ee43a1SRui Paulo
294b00ab754SHans Petter Selasky /*
295b00ab754SHans Petter Selasky * Turn a negative snapshot value (invalid), a snapshot value of
296b00ab754SHans Petter Selasky * 0 (unspecified), or a value bigger than the normal maximum
297b00ab754SHans Petter Selasky * value, into the maximum allowed value.
298b00ab754SHans Petter Selasky *
299b00ab754SHans Petter Selasky * If some application really *needs* a bigger snapshot
300b00ab754SHans Petter Selasky * length, we should just increase MAXIMUM_SNAPLEN.
301b00ab754SHans Petter Selasky */
302b00ab754SHans Petter Selasky if (p->snapshot <= 0 || p->snapshot > MAXIMUM_SNAPLEN)
303b00ab754SHans Petter Selasky p->snapshot = MAXIMUM_SNAPLEN;
304b00ab754SHans Petter Selasky
305681ed54cSXin LI if (p->opt.timeout <= 0)
306681ed54cSXin LI ps->snf_timeout = -1;
307a0ee43a1SRui Paulo else
308681ed54cSXin LI ps->snf_timeout = p->opt.timeout;
309a0ee43a1SRui Paulo
310681ed54cSXin LI err = snf_start(ps->snf_handle);
311a0ee43a1SRui Paulo if (err != 0) {
312b00ab754SHans Petter Selasky pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
313b00ab754SHans Petter Selasky err, "snf_start failed");
314a0ee43a1SRui Paulo return -1;
315a0ee43a1SRui Paulo }
316a0ee43a1SRui Paulo
317a0ee43a1SRui Paulo /*
318a0ee43a1SRui Paulo * "select()" and "poll()" don't work on snf descriptors.
319a0ee43a1SRui Paulo */
320b00ab754SHans Petter Selasky #ifndef _WIN32
321a0ee43a1SRui Paulo p->selectable_fd = -1;
322b00ab754SHans Petter Selasky #endif /* !_WIN32 */
323a0ee43a1SRui Paulo p->linktype = DLT_EN10MB;
324a0ee43a1SRui Paulo p->read_op = snf_read;
325a0ee43a1SRui Paulo p->inject_op = snf_inject;
3266f9cba8fSJoseph Mingrone p->setfilter_op = install_bpf_program;
327a0ee43a1SRui Paulo p->setdirection_op = NULL; /* Not implemented.*/
328a0ee43a1SRui Paulo p->set_datalink_op = snf_set_datalink;
329a0ee43a1SRui Paulo p->getnonblock_op = snf_getnonblock;
330a0ee43a1SRui Paulo p->setnonblock_op = snf_setnonblock;
331a0ee43a1SRui Paulo p->stats_op = snf_pcap_stats;
332a0ee43a1SRui Paulo p->cleanup_op = snf_platform_cleanup;
333ada6f083SXin LI #ifdef SNF_HAVE_INJECT_API
334ada6f083SXin LI ps->snf_inj = NULL;
335ada6f083SXin LI #endif
336a0ee43a1SRui Paulo return 0;
337a0ee43a1SRui Paulo }
338a0ee43a1SRui Paulo
339ada6f083SXin LI #define MAX_DESC_LENGTH 128
340a0ee43a1SRui Paulo int
snf_findalldevs(pcap_if_list_t * devlistp,char * errbuf)341b00ab754SHans Petter Selasky snf_findalldevs(pcap_if_list_t *devlistp, char *errbuf)
342a0ee43a1SRui Paulo {
343b00ab754SHans Petter Selasky pcap_if_t *dev;
344b00ab754SHans Petter Selasky #ifdef _WIN32
345b00ab754SHans Petter Selasky struct sockaddr_in addr;
346b00ab754SHans Petter Selasky #endif
347ada6f083SXin LI struct snf_ifaddrs *ifaddrs, *ifa;
348b00ab754SHans Petter Selasky char name[MAX_DESC_LENGTH];
349ada6f083SXin LI char desc[MAX_DESC_LENGTH];
350b00ab754SHans Petter Selasky int ret, allports = 0, merge = 0;
351b00ab754SHans Petter Selasky const char *nr = NULL;
352ada6f083SXin LI
353b00ab754SHans Petter Selasky if (snf_init(SNF_VERSION_API)) {
3546f9cba8fSJoseph Mingrone (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
355b00ab754SHans Petter Selasky "snf_getifaddrs: snf_init failed");
356ada6f083SXin LI return (-1);
357b00ab754SHans Petter Selasky }
358ada6f083SXin LI
359ada6f083SXin LI if (snf_getifaddrs(&ifaddrs) || ifaddrs == NULL)
360ada6f083SXin LI {
361b00ab754SHans Petter Selasky pcap_fmt_errmsg_for_errno(errbuf, PCAP_ERRBUF_SIZE,
362b00ab754SHans Petter Selasky errno, "snf_getifaddrs");
363ada6f083SXin LI return (-1);
364ada6f083SXin LI }
365b00ab754SHans Petter Selasky if ((nr = getenv("SNF_FLAGS")) && *nr) {
366b00ab754SHans Petter Selasky errno = 0;
367b00ab754SHans Petter Selasky merge = strtol(nr, NULL, 0);
368b00ab754SHans Petter Selasky if (errno) {
3696f9cba8fSJoseph Mingrone (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
370b00ab754SHans Petter Selasky "snf_getifaddrs: SNF_FLAGS is not a valid number");
371ada6f083SXin LI return (-1);
372ada6f083SXin LI }
373b00ab754SHans Petter Selasky merge = merge & SNF_F_AGGREGATE_PORTMASK;
374ada6f083SXin LI }
375ada6f083SXin LI
376b00ab754SHans Petter Selasky for (ifa = ifaddrs; ifa != NULL; ifa = ifa->snf_ifa_next) {
377b00ab754SHans Petter Selasky /*
378b00ab754SHans Petter Selasky * Myricom SNF adapter ports may appear as regular
379b00ab754SHans Petter Selasky * network interfaces, which would already have been
380b00ab754SHans Petter Selasky * added to the list of adapters by pcap_platform_finddevs()
381b00ab754SHans Petter Selasky * if this isn't an SNF-only version of libpcap.
382b00ab754SHans Petter Selasky *
383b00ab754SHans Petter Selasky * Our create routine intercepts pcap_create() calls for
384b00ab754SHans Petter Selasky * those interfaces and arranges that they will be
385b00ab754SHans Petter Selasky * opened using the SNF API instead.
386b00ab754SHans Petter Selasky *
387b00ab754SHans Petter Selasky * So if we already have an entry for the device, we
388b00ab754SHans Petter Selasky * don't add an additional entry for it, we just
389b00ab754SHans Petter Selasky * update the description for it, if any, to indicate
390b00ab754SHans Petter Selasky * which snfN device it is. Otherwise, we add an entry
391b00ab754SHans Petter Selasky * for it.
392b00ab754SHans Petter Selasky *
393b00ab754SHans Petter Selasky * In either case, if SNF_F_AGGREGATE_PORTMASK is set
394b00ab754SHans Petter Selasky * in SNF_FLAGS, we add this port to the bitmask
395b00ab754SHans Petter Selasky * of ports, which we use to generate a device
396b00ab754SHans Petter Selasky * we can use to capture on all ports.
397b00ab754SHans Petter Selasky *
398b00ab754SHans Petter Selasky * Generate the description string. If port aggregation
399b00ab754SHans Petter Selasky * is set, use 2^{port number} as the unit number,
400b00ab754SHans Petter Selasky * rather than {port number}.
401b00ab754SHans Petter Selasky *
402b00ab754SHans Petter Selasky * XXX - do entries in this list have IP addresses for
403b00ab754SHans Petter Selasky * the port? If so, should we add them to the
404b00ab754SHans Petter Selasky * entry for the device, if they're not already in the
405b00ab754SHans Petter Selasky * list of IP addresses for the device?
406b00ab754SHans Petter Selasky */
4076f9cba8fSJoseph Mingrone (void)snprintf(desc,MAX_DESC_LENGTH,"Myricom %ssnf%d",
408b00ab754SHans Petter Selasky merge ? "Merge Bitmask Port " : "",
409b00ab754SHans Petter Selasky merge ? 1 << ifa->snf_ifa_portnum : ifa->snf_ifa_portnum);
410b00ab754SHans Petter Selasky /*
411b00ab754SHans Petter Selasky * Add the port to the bitmask.
412b00ab754SHans Petter Selasky */
413b00ab754SHans Petter Selasky if (merge)
414b00ab754SHans Petter Selasky allports |= 1 << ifa->snf_ifa_portnum;
415b00ab754SHans Petter Selasky /*
416b00ab754SHans Petter Selasky * See if there's already an entry for the device
417b00ab754SHans Petter Selasky * with the name ifa->snf_ifa_name.
418b00ab754SHans Petter Selasky */
419b00ab754SHans Petter Selasky dev = find_dev(devlistp, ifa->snf_ifa_name);
420b00ab754SHans Petter Selasky if (dev != NULL) {
421b00ab754SHans Petter Selasky /*
422b00ab754SHans Petter Selasky * Yes. Update its description.
423b00ab754SHans Petter Selasky */
424b00ab754SHans Petter Selasky char *desc_str;
425ada6f083SXin LI
426b00ab754SHans Petter Selasky desc_str = strdup(desc);
427b00ab754SHans Petter Selasky if (desc_str == NULL) {
428b00ab754SHans Petter Selasky pcap_fmt_errmsg_for_errno(errbuf,
429b00ab754SHans Petter Selasky PCAP_ERRBUF_SIZE, errno,
430b00ab754SHans Petter Selasky "snf_findalldevs strdup");
431b00ab754SHans Petter Selasky return -1;
432b00ab754SHans Petter Selasky }
433b00ab754SHans Petter Selasky free(dev->description);
434b00ab754SHans Petter Selasky dev->description = desc_str;
435b00ab754SHans Petter Selasky } else {
436b00ab754SHans Petter Selasky /*
437b00ab754SHans Petter Selasky * No. Add an entry for it.
438b00ab754SHans Petter Selasky *
439b00ab754SHans Petter Selasky * XXX - is there a notion of "up" or "running",
440b00ab754SHans Petter Selasky * and can we determine whether something's
441b00ab754SHans Petter Selasky * plugged into the adapter and set
442b00ab754SHans Petter Selasky * PCAP_IF_CONNECTION_STATUS_CONNECTED or
443b00ab754SHans Petter Selasky * PCAP_IF_CONNECTION_STATUS_DISCONNECTED?
444b00ab754SHans Petter Selasky */
445b00ab754SHans Petter Selasky dev = add_dev(devlistp, ifa->snf_ifa_name, 0, desc,
446b00ab754SHans Petter Selasky errbuf);
447b00ab754SHans Petter Selasky if (dev == NULL)
448b00ab754SHans Petter Selasky return -1;
449b00ab754SHans Petter Selasky #ifdef _WIN32
450b00ab754SHans Petter Selasky /*
451b00ab754SHans Petter Selasky * On Windows, fill in IP# from device name
452b00ab754SHans Petter Selasky */
453b00ab754SHans Petter Selasky ret = inet_pton(AF_INET, dev->name, &addr.sin_addr);
454b00ab754SHans Petter Selasky if (ret == 1) {
455b00ab754SHans Petter Selasky /*
456b00ab754SHans Petter Selasky * Successful conversion of device name
457b00ab754SHans Petter Selasky * to IPv4 address.
458b00ab754SHans Petter Selasky */
459b00ab754SHans Petter Selasky addr.sin_family = AF_INET;
460b00ab754SHans Petter Selasky if (add_addr_to_dev(dev, &addr, sizeof(addr),
461b00ab754SHans Petter Selasky NULL, 0, NULL, 0, NULL, 0, errbuf) == -1)
462b00ab754SHans Petter Selasky return -1;
463b00ab754SHans Petter Selasky } else if (ret == -1) {
464b00ab754SHans Petter Selasky /*
465b00ab754SHans Petter Selasky * Error.
466b00ab754SHans Petter Selasky */
467b00ab754SHans Petter Selasky pcap_fmt_errmsg_for_errno(errbuf,
468b00ab754SHans Petter Selasky PCAP_ERRBUF_SIZE, errno,
469b00ab754SHans Petter Selasky "sinf_findalldevs inet_pton");
470b00ab754SHans Petter Selasky return -1;
471b00ab754SHans Petter Selasky }
472b00ab754SHans Petter Selasky #endif _WIN32
473b00ab754SHans Petter Selasky }
474ada6f083SXin LI }
475ada6f083SXin LI snf_freeifaddrs(ifaddrs);
476a0ee43a1SRui Paulo /*
477b00ab754SHans Petter Selasky * Create a snfX entry if port aggregation is enabled
478a0ee43a1SRui Paulo */
479b00ab754SHans Petter Selasky if (merge) {
480b00ab754SHans Petter Selasky /*
481b00ab754SHans Petter Selasky * Add a new entry with all ports bitmask
482b00ab754SHans Petter Selasky */
4836f9cba8fSJoseph Mingrone (void)snprintf(name,MAX_DESC_LENGTH,"snf%d",allports);
4846f9cba8fSJoseph Mingrone (void)snprintf(desc,MAX_DESC_LENGTH,"Myricom Merge Bitmask All Ports snf%d",
485b00ab754SHans Petter Selasky allports);
486b00ab754SHans Petter Selasky /*
487b00ab754SHans Petter Selasky * XXX - is there any notion of "up" and "running" that
488b00ab754SHans Petter Selasky * would apply to this device, given that it handles
489b00ab754SHans Petter Selasky * multiple ports?
490b00ab754SHans Petter Selasky *
491b00ab754SHans Petter Selasky * Presumably, there's no notion of "connected" vs.
492b00ab754SHans Petter Selasky * "disconnected", as "is this plugged into a network?"
493b00ab754SHans Petter Selasky * would be a per-port property.
494b00ab754SHans Petter Selasky */
495b00ab754SHans Petter Selasky if (add_dev(devlistp, name,
496b00ab754SHans Petter Selasky PCAP_IF_CONNECTION_STATUS_NOT_APPLICABLE, desc,
497b00ab754SHans Petter Selasky errbuf) == NULL)
498b00ab754SHans Petter Selasky return (-1);
499b00ab754SHans Petter Selasky /*
500b00ab754SHans Petter Selasky * XXX - should we give it a list of addresses with all
501b00ab754SHans Petter Selasky * the addresses for all the ports?
502b00ab754SHans Petter Selasky */
503b00ab754SHans Petter Selasky }
504b00ab754SHans Petter Selasky
505a0ee43a1SRui Paulo return 0;
506a0ee43a1SRui Paulo }
507a0ee43a1SRui Paulo
508a0ee43a1SRui Paulo pcap_t *
snf_create(const char * device,char * ebuf,int * is_ours)509edc89b24SXin LI snf_create(const char *device, char *ebuf, int *is_ours)
510a0ee43a1SRui Paulo {
511a0ee43a1SRui Paulo pcap_t *p;
512a0ee43a1SRui Paulo int boardnum = -1;
513a0ee43a1SRui Paulo struct snf_ifaddrs *ifaddrs, *ifa;
514a0ee43a1SRui Paulo size_t devlen;
515681ed54cSXin LI struct pcap_snf *ps;
516a0ee43a1SRui Paulo
517edc89b24SXin LI if (snf_init(SNF_VERSION_API)) {
518edc89b24SXin LI /* Can't initialize the API, so no SNF devices */
519edc89b24SXin LI *is_ours = 0;
520a0ee43a1SRui Paulo return NULL;
521edc89b24SXin LI }
522a0ee43a1SRui Paulo
523a0ee43a1SRui Paulo /*
524a0ee43a1SRui Paulo * Match a given interface name to our list of interface names, from
525a0ee43a1SRui Paulo * which we can obtain the intended board number
526a0ee43a1SRui Paulo */
527edc89b24SXin LI if (snf_getifaddrs(&ifaddrs) || ifaddrs == NULL) {
528edc89b24SXin LI /* Can't get SNF addresses */
529edc89b24SXin LI *is_ours = 0;
530a0ee43a1SRui Paulo return NULL;
531edc89b24SXin LI }
532a0ee43a1SRui Paulo devlen = strlen(device) + 1;
533a0ee43a1SRui Paulo ifa = ifaddrs;
534a0ee43a1SRui Paulo while (ifa) {
535b00ab754SHans Petter Selasky if (strncmp(device, ifa->snf_ifa_name, devlen) == 0) {
536a0ee43a1SRui Paulo boardnum = ifa->snf_ifa_boardnum;
537a0ee43a1SRui Paulo break;
538a0ee43a1SRui Paulo }
539a0ee43a1SRui Paulo ifa = ifa->snf_ifa_next;
540a0ee43a1SRui Paulo }
541a0ee43a1SRui Paulo snf_freeifaddrs(ifaddrs);
542a0ee43a1SRui Paulo
543a0ee43a1SRui Paulo if (ifa == NULL) {
544a0ee43a1SRui Paulo /*
545a0ee43a1SRui Paulo * If we can't find the device by name, support the name "snfX"
546a0ee43a1SRui Paulo * and "snf10gX" where X is the board number.
547a0ee43a1SRui Paulo */
548a0ee43a1SRui Paulo if (sscanf(device, "snf10g%d", &boardnum) != 1 &&
549edc89b24SXin LI sscanf(device, "snf%d", &boardnum) != 1) {
550edc89b24SXin LI /* Nope, not a supported name */
551edc89b24SXin LI *is_ours = 0;
552a0ee43a1SRui Paulo return NULL;
553a0ee43a1SRui Paulo }
554edc89b24SXin LI }
555edc89b24SXin LI
556edc89b24SXin LI /* OK, it's probably ours. */
557edc89b24SXin LI *is_ours = 1;
558a0ee43a1SRui Paulo
5596f9cba8fSJoseph Mingrone p = PCAP_CREATE_COMMON(ebuf, struct pcap_snf);
560a0ee43a1SRui Paulo if (p == NULL)
561a0ee43a1SRui Paulo return NULL;
562681ed54cSXin LI ps = p->priv;
563a0ee43a1SRui Paulo
564ada6f083SXin LI /*
565ada6f083SXin LI * We support microsecond and nanosecond time stamps.
566ada6f083SXin LI */
567ada6f083SXin LI p->tstamp_precision_list = malloc(2 * sizeof(u_int));
568ada6f083SXin LI if (p->tstamp_precision_list == NULL) {
569b00ab754SHans Petter Selasky pcap_fmt_errmsg_for_errno(ebuf, PCAP_ERRBUF_SIZE, errno,
570b00ab754SHans Petter Selasky "malloc");
571ada6f083SXin LI pcap_close(p);
572ada6f083SXin LI return NULL;
573ada6f083SXin LI }
574ada6f083SXin LI p->tstamp_precision_list[0] = PCAP_TSTAMP_PRECISION_MICRO;
575ada6f083SXin LI p->tstamp_precision_list[1] = PCAP_TSTAMP_PRECISION_NANO;
5766f9cba8fSJoseph Mingrone p->tstamp_precision_count = 2;
577ada6f083SXin LI
578a0ee43a1SRui Paulo p->activate_op = snf_activate;
579681ed54cSXin LI ps->snf_boardnum = boardnum;
580a0ee43a1SRui Paulo return p;
581a0ee43a1SRui Paulo }
582ada6f083SXin LI
583ada6f083SXin LI #ifdef SNF_ONLY
584ada6f083SXin LI /*
585ada6f083SXin LI * This libpcap build supports only SNF cards, not regular network
586ada6f083SXin LI * interfaces..
587ada6f083SXin LI */
588ada6f083SXin LI
589ada6f083SXin LI /*
590b00ab754SHans Petter Selasky * There are no regular interfaces, just SNF interfaces.
591ada6f083SXin LI */
592ada6f083SXin LI int
pcap_platform_finddevs(pcap_if_list_t * devlistp,char * errbuf)593b00ab754SHans Petter Selasky pcap_platform_finddevs(pcap_if_list_t *devlistp, char *errbuf)
594ada6f083SXin LI {
595ada6f083SXin LI return (0);
596ada6f083SXin LI }
597ada6f083SXin LI
598ada6f083SXin LI /*
599ada6f083SXin LI * Attempts to open a regular interface fail.
600ada6f083SXin LI */
601ada6f083SXin LI pcap_t *
pcap_create_interface(const char * device,char * errbuf)602ada6f083SXin LI pcap_create_interface(const char *device, char *errbuf)
603ada6f083SXin LI {
6046f9cba8fSJoseph Mingrone snprintf(errbuf, PCAP_ERRBUF_SIZE,
605ada6f083SXin LI "This version of libpcap only supports SNF cards");
606ada6f083SXin LI return NULL;
607ada6f083SXin LI }
608b00ab754SHans Petter Selasky
609b00ab754SHans Petter Selasky /*
610b00ab754SHans Petter Selasky * Libpcap version string.
611b00ab754SHans Petter Selasky */
612b00ab754SHans Petter Selasky const char *
pcap_lib_version(void)613b00ab754SHans Petter Selasky pcap_lib_version(void)
614b00ab754SHans Petter Selasky {
615b00ab754SHans Petter Selasky return (PCAP_VERSION_STRING " (SNF-only)");
616b00ab754SHans Petter Selasky }
617ada6f083SXin LI #endif
618