196 lines
4.2 KiB
C
196 lines
4.2 KiB
C
/*
|
|
* Copyright (c) 1993, 1994, 1995, 1996
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the Computer Systems
|
|
* Engineering Group at Lawrence Berkeley Laboratory.
|
|
* 4. Neither the name of the University nor of the Laboratory may be used
|
|
* to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef lint
|
|
static char rcsid[] =
|
|
"@(#) $Header: pcap.c,v 1.25 96/06/05 21:45:26 leres Exp $ (LBL)";
|
|
#endif
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include "gnuc.h"
|
|
#ifdef HAVE_OS_PROTO_H
|
|
#include "os-proto.h"
|
|
#endif
|
|
|
|
#include "pcap-int.h"
|
|
|
|
int
|
|
pcap_dispatch(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
|
|
{
|
|
register int cc;
|
|
|
|
if (p->sf.rfile != NULL)
|
|
return (pcap_offline_read(p, cnt, callback, user));
|
|
/* XXX keep reading until we get something (or an error occurs) */
|
|
do {
|
|
cc = pcap_read(p, cnt, callback, user);
|
|
} while (cc == 0);
|
|
return (cc);
|
|
}
|
|
|
|
int
|
|
pcap_loop(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
|
|
{
|
|
for (;;) {
|
|
int n = pcap_dispatch(p, cnt, callback, user);
|
|
if (n <= 0)
|
|
return (n);
|
|
if (cnt > 0) {
|
|
cnt -= n;
|
|
if (cnt <= 0)
|
|
return (0);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct singleton {
|
|
struct pcap_pkthdr *hdr;
|
|
const u_char *pkt;
|
|
};
|
|
|
|
|
|
static void
|
|
pcap_oneshot(u_char *userData, const struct pcap_pkthdr *h, const u_char *pkt)
|
|
{
|
|
struct singleton *sp = (struct singleton *)userData;
|
|
*sp->hdr = *h;
|
|
sp->pkt = pkt;
|
|
}
|
|
|
|
const u_char *
|
|
pcap_next(pcap_t *p, struct pcap_pkthdr *h)
|
|
{
|
|
struct singleton s;
|
|
|
|
s.hdr = h;
|
|
if (pcap_dispatch(p, 1, pcap_oneshot, (u_char*)&s) <= 0)
|
|
return (0);
|
|
return (s.pkt);
|
|
}
|
|
|
|
int
|
|
pcap_datalink(pcap_t *p)
|
|
{
|
|
return (p->linktype);
|
|
}
|
|
|
|
int
|
|
pcap_snapshot(pcap_t *p)
|
|
{
|
|
return (p->snapshot);
|
|
}
|
|
|
|
int
|
|
pcap_is_swapped(pcap_t *p)
|
|
{
|
|
return (p->sf.swapped);
|
|
}
|
|
|
|
int
|
|
pcap_major_version(pcap_t *p)
|
|
{
|
|
return (p->sf.version_major);
|
|
}
|
|
|
|
int
|
|
pcap_minor_version(pcap_t *p)
|
|
{
|
|
return (p->sf.version_minor);
|
|
}
|
|
|
|
FILE *
|
|
pcap_file(pcap_t *p)
|
|
{
|
|
return (p->sf.rfile);
|
|
}
|
|
|
|
int
|
|
pcap_fileno(pcap_t *p)
|
|
{
|
|
return (p->fd);
|
|
}
|
|
|
|
void
|
|
pcap_perror(pcap_t *p, char *prefix)
|
|
{
|
|
fprintf(stderr, "%s: %s\n", prefix, p->errbuf);
|
|
}
|
|
|
|
char *
|
|
pcap_geterr(pcap_t *p)
|
|
{
|
|
return (p->errbuf);
|
|
}
|
|
|
|
/*
|
|
* Not all systems have strerror().
|
|
*/
|
|
char *
|
|
pcap_strerror(int errnum)
|
|
{
|
|
#ifdef HAVE_STRERROR
|
|
return (strerror(errnum));
|
|
#else
|
|
extern int sys_nerr;
|
|
extern const char *const sys_errlist[];
|
|
static char ebuf[20];
|
|
|
|
if ((unsigned int)errnum < sys_nerr)
|
|
return ((char *)sys_errlist[errnum]);
|
|
(void)sprintf(ebuf, "Unknown error: %d", errnum);
|
|
return(ebuf);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
pcap_close(pcap_t *p)
|
|
{
|
|
/*XXX*/
|
|
if (p->fd >= 0)
|
|
close(p->fd);
|
|
if (p->sf.rfile != NULL) {
|
|
(void)fclose(p->sf.rfile);
|
|
if (p->sf.base != NULL)
|
|
free(p->sf.base);
|
|
} else if (p->buffer != NULL)
|
|
free(p->buffer);
|
|
|
|
free(p);
|
|
}
|