1 #include <sys/cdefs.h>
2 __RCSID("$NetBSD: pcap-snf.c,v 1.3 2015/03/31 21:39:42 christos Exp $");
3
4 /* $NetBSD: pcap-snf.c,v 1.3 2015/03/31 21:39:42 christos Exp $ */
5
6 #ifdef HAVE_CONFIG_H
7 #include "config.h"
8 #endif
9
10 #include <sys/param.h>
11
12 #include <stdlib.h>
13 #include <string.h>
14 #include <errno.h>
15
16 #include <ctype.h>
17 #include <netinet/in.h>
18 #include <sys/mman.h>
19 #include <sys/socket.h>
20 #include <sys/types.h>
21 #include <unistd.h>
22
23 #include <snf.h>
24 #if SNF_VERSION_API >= 0x0003
25 #define SNF_HAVE_INJECT_API
26 #endif
27
28 #include "pcap-int.h"
29 #include "pcap-snf.h"
30
31 /*
32 * Private data for capturing on SNF devices.
33 */
34 struct pcap_snf {
35 snf_handle_t snf_handle; /* opaque device handle */
36 snf_ring_t snf_ring; /* opaque device ring handle */
37 #ifdef SNF_HAVE_INJECT_API
38 snf_inject_t snf_inj; /* inject handle, if inject is used */
39 #endif
40 int snf_timeout;
41 int snf_boardnum;
42 };
43
44 static int
snf_set_datalink(pcap_t * p,int dlt)45 snf_set_datalink(pcap_t *p, int dlt)
46 {
47 p->linktype = dlt;
48 return (0);
49 }
50
51 static int
snf_pcap_stats(pcap_t * p,struct pcap_stat * ps)52 snf_pcap_stats(pcap_t *p, struct pcap_stat *ps)
53 {
54 struct snf_ring_stats stats;
55 struct pcap_snf *snfps = p->priv;
56 int rc;
57
58 if ((rc = snf_ring_getstats(snfps->snf_ring, &stats))) {
59 snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snf_get_stats: %s",
60 pcap_strerror(rc));
61 return -1;
62 }
63 ps->ps_recv = stats.ring_pkt_recv + stats.ring_pkt_overflow;
64 ps->ps_drop = stats.ring_pkt_overflow;
65 ps->ps_ifdrop = stats.nic_pkt_overflow + stats.nic_pkt_bad;
66 return 0;
67 }
68
69 static void
snf_platform_cleanup(pcap_t * p)70 snf_platform_cleanup(pcap_t *p)
71 {
72 struct pcap_snf *ps = p->priv;
73
74 if (p == NULL)
75 return;
76
77 #ifdef SNF_HAVE_INJECT_API
78 if (ps->snf_inj)
79 snf_inject_close(ps->snf_inj);
80 #endif
81 snf_ring_close(ps->snf_ring);
82 snf_close(ps->snf_handle);
83 pcap_cleanup_live_common(p);
84 }
85
86 static int
snf_getnonblock(pcap_t * p,char * errbuf)87 snf_getnonblock(pcap_t *p, char *errbuf)
88 {
89 struct pcap_snf *ps = p->priv;
90
91 return (ps->snf_timeout == 0);
92 }
93
94 static int
snf_setnonblock(pcap_t * p,int nonblock,char * errbuf)95 snf_setnonblock(pcap_t *p, int nonblock, char *errbuf)
96 {
97 struct pcap_snf *ps = p->priv;
98
99 if (nonblock)
100 ps->snf_timeout = 0;
101 else {
102 if (p->opt.timeout <= 0)
103 ps->snf_timeout = -1; /* forever */
104 else
105 ps->snf_timeout = p->opt.timeout;
106 }
107 return (0);
108 }
109
110 #define _NSEC_PER_SEC 1000000000
111
112 static inline
113 struct timeval
snf_timestamp_to_timeval(const int64_t ts_nanosec,const int tstamp_precision)114 snf_timestamp_to_timeval(const int64_t ts_nanosec, const int tstamp_precision)
115 {
116 struct timeval tv;
117 long tv_nsec;
118
119 if (ts_nanosec == 0)
120 return (struct timeval) { 0, 0 };
121
122 tv.tv_sec = ts_nanosec / _NSEC_PER_SEC;
123 tv_nsec = (ts_nanosec % _NSEC_PER_SEC);
124
125 /* libpcap expects tv_usec to be nanos if using nanosecond precision. */
126 if (tstamp_precision == PCAP_TSTAMP_PRECISION_NANO)
127 tv.tv_usec = tv_nsec;
128 else
129 tv.tv_usec = tv_nsec / 1000;
130
131 return tv;
132 }
133
134 static int
snf_read(pcap_t * p,int cnt,pcap_handler callback,u_char * user)135 snf_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
136 {
137 struct pcap_snf *ps = p->priv;
138 struct pcap_pkthdr hdr;
139 int i, flags, err, caplen, n;
140 struct snf_recv_req req;
141 int nonblock, timeout;
142
143 if (!p)
144 return -1;
145
146 n = 0;
147 timeout = ps->snf_timeout;
148 while (n < cnt || PACKET_COUNT_IS_UNLIMITED(cnt)) {
149 /*
150 * Has "pcap_breakloop()" been called?
151 */
152 if (p->break_loop) {
153 if (n == 0) {
154 p->break_loop = 0;
155 return (-2);
156 } else {
157 return (n);
158 }
159 }
160
161 err = snf_ring_recv(ps->snf_ring, timeout, &req);
162
163 if (err) {
164 if (err == EBUSY || err == EAGAIN) {
165 return (n);
166 }
167 else if (err == EINTR) {
168 timeout = 0;
169 continue;
170 }
171 else {
172 snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snf_read: %s",
173 pcap_strerror(err));
174 return -1;
175 }
176 }
177
178 caplen = req.length;
179 if (caplen > p->snapshot)
180 caplen = p->snapshot;
181
182 if ((p->fcode.bf_insns == NULL) ||
183 bpf_filter(p->fcode.bf_insns, req.pkt_addr, req.length, caplen)) {
184 hdr.ts = snf_timestamp_to_timeval(req.timestamp, p->opt.tstamp_precision);
185 hdr.caplen = caplen;
186 hdr.len = req.length;
187 callback(user, &hdr, req.pkt_addr);
188 }
189 n++;
190
191 /* After one successful packet is received, we won't block
192 * again for that timeout. */
193 if (timeout != 0)
194 timeout = 0;
195 }
196 return (n);
197 }
198
199 static int
snf_setfilter(pcap_t * p,struct bpf_program * fp)200 snf_setfilter(pcap_t *p, struct bpf_program *fp)
201 {
202 if (!p)
203 return -1;
204 if (!fp) {
205 strncpy(p->errbuf, "setfilter: No filter specified",
206 sizeof(p->errbuf));
207 return -1;
208 }
209
210 /* Make our private copy of the filter */
211
212 if (install_bpf_program(p, fp) < 0)
213 return -1;
214
215 return (0);
216 }
217
218 static int
snf_inject(pcap_t * p,const void * buf _U_,size_t size _U_)219 snf_inject(pcap_t *p, const void *buf _U_, size_t size _U_)
220 {
221 #ifdef SNF_HAVE_INJECT_API
222 struct pcap_snf *ps = p->priv;
223 int rc;
224 if (ps->snf_inj == NULL) {
225 rc = snf_inject_open(ps->snf_boardnum, 0, &ps->snf_inj);
226 if (rc) {
227 snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
228 "snf_inject_open: %s", pcap_strerror(rc));
229 return (-1);
230 }
231 }
232
233 rc = snf_inject_send(ps->snf_inj, -1, 0, buf, size);
234 if (!rc) {
235 return (size);
236 }
237 else {
238 snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snf_inject_send: %s",
239 pcap_strerror(rc));
240 return (-1);
241 }
242 #else
243 strlcpy(p->errbuf, "Sending packets isn't supported with this snf version",
244 PCAP_ERRBUF_SIZE);
245 return (-1);
246 #endif
247 }
248
249 static int
snf_activate(pcap_t * p)250 snf_activate(pcap_t* p)
251 {
252 struct pcap_snf *ps = p->priv;
253 char *device = p->opt.source;
254 const char *nr = NULL;
255 int err;
256 int flags = -1, ring_id = -1;
257
258 if (device == NULL) {
259 snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
260 "device is NULL: %s", pcap_strerror(errno));
261 return -1;
262 }
263
264 /* In Libpcap, we set pshared by default if NUM_RINGS is set to > 1.
265 * Since libpcap isn't thread-safe */
266 if ((nr = getenv("SNF_FLAGS")) && *nr)
267 flags = strtol(nr, NULL, 0);
268 else if ((nr = getenv("SNF_NUM_RINGS")) && *nr && atoi(nr) > 1)
269 flags = SNF_F_PSHARED;
270 else
271 nr = NULL;
272
273 err = snf_open(ps->snf_boardnum,
274 0, /* let SNF API parse SNF_NUM_RINGS, if set */
275 NULL, /* default RSS, or use SNF_RSS_FLAGS env */
276 0, /* default to SNF_DATARING_SIZE from env */
277 flags, /* may want pshared */
278 &ps->snf_handle);
279 if (err != 0) {
280 snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
281 "snf_open failed: %s", pcap_strerror(err));
282 return -1;
283 }
284
285 if ((nr = getenv("SNF_PCAP_RING_ID")) && *nr) {
286 ring_id = (int) strtol(nr, NULL, 0);
287 }
288 err = snf_ring_open_id(ps->snf_handle, ring_id, &ps->snf_ring);
289 if (err != 0) {
290 snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
291 "snf_ring_open_id(ring=%d) failed: %s",
292 ring_id, pcap_strerror(err));
293 return -1;
294 }
295
296 if (p->opt.timeout <= 0)
297 ps->snf_timeout = -1;
298 else
299 ps->snf_timeout = p->opt.timeout;
300
301 err = snf_start(ps->snf_handle);
302 if (err != 0) {
303 snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
304 "snf_start failed: %s", pcap_strerror(err));
305 return -1;
306 }
307
308 /*
309 * "select()" and "poll()" don't work on snf descriptors.
310 */
311 p->selectable_fd = -1;
312 p->linktype = DLT_EN10MB;
313 p->read_op = snf_read;
314 p->inject_op = snf_inject;
315 p->setfilter_op = snf_setfilter;
316 p->setdirection_op = NULL; /* Not implemented.*/
317 p->set_datalink_op = snf_set_datalink;
318 p->getnonblock_op = snf_getnonblock;
319 p->setnonblock_op = snf_setnonblock;
320 p->stats_op = snf_pcap_stats;
321 p->cleanup_op = snf_platform_cleanup;
322 #ifdef SNF_HAVE_INJECT_API
323 ps->snf_inj = NULL;
324 #endif
325 return 0;
326 }
327
328 #define MAX_DESC_LENGTH 128
329 int
snf_findalldevs(pcap_if_t ** devlistp,char * errbuf)330 snf_findalldevs(pcap_if_t **devlistp, char *errbuf)
331 {
332 pcap_if_t *devlist = NULL,*curdev,*prevdev;
333 pcap_addr_t *curaddr;
334 struct snf_ifaddrs *ifaddrs, *ifa;
335 char desc[MAX_DESC_LENGTH];
336 int ret;
337
338 if (snf_init(SNF_VERSION_API))
339 return (-1);
340
341 if (snf_getifaddrs(&ifaddrs) || ifaddrs == NULL)
342 {
343 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
344 "snf_getifaddrs: %s", pcap_strerror(errno));
345 return (-1);
346 }
347 ifa = ifaddrs;
348 while (ifa)
349 {
350 /*
351 * Allocate a new entry
352 */
353 curdev = (pcap_if_t *)malloc(sizeof(pcap_if_t));
354 if (curdev == NULL) {
355 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
356 "snf_findalldevs malloc: %s", pcap_strerror(errno));
357 return (-1);
358 }
359 if (devlist == NULL) /* save first entry */
360 devlist = curdev;
361 else
362 prevdev->next = curdev;
363 /*
364 * Fill in the entry.
365 */
366 curdev->next = NULL;
367 curdev->name = strdup(ifa->snf_ifa_name);
368 if (curdev->name == NULL) {
369 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
370 "snf_findalldevs strdup: %s", pcap_strerror(errno));
371 free(curdev);
372 return (-1);
373 }
374 (void)snprintf(desc,MAX_DESC_LENGTH,"Myricom snf%d",
375 ifa->snf_ifa_portnum);
376 curdev->description = strdup(desc);
377 if (curdev->description == NULL) {
378 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
379 "snf_findalldevs strdup1: %s", pcap_strerror(errno));
380 free(curdev->name);
381 free(curdev);
382 return (-1);
383 }
384 curdev->addresses = NULL;
385 curdev->flags = 0;
386
387 curaddr = (pcap_addr_t *)malloc(sizeof(pcap_addr_t));
388 if (curaddr == NULL) {
389 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
390 "snf_findalldevs malloc1: %s", pcap_strerror(errno));
391 free(curdev->description);
392 free(curdev->name);
393 free(curdev);
394 return (-1);
395 }
396 curdev->addresses = curaddr;
397 curaddr->next = NULL;
398 curaddr->addr = (struct sockaddr*)malloc(sizeof(struct sockaddr_storage));
399 if (curaddr->addr == NULL) {
400 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
401 "malloc2: %s", pcap_strerror(errno));
402 free(curdev->description);
403 free(curdev->name);
404 free(curaddr);
405 free(curdev);
406 return (-1);
407 }
408 curaddr->addr->sa_family = AF_INET;
409 curaddr->netmask = NULL;
410 curaddr->broadaddr = NULL;
411 curaddr->dstaddr = NULL;
412 curaddr->next = NULL;
413
414 prevdev = curdev;
415 ifa = ifa->snf_ifa_next;
416 }
417 snf_freeifaddrs(ifaddrs);
418 *devlistp = devlist;
419
420 /*
421 * There are no platform-specific devices since each device
422 * exists as a regular Ethernet device.
423 */
424 return 0;
425 }
426
427 pcap_t *
snf_create(const char * device,char * ebuf,int * is_ours)428 snf_create(const char *device, char *ebuf, int *is_ours)
429 {
430 pcap_t *p;
431 int boardnum = -1;
432 struct snf_ifaddrs *ifaddrs, *ifa;
433 size_t devlen;
434 struct pcap_snf *ps;
435
436 if (snf_init(SNF_VERSION_API)) {
437 /* Can't initialize the API, so no SNF devices */
438 *is_ours = 0;
439 return NULL;
440 }
441
442 /*
443 * Match a given interface name to our list of interface names, from
444 * which we can obtain the intended board number
445 */
446 if (snf_getifaddrs(&ifaddrs) || ifaddrs == NULL) {
447 /* Can't get SNF addresses */
448 *is_ours = 0;
449 return NULL;
450 }
451 devlen = strlen(device) + 1;
452 ifa = ifaddrs;
453 while (ifa) {
454 if (!strncmp(device, ifa->snf_ifa_name, devlen)) {
455 boardnum = ifa->snf_ifa_boardnum;
456 break;
457 }
458 ifa = ifa->snf_ifa_next;
459 }
460 snf_freeifaddrs(ifaddrs);
461
462 if (ifa == NULL) {
463 /*
464 * If we can't find the device by name, support the name "snfX"
465 * and "snf10gX" where X is the board number.
466 */
467 if (sscanf(device, "snf10g%d", &boardnum) != 1 &&
468 sscanf(device, "snf%d", &boardnum) != 1) {
469 /* Nope, not a supported name */
470 *is_ours = 0;
471 return NULL;
472 }
473 }
474
475 /* OK, it's probably ours. */
476 *is_ours = 1;
477
478 p = pcap_create_common(device, ebuf, sizeof (struct pcap_snf));
479 if (p == NULL)
480 return NULL;
481 ps = p->priv;
482
483 /*
484 * We support microsecond and nanosecond time stamps.
485 */
486 p->tstamp_precision_count = 2;
487 p->tstamp_precision_list = malloc(2 * sizeof(u_int));
488 if (p->tstamp_precision_list == NULL) {
489 snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
490 pcap_strerror(errno));
491 if (p->tstamp_type_list != NULL)
492 free(p->tstamp_type_list);
493 free(p);
494 return NULL;
495 }
496 p->tstamp_precision_list[0] = PCAP_TSTAMP_PRECISION_MICRO;
497 p->tstamp_precision_list[1] = PCAP_TSTAMP_PRECISION_NANO;
498
499 p->activate_op = snf_activate;
500 ps->snf_boardnum = boardnum;
501 return p;
502 }
503