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