1/*
2 * Copyright (c) 2002 - 2005 NetGroup, Politecnico di Torino (Italy)
3 * Copyright (c) 2005 - 2008 CACE Technologies, Davis (California)
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the Politecnico di Torino, CACE Technologies
16 * nor the names of its contributors may be used to endorse or promote
17 * products derived from this software without specific prior written
18 * permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 *
32 */
33
34#ifdef HAVE_CONFIG_H
35#include <config.h>
36#endif
37
38#include "ftmacros.h"
39#include "diag-control.h"
40
41/*
42 * sockutils.h may include <crtdbg.h> on Windows, and pcap-int.h will
43 * include portability.h, and portability.h, on Windows, expects that
44 * <crtdbg.h> has already been included, so include sockutils.h first.
45 */
46#include "sockutils.h"
47#include "pcap-int.h"	// for the details of the pcap_t structure
48#include "pcap-rpcap.h"
49#include "rpcap-protocol.h"
50#include <errno.h>		// for the errno variable
51#include <stdlib.h>		// for malloc(), free(), ...
52#include <string.h>		// for strstr, etc
53
54#ifndef _WIN32
55#include <dirent.h>		// for readdir
56#endif
57
58/* String identifier to be used in the pcap_findalldevs_ex() */
59#define PCAP_TEXT_SOURCE_FILE "File"
60#define PCAP_TEXT_SOURCE_FILE_LEN (sizeof PCAP_TEXT_SOURCE_FILE - 1)
61/* String identifier to be used in the pcap_findalldevs_ex() */
62#define PCAP_TEXT_SOURCE_ADAPTER "Network adapter"
63#define PCAP_TEXT_SOURCE_ADAPTER_LEN (sizeof "Network adapter" - 1)
64
65/* String identifier to be used in the pcap_findalldevs_ex() */
66#define PCAP_TEXT_SOURCE_ON_LOCAL_HOST "on local host"
67#define PCAP_TEXT_SOURCE_ON_LOCAL_HOST_LEN (sizeof PCAP_TEXT_SOURCE_ON_LOCAL_HOST + 1)
68
69/****************************************************
70 *                                                  *
71 * Function bodies                                  *
72 *                                                  *
73 ****************************************************/
74
75int pcap_findalldevs_ex(const char *source, struct pcap_rmtauth *auth, pcap_if_t **alldevs, char *errbuf)
76{
77	int type;
78	char name[PCAP_BUF_SIZE], path[PCAP_BUF_SIZE], filename[PCAP_BUF_SIZE];
79	size_t pathlen;
80	size_t stringlen;
81	pcap_t *fp;
82	char tmpstring[PCAP_BUF_SIZE + 1];		/* Needed to convert names and descriptions from 'old' syntax to the 'new' one */
83	pcap_if_t *lastdev;	/* Last device in the pcap_if_t list */
84	pcap_if_t *dev;		/* Device we're adding to the pcap_if_t list */
85
86	/* List starts out empty. */
87	(*alldevs) = NULL;
88	lastdev = NULL;
89
90	if (strlen(source) > PCAP_BUF_SIZE)
91	{
92		snprintf(errbuf, PCAP_ERRBUF_SIZE, "The source string is too long. Cannot handle it correctly.");
93		return -1;
94	}
95
96	/*
97	 * Determine the type of the source (file, local, remote)
98	 * There are some differences if pcap_findalldevs_ex() is called to list files and remote adapters.
99	 * In the first case, the name of the directory we have to look into must be present (therefore
100	 * the 'name' parameter of the pcap_parsesrcstr() is present).
101	 * In the second case, the name of the adapter is not required (we need just the host). So, we have
102	 * to use a first time this function to get the source type, and a second time to get the appropriate
103	 * info, which depends on the source type.
104	 */
105	if (pcap_parsesrcstr(source, &type, NULL, NULL, NULL, errbuf) == -1)
106		return -1;
107
108	switch (type)
109	{
110	case PCAP_SRC_IFLOCAL:
111		if (pcap_parsesrcstr(source, &type, NULL, NULL, NULL, errbuf) == -1)
112			return -1;
113
114		/* Initialize temporary string */
115		tmpstring[PCAP_BUF_SIZE] = 0;
116
117		/* The user wants to retrieve adapters from a local host */
118		if (pcap_findalldevs(alldevs, errbuf) == -1)
119			return -1;
120
121		if (*alldevs == NULL)
122		{
123			snprintf(errbuf, PCAP_ERRBUF_SIZE,
124				"No interfaces found! Make sure libpcap/Npcap is properly installed"
125				" on the local machine.");
126			return -1;
127		}
128
129		/* Scan all the interfaces and modify name and description */
130		/* This is a trick in order to avoid the re-implementation of the pcap_findalldevs here */
131		dev = *alldevs;
132		while (dev)
133		{
134			char *localdesc, *desc;
135
136			/* Create the new device identifier */
137			if (pcap_createsrcstr(tmpstring, PCAP_SRC_IFLOCAL, NULL, NULL, dev->name, errbuf) == -1)
138				return -1;
139
140			/* Delete the old pointer */
141			free(dev->name);
142
143			/* Make a copy of the new device identifier */
144			dev->name = strdup(tmpstring);
145			if (dev->name == NULL)
146			{
147				pcap_fmt_errmsg_for_errno(errbuf,
148				    PCAP_ERRBUF_SIZE, errno,
149				    "malloc() failed");
150				pcap_freealldevs(*alldevs);
151				return -1;
152			}
153
154			/*
155			 * Create the description.
156			 */
157			if ((dev->description == NULL) || (dev->description[0] == 0))
158				localdesc = dev->name;
159			else
160				localdesc = dev->description;
161			if (pcap_asprintf(&desc, "%s '%s' %s",
162			    PCAP_TEXT_SOURCE_ADAPTER, localdesc,
163			    PCAP_TEXT_SOURCE_ON_LOCAL_HOST) == -1)
164			{
165				pcap_fmt_errmsg_for_errno(errbuf,
166				    PCAP_ERRBUF_SIZE, errno,
167				    "malloc() failed");
168				pcap_freealldevs(*alldevs);
169				return -1;
170			}
171
172			/* Now overwrite the description */
173			free(dev->description);
174			dev->description = desc;
175
176			dev = dev->next;
177		}
178
179		return 0;
180
181	case PCAP_SRC_FILE:
182	{
183#ifdef _WIN32
184		WIN32_FIND_DATA filedata;
185		HANDLE filehandle;
186#else
187		struct dirent *filedata;
188		DIR *unixdir;
189#endif
190
191		if (pcap_parsesrcstr(source, &type, NULL, NULL, name, errbuf) == -1)
192			return -1;
193
194		/* Check that the filename is correct */
195		stringlen = strlen(name);
196
197		/* The directory must end with '\' in Win32 and '/' in UNIX */
198#ifdef _WIN32
199#define ENDING_CHAR '\\'
200#else
201#define ENDING_CHAR '/'
202#endif
203
204		if (name[stringlen - 1] != ENDING_CHAR)
205		{
206			name[stringlen] = ENDING_CHAR;
207			name[stringlen + 1] = 0;
208
209			stringlen++;
210		}
211
212		/* Save the path for future reference */
213		snprintf(path, sizeof(path), "%s", name);
214		pathlen = strlen(path);
215
216#ifdef _WIN32
217		/* To perform directory listing, Win32 must have an 'asterisk' as ending char */
218		if (name[stringlen - 1] != '*')
219		{
220			name[stringlen] = '*';
221			name[stringlen + 1] = 0;
222		}
223
224		filehandle = FindFirstFile(name, &filedata);
225
226		if (filehandle == INVALID_HANDLE_VALUE)
227		{
228			snprintf(errbuf, PCAP_ERRBUF_SIZE, "Error when listing files: does folder '%s' exist?", path);
229			return -1;
230		}
231
232#else
233		/* opening the folder */
234		unixdir= opendir(path);
235
236		/* get the first file into it */
237		filedata= readdir(unixdir);
238
239		if (filedata == NULL)
240		{
241			DIAG_OFF_FORMAT_TRUNCATION
242			snprintf(errbuf, PCAP_ERRBUF_SIZE, "Error when listing files: does folder '%s' exist?", path);
243			DIAG_ON_FORMAT_TRUNCATION
244			closedir(unixdir);
245			return -1;
246		}
247#endif
248
249		/* Add all files we find to the list. */
250		do
251		{
252#ifdef _WIN32
253			/* Skip the file if the pathname won't fit in the buffer */
254			if (pathlen + strlen(filedata.cFileName) >= sizeof(filename))
255				continue;
256			snprintf(filename, sizeof(filename), "%s%s", path, filedata.cFileName);
257#else
258			if (pathlen + strlen(filedata->d_name) >= sizeof(filename))
259				continue;
260			DIAG_OFF_FORMAT_TRUNCATION
261			snprintf(filename, sizeof(filename), "%s%s", path, filedata->d_name);
262			DIAG_ON_FORMAT_TRUNCATION
263#endif
264
265			fp = pcap_open_offline(filename, errbuf);
266
267			if (fp)
268			{
269				/* allocate the main structure */
270				dev = (pcap_if_t *)malloc(sizeof(pcap_if_t));
271				if (dev == NULL)
272				{
273					pcap_fmt_errmsg_for_errno(errbuf,
274					    PCAP_ERRBUF_SIZE, errno,
275					    "malloc() failed");
276					pcap_freealldevs(*alldevs);
277#ifdef _WIN32
278					FindClose(filehandle);
279#else
280					closedir(unixdir);
281#endif
282					return -1;
283				}
284
285				/* Initialize the structure to 'zero' */
286				memset(dev, 0, sizeof(pcap_if_t));
287
288				/* Append it to the list. */
289				if (lastdev == NULL)
290				{
291					/*
292					 * List is empty, so it's also
293					 * the first device.
294					 */
295					*alldevs = dev;
296				}
297				else
298				{
299					/*
300					 * Append after the last device.
301					 */
302					lastdev->next = dev;
303				}
304				/* It's now the last device. */
305				lastdev = dev;
306
307				/* Create the new source identifier */
308				if (pcap_createsrcstr(tmpstring, PCAP_SRC_FILE, NULL, NULL, filename, errbuf) == -1)
309				{
310					pcap_freealldevs(*alldevs);
311#ifdef _WIN32
312					FindClose(filehandle);
313#else
314					closedir(unixdir);
315#endif
316					return -1;
317				}
318
319				dev->name = strdup(tmpstring);
320				if (dev->name == NULL)
321				{
322					pcap_fmt_errmsg_for_errno(errbuf,
323					    PCAP_ERRBUF_SIZE, errno,
324					    "malloc() failed");
325					pcap_freealldevs(*alldevs);
326#ifdef _WIN32
327					FindClose(filehandle);
328#else
329					closedir(unixdir);
330#endif
331					return -1;
332				}
333
334				/*
335				 * Create the description.
336				 */
337				if (pcap_asprintf(&dev->description,
338				    "%s '%s' %s", PCAP_TEXT_SOURCE_FILE,
339				    filename, PCAP_TEXT_SOURCE_ON_LOCAL_HOST) == -1)
340				{
341					pcap_fmt_errmsg_for_errno(errbuf,
342					    PCAP_ERRBUF_SIZE, errno,
343					    "malloc() failed");
344					pcap_freealldevs(*alldevs);
345#ifdef _WIN32
346					FindClose(filehandle);
347#else
348					closedir(unixdir);
349#endif
350					return -1;
351				}
352
353				pcap_close(fp);
354			}
355		}
356#ifdef _WIN32
357		while (FindNextFile(filehandle, &filedata) != 0);
358#else
359		while ( (filedata= readdir(unixdir)) != NULL);
360#endif
361
362
363		/* Close the search handle. */
364#ifdef _WIN32
365		FindClose(filehandle);
366#else
367		closedir(unixdir);
368#endif
369
370		return 0;
371	}
372
373	case PCAP_SRC_IFREMOTE:
374		return pcap_findalldevs_ex_remote(source, auth, alldevs, errbuf);
375
376	default:
377		pcap_strlcpy(errbuf, "Source type not supported", PCAP_ERRBUF_SIZE);
378		return -1;
379	}
380}
381
382pcap_t *pcap_open(const char *source, int snaplen, int flags, int read_timeout, struct pcap_rmtauth *auth, char *errbuf)
383{
384	char name[PCAP_BUF_SIZE];
385	int type;
386	pcap_t *fp;
387	int status;
388
389	/*
390	 * A null device name is equivalent to the "any" device -
391	 * which might not be supported on this platform, but
392	 * this means that you'll get a "not supported" error
393	 * rather than, say, a crash when we try to dereference
394	 * the null pointer.
395	 */
396	if (source == NULL)
397		source = "any";
398
399	if (strlen(source) > PCAP_BUF_SIZE)
400	{
401		snprintf(errbuf, PCAP_ERRBUF_SIZE, "The source string is too long. Cannot handle it correctly.");
402		return NULL;
403	}
404
405	/*
406	 * Determine the type of the source (file, local, remote) and,
407	 * if it's file or local, the name of the file or capture device.
408	 */
409	if (pcap_parsesrcstr(source, &type, NULL, NULL, name, errbuf) == -1)
410		return NULL;
411
412	switch (type)
413	{
414	case PCAP_SRC_FILE:
415		return pcap_open_offline(name, errbuf);
416
417	case PCAP_SRC_IFLOCAL:
418		fp = pcap_create(name, errbuf);
419		break;
420
421	case PCAP_SRC_IFREMOTE:
422		/*
423		 * Although we already have host, port and iface, we prefer
424		 * to pass only 'source' to pcap_open_rpcap(), so that it
425		 * has to call pcap_parsesrcstr() again.
426		 * This is less optimized, but much clearer.
427		 */
428		return pcap_open_rpcap(source, snaplen, flags, read_timeout, auth, errbuf);
429
430	default:
431		pcap_strlcpy(errbuf, "Source type not supported", PCAP_ERRBUF_SIZE);
432		return NULL;
433	}
434
435	if (fp == NULL)
436		return (NULL);
437	status = pcap_set_snaplen(fp, snaplen);
438	if (status < 0)
439		goto fail;
440	if (flags & PCAP_OPENFLAG_PROMISCUOUS)
441	{
442		status = pcap_set_promisc(fp, 1);
443		if (status < 0)
444			goto fail;
445	}
446	if (flags & PCAP_OPENFLAG_MAX_RESPONSIVENESS)
447	{
448		status = pcap_set_immediate_mode(fp, 1);
449		if (status < 0)
450			goto fail;
451	}
452#ifdef _WIN32
453	/*
454	 * This flag is supported on Windows only.
455	 * XXX - is there a way to support it with
456	 * the capture mechanisms on UN*X?  It's not
457	 * exactly a "set direction" operation; I
458	 * think it means "do not capture packets
459	 * injected with pcap_sendpacket() or
460	 * pcap_inject()".
461	 */
462	/* disable loopback capture if requested */
463	if (flags & PCAP_OPENFLAG_NOCAPTURE_LOCAL)
464		fp->opt.nocapture_local = 1;
465#endif /* _WIN32 */
466	status = pcap_set_timeout(fp, read_timeout);
467	if (status < 0)
468		goto fail;
469	status = pcap_activate(fp);
470	if (status < 0)
471		goto fail;
472	return fp;
473
474fail:
475	DIAG_OFF_FORMAT_TRUNCATION
476	if (status == PCAP_ERROR)
477		snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s",
478		    name, fp->errbuf);
479	else if (status == PCAP_ERROR_NO_SUCH_DEVICE ||
480	    status == PCAP_ERROR_PERM_DENIED ||
481	    status == PCAP_ERROR_PROMISC_PERM_DENIED)
482		snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s (%s)",
483		    name, pcap_statustostr(status), fp->errbuf);
484	else
485		snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s",
486		    name, pcap_statustostr(status));
487	DIAG_ON_FORMAT_TRUNCATION
488	pcap_close(fp);
489	return NULL;
490}
491
492struct pcap_samp *pcap_setsampling(pcap_t *p)
493{
494	return &p->rmt_samp;
495}
496