pcap.h

Go to the documentation of this file.

//\{ 

typedef void (*pcap_handler)(u_char *user, const struct pcap_pkthdr *pkt_header,
                 const u_char *pkt_data);

pcap_t *pcap_open_live(const char *device, int snaplen, int promisc, int to_ms, char *ebuf);


pcap_t *pcap_open_dead(int linktype, int snaplen);


pcap_t *pcap_open_offline(const char *fname, char *errbuf);

pcap_dumper_t *pcap_dump_open(pcap_t *p, const char *fname);

int pcap_setnonblock(pcap_t *p, int nonblock, char *errbuf);


int pcap_getnonblock(pcap_t *p, char *errbuf);

int pcap_findalldevs(pcap_if_t **alldevsp, char *errbuf);

void pcap_freealldevs(pcap_if_t *alldevsp);

char *pcap_lookupdev(char *errbuf);


int pcap_lookupnet(const char *device, bpf_u_int32 *netp, bpf_u_int32 *maskp, char *errbuf);

int pcap_dispatch(pcap_t *p, int cnt, pcap_handler callback, u_char *user);


int pcap_loop(pcap_t *p, int cnt, pcap_handler callback, u_char *user);


u_char *pcap_next(pcap_t *p, struct pcap_pkthdr *h);

int pcap_next_ex(pcap_t *p, struct pcap_pkthdr **pkt_header, const u_char **pkt_data);

void pcap_breakloop(pcap_t *);

int pcap_sendpacket(pcap_t *p, u_char *buf, int size);  

void pcap_dump(u_char *user, const struct pcap_pkthdr *h, const u_char *sp);

long pcap_dump_ftell(pcap_dumper_t *);

int pcap_compile(pcap_t *p, struct bpf_program *fp, char *str, int optimize, bpf_u_int32 netmask);

int pcap_compile_nopcap(int snaplen_arg, int linktype_arg, struct bpf_program *program, char *buf, int optimize, bpf_u_int32 mask);


int pcap_setfilter(pcap_t *p, struct bpf_program *fp);


void pcap_freecode(struct bpf_program *fp);

int pcap_datalink(pcap_t *p);

int pcap_list_datalinks(pcap_t *p, int **dlt_buf);

int pcap_set_datalink(pcap_t *p, int dlt);

int pcap_datalink_name_to_val(const char *name);

const char *pcap_datalink_val_to_name(int dlt);

const char *pcap_datalink_val_to_description(int dlt);


int pcap_snapshot(pcap_t *p);


int pcap_is_swapped(pcap_t *p);


int pcap_major_version(pcap_t *p);


int pcap_minor_version(pcap_t *p);

FILE *pcap_file(pcap_t *p);

int pcap_stats(pcap_t *p, struct pcap_stat *ps);

void pcap_perror(pcap_t *p, char *prefix);


char *pcap_geterr(pcap_t *p);


char *pcap_strerror(int error);

const char *pcap_lib_version(void);

void pcap_close(pcap_t *p);

FILE *pcap_dump_file(pcap_dumper_t *p);

int pcap_dump_flush(pcap_dumper_t *p);

void pcap_dump_close(pcap_dumper_t *p);

//\}
// End of Unix-compatible functions







//\{ 

PAirpcapHandle pcap_get_airpcap_handle(pcap_t *p);

bool pcap_offline_filter(struct bpf_program *prog, const struct pcap_pkthdr *header, const u_char *pkt_data);

int pcap_live_dump(pcap_t *p, char *filename, int maxsize, int maxpacks);


int pcap_live_dump_ended(pcap_t *p, int sync);


struct pcap_stat *pcap_stats_ex(pcap_t *p, int *pcap_stat_size);

int pcap_setbuff(pcap_t *p, int dim);


int pcap_setmode(pcap_t *p, int mode);


int pcap_setmintocopy(pcap_t *p, int size);



HANDLE pcap_getevent(pcap_t *p);

pcap_send_queue* pcap_sendqueue_alloc(u_int memsize);

void pcap_sendqueue_destroy(pcap_send_queue* queue);

int pcap_sendqueue_queue(pcap_send_queue* queue, const struct pcap_pkthdr *pkt_header, const u_char *pkt_data);


u_int pcap_sendqueue_transmit(pcap_t *p, pcap_send_queue* queue, int sync);


int pcap_findalldevs_ex(char *source, struct pcap_rmtauth *auth, pcap_if_t **alldevs, char *errbuf);


int pcap_createsrcstr(char *source, int type, const char *host, const char *port, const char *name, char *errbuf);


int pcap_parsesrcstr(const char *source, int *type, char *host, char *port, char *name, char *errbuf);

pcap_t *pcap_open(const char *source, int snaplen, int flags, int read_timeout, struct pcap_rmtauth *auth, char *errbuf);

struct pcap_samp *pcap_setsampling(pcap_t *p);

SOCKET pcap_remoteact_accept(const char *address, const char *port, const char *hostlist, char *connectinghost, struct pcap_rmtauth *auth, char *errbuf);

int pcap_remoteact_close(const char *host, char *errbuf);

void pcap_remoteact_cleanup();

int pcap_remoteact_list(char *hostlist, char sep, int size, char *errbuf);

//\}
// End of Windows-specific extensions

---

documentation. Copyright (c) 2002-2005 Politecnico di Torino. Copyright (c) 2005-2008 CACE Technologies. All rights reserved.