1 .\" @(#) $Header: /tcpdump/master/libpcap/pcap.3,v 1.51.2.9 2004/03/28 21:45:32 fenner Exp $
3 .\" Copyright (c) 1994, 1996, 1997
4 .\" The Regents of the University of California. All rights reserved.
6 .\" Redistribution and use in source and binary forms, with or without
7 .\" modification, are permitted provided that: (1) source code distributions
8 .\" retain the above copyright notice and this paragraph in its entirety, (2)
9 .\" distributions including binary code include the above copyright notice and
10 .\" this paragraph in its entirety in the documentation or other materials
11 .\" provided with the distribution, and (3) all advertising materials mentioning
12 .\" features or use of this software display the following acknowledgement:
13 .\" ``This product includes software developed by the University of California,
14 .\" Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
15 .\" the University nor the names of its contributors may be used to endorse
16 .\" or promote products derived from this software without specific prior
17 .\" written permission.
18 .\" THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
19 .\" WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
20 .\" MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
24 .TH PCAP 3 "27 February 2004"
26 pcap \- Packet Capture library
35 char errbuf[PCAP_ERRBUF_SIZE];
39 pcap_t *pcap_open_live(const char *device, int snaplen,
41 int promisc, int to_ms, char *errbuf)
42 pcap_t *pcap_open_dead(int linktype, int snaplen)
43 pcap_t *pcap_open_offline(const char *fname, char *errbuf)
44 pcap_dumper_t *pcap_dump_open(pcap_t *p, const char *fname)
48 int pcap_setnonblock(pcap_t *p, int nonblock, char *errbuf);
49 int pcap_getnonblock(pcap_t *p, char *errbuf);
53 int pcap_findalldevs(pcap_if_t **alldevsp, char *errbuf)
54 void pcap_freealldevs(pcap_if_t *alldevs)
55 char *pcap_lookupdev(char *errbuf)
56 int pcap_lookupnet(const char *device, bpf_u_int32 *netp,
58 bpf_u_int32 *maskp, char *errbuf)
62 int pcap_dispatch(pcap_t *p, int cnt,
64 pcap_handler callback, u_char *user)
65 int pcap_loop(pcap_t *p, int cnt,
67 pcap_handler callback, u_char *user)
68 void pcap_dump(u_char *user, struct pcap_pkthdr *h,
74 int pcap_compile(pcap_t *p, struct bpf_program *fp,
76 char *str, int optimize, bpf_u_int32 netmask)
77 int pcap_setfilter(pcap_t *p, struct bpf_program *fp)
78 void pcap_freecode(struct bpf_program *);
82 const u_char *pcap_next(pcap_t *p, struct pcap_pkthdr *h)
83 int pcap_next_ex(pcap_t *p, struct pcap_pkthdr **pkt_header,
85 const u_char **pkt_data)
89 void pcap_breakloop(pcap_t *)
93 int pcap_datalink(pcap_t *p)
94 int pcap_list_datalinks(pcap_t *p, int **dlt_buf);
95 int pcap_set_datalink(pcap_t *p, int dlt);
96 int pcap_datalink_name_to_val(const char *name);
97 const char *pcap_datalink_val_to_name(int dlt);
98 const char *pcap_datalink_val_to_description(int dlt);
99 int pcap_snapshot(pcap_t *p)
100 int pcap_is_swapped(pcap_t *p)
101 int pcap_major_version(pcap_t *p)
102 int pcap_minor_version(pcap_t *p)
103 int pcap_stats(pcap_t *p, struct pcap_stat *ps)
104 FILE *pcap_file(pcap_t *p)
105 int pcap_fileno(pcap_t *p)
106 int pcap_get_selectable_fd(pcap_t *p)
107 void pcap_perror(pcap_t *p, char *prefix)
108 char *pcap_geterr(pcap_t *p)
109 char *pcap_strerror(int error)
110 const char *pcap_lib_version(void)
114 void pcap_close(pcap_t *p)
115 int pcap_dump_flush(pcap_dumper_t *p)
116 FILE *pcap_dump_file(pcap_dumper_t *p)
117 void pcap_dump_close(pcap_dumper_t *p)
121 The Packet Capture library
122 provides a high level interface to packet capture systems. All packets
123 on the network, even those destined for other hosts, are accessible
124 through this mechanism.
130 .BR pcap_open_live() ,
131 .BR pcap_open_dead() ,
132 .BR pcap_open_offline() ,
133 .BR pcap_setnonblock() ,
134 .BR pcap_getnonblock() ,
135 .BR pcap_findalldevs() ,
136 .BR pcap_lookupdev() ,
139 is assumed to be able to hold at least
144 is used to obtain a packet capture descriptor to look
145 at packets on the network.
147 is a string that specifies the network device to open; on Linux systems
148 with 2.2 or later kernels, a
152 can be used to capture packets from all interfaces.
154 specifies the maximum number of bytes to capture. If this value is less
155 than the size of a packet that is captured, only the first
157 bytes of that packet will be captured and provided as packet data. A
158 value of 65535 should be sufficient, on most if not all networks, to
159 capture all the data available from the packet.
161 specifies if the interface is to be put into promiscuous mode.
162 (Note that even if this parameter is false, the interface
163 could well be in promiscuous mode for some other reason.) For now, this
164 doesn't work on the "any" device; if an argument of "any" or NULL is
169 specifies the read timeout in milliseconds. The read timeout is used to
170 arrange that the read not necessarily return immediately when a packet
171 is seen, but that it wait for some amount of time to allow more packets
172 to arrive and to read multiple packets from the OS kernel in one
173 operation. Not all platforms support a read timeout; on platforms that
174 don't, the read timeout is ignored. A zero value for
176 on platforms that support a read timeout,
177 will cause a read to wait forever to allow enough packets to
178 arrive, with no timeout.
180 is used to return error or warning text. It will be set to error text when
185 may also be set to warning text when
187 succeds; to detect this case the caller should store a zero-length string in
191 and display the warning to the user if
193 is no longer a zero-length string.
196 is used for creating a
198 structure to use when calling the other functions in libpcap. It is
199 typically used when just using libpcap for compiling BPF code.
201 .B pcap_open_offline()
202 is called to open a ``savefile'' for reading.
204 specifies the name of the file to open. The file has
205 the same format as those used by
209 The name "-" in a synonym for
212 is used to return error text and is only set when
213 .B pcap_open_offline()
218 is called to open a ``savefile'' for writing. The name "-" in a synonym
222 is returned on failure.
226 struct as returned by
227 .B pcap_open_offline()
229 .BR pcap_open_live() .
231 specifies the name of the file to open.
236 can be used to get the error text.
238 .B pcap_setnonblock()
239 puts a capture descriptor, opened with
240 .BR pcap_open_live() ,
241 into ``non-blocking'' mode, or takes it out of ``non-blocking'' mode,
242 depending on whether the
244 argument is non-zero or zero. It has no effect on ``savefiles''.
245 If there is an error, \-1 is returned and
247 is filled in with an appropriate error message; otherwise, 0 is
250 ``non-blocking'' mode, an attempt to read from the capture descriptor
253 will, if no packets are currently available to be read, return 0
254 immediately rather than blocking waiting for packets to arrive.
258 will not work in ``non-blocking'' mode.
260 .B pcap_getnonblock()
261 returns the current ``non-blocking'' state of the capture descriptor; it
262 always returns 0 on ``savefiles''.
263 If there is an error, \-1 is returned and
265 is filled in with an appropriate error message.
267 .B pcap_findalldevs()
268 constructs a list of network devices that can be opened with
269 .BR pcap_open_live() .
270 (Note that there may be network devices that cannot be opened with
274 .BR pcap_findalldevs() ,
275 because, for example, that process might not have sufficient privileges
276 to open them for capturing; if so, those devices will not appear on the
279 is set to point to the first element of the list; each element of the
282 and has the following members:
288 a pointer to the next element in the list;
290 for the last element of the list
293 a pointer to a string giving a name for the device to pass to
299 a pointer to a string giving a human-readable description of the device
302 a pointer to the first element of a list of addresses for the interface
309 set if the interface is a loopback interface
313 Each element of the list of addresses is of type
315 and has the following members:
321 a pointer to the next element in the list;
323 for the last element of the list
328 containing an address
335 that contains the netmask corresponding to the address pointed to by
343 that contains the broadcast address corresponding to the address pointed
346 may be null if the interface doesn't support broadcasts
353 that contains the destination address corresponding to the address pointed
356 may be null if the interface isn't a point-to-point interface
360 is returned on failure, in which case
362 is filled in with an appropriate error message;
364 is returned on success.
366 .B pcap_freealldevs()
367 is used to free a list allocated by
368 .BR pcap_findalldevs() .
371 returns a pointer to a network device suitable for use with
374 .BR pcap_lookupnet() .
375 If there is an error,
379 is filled in with an appropriate error message.
382 is used to determine the network number and mask
383 associated with the network device
392 A return of \-1 indicates an error in which case
394 is filled in with an appropriate error message.
397 is used to collect and process packets.
399 specifies the maximum number of packets to process before returning.
400 This is not a minimum number; when reading a live capture, only one
401 bufferful of packets is read at a time, so fewer than
403 packets may be processed. A
405 of \-1 processes all the packets received in one buffer when reading a
406 live capture, or all the packets in the file when reading a
409 specifies a routine to be called with three arguments:
412 pointer which is passed in from
413 .BR pcap_dispatch() ,
415 .I const struct pcap_pkthdr
416 pointer to a structure with the following members:
422 containing the time when the packet was captured
427 giving the number of bytes of the packet that are available from the
433 giving the length of the packet, in bytes (which might be more than the
434 number of bytes available from the capture, if the length of the packet
435 is larger than the maximum number of bytes to capture)
443 .I struct pcap_pkthdr
444 a pointer to which is passed to the callback routine)
445 bytes of data from the packet (which won't necessarily be the entire
446 packet; to capture the entire packet, you will have to provide a value
451 that is sufficiently large to get all of the packet's data - a value of
452 65535 should be sufficient on most if not all networks).
454 The number of packets read is returned.
455 0 is returned if no packets were read from a live capture (if, for
456 example, they were discarded because they didn't pass the packet filter,
457 or if, on platforms that support a read timeout that starts before any
458 packets arrive, the timeout expires before any packets arrive, or if the
459 file descriptor for the capture device is in non-blocking mode and no
460 packets were available to be read) or if no more packets are available
461 in a ``savefile.'' A return of \-1 indicates
462 an error in which case
466 may be used to display the error text.
467 A return of \-2 indicates that the loop terminated due to a call to
469 before any packets were processed.
471 If your application uses pcap_breakloop(),
472 make sure that you explicitly check for \-1 and \-2, rather than just
473 checking for a return value < 0.
477 when reading a live capture,
479 will not necessarily return when the read times out; on some platforms,
480 the read timeout isn't supported, and, on other platforms, the timer
481 doesn't start until at least one packet arrives. This means that the
484 be used in, for example, an interactive application, to allow the packet
485 capture loop to ``poll'' for user input periodically, as there's no
488 will return after the timeout expires.
493 except it keeps reading packets until
495 packets are processed or an error occurs.
498 return when live read timeouts occur.
499 Rather, specifying a non-zero read timeout to
503 allows the reception and processing of any packets that arrive when the
509 to loop forever (or at least until an error occurs). \-1 is returned on
510 an error; 0 is returned if
512 is exhausted; \-2 is returned if the loop terminated due to a call to
514 before any packets were processed.
516 If your application uses pcap_breakloop(),
517 make sure that you explicitly check for \-1 and \-2, rather than just
518 checking for a return value < 0.
522 reads the next packet (by calling
528 pointer to the data in that packet. (The
530 struct for that packet is not supplied.)
532 is returned if an error occured, or if no packets were read from a live
533 capture (if, for example, they were discarded because they didn't pass
534 the packet filter, or if, on platforms that support a read timeout that
535 starts before any packets arrive, the timeout expires before any packets
536 arrive, or if the file descriptor for the capture device is in
537 non-blocking mode and no packets were available to be read), or if no
538 more packets are available in a ``savefile.'' Unfortunately, there is
539 no way to determine whether an error occured or not.
542 reads the next packet and returns a success/failure indication:
546 the packet was read without problems
549 packets are being read from a live capture, and the timeout expired
552 an error occurred while reading the packet
555 packets are being read from a ``savefile'', and there are no more
556 packets to read from the savefile.
559 If the packet was read without problems, the pointer pointed to by the
561 argument is set to point to the
563 struct for the packet, and the
564 pointer pointed to by the
566 argument is set to point to the data in the packet.
569 sets a flag that will force
573 to return rather than looping; they will return the number of packets
574 that have been processed so far, or \-2 if no packets have been
577 This routine is safe to use inside a signal handler on UNIX or a console
578 control handler on Windows, as it merely sets a flag that is checked
581 The flag is checked in loops reading packets from the OS - a signal by
582 itself will not necessarily terminate those loops - as well as in loops
583 processing a set of packets returned by the OS.
585 Note that if you are catching signals on UNIX systems that support
586 restarting system calls after a signal, and calling pcap_breakloop()
587 in the signal handler, you must specify, when catching those signals,
588 that system calls should NOT be restarted by that signal. Otherwise,
589 if the signal interrupted a call reading packets in a live capture,
590 when your signal handler returns after calling pcap_breakloop(), the
591 call will be restarted, and the loop will not terminate until more
592 packets arrive and the call completes.
594 Note also that, in a multi-threaded application, if one thread is
596 .BR pcap_dispatch() ,
603 in a different thread will not unblock that thread; you will need to use
604 whatever mechanism the OS provides for breaking a thread out of blocking
605 calls in order to unblock the thread, such as thread cancellation in
606 systems that support POSIX threads.
611 will, on some platforms, loop reading packets from the OS; that loop
612 will not necessarily be terminated by a signal, so
614 should be used to terminate packet processing even if
619 does not guarantee that no further packets will be processed by
623 after it is called; at most one more packet might be processed.
625 If \-2 is returned from
629 the flag is cleared, so a subsequent call will resume reading packets.
630 If a positive number is returned, the flag is not cleared, so a
631 subsequent call will return \-2 and clear the flag.
634 outputs a packet to the ``savefile'' opened with
635 .BR pcap_dump_open() .
636 Note that its calling arguments are suitable for use with
640 If called directly, the
645 .BR pcap_dump_open() .
648 is used to compile the string
650 into a filter program.
654 struct and is filled in by
657 controls whether optimization on the resulting code is performed.
659 specifies the IPv4 netmask of the network on which packets are being
660 captured; it is used only when checking for IPv4 broadcast addresses in
661 the filter program. If the netmask of the network on which packets are
662 being captured isn't known to the program, or if packets are being
663 captured on the Linux "any" pseudo-interface that can capture on more
664 than one network, a value of 0 can be supplied; tests for IPv4 broadcast
665 addreses won't be done correctly, but all other tests in the filter
666 program will be OK. A return of \-1 indicates an error in which case
668 may be used to display the error text.
670 .B pcap_compile_nopcap()
673 except that instead of passing a pcap structure, one passes the
674 snaplen and linktype explicitly. It is intended to be used for
675 compiling filters for direct BPF usage, without necessarily having
678 A return of \-1 indicates an error; the error text is unavailable.
679 .RB ( pcap_compile_nopcap()
681 .BR pcap_open_dead() ,
685 the latter three routines can be used directly in order to get the error
686 text for a compilation error.)
690 is used to specify a filter program.
694 struct, usually the result of a call to
697 is returned on failure, in which case
699 may be used to display the error text;
701 is returned on success.
704 is used to free up allocated memory pointed to by a
708 when that BPF program is no longer needed, for example after it
709 has been made the filter program for a pcap structure by a call to
710 .BR pcap_setfilter() .
713 returns the link layer type; link layer types it can return include:
718 BSD loopback encapsulation; the link layer header is a 4-byte field, in
720 byte order, containing a PF_ value from
722 for the network-layer protocol of the packet.
724 Note that ``host byte order'' is the byte order of the machine on which
725 the packets are captured, and the PF_ values are for the OS of the
726 machine on which the packets are captured; if a live capture is being
727 done, ``host byte order'' is the byte order of the machine capturing the
728 packets, and the PF_ values are those of the OS of the machine capturing
729 the packets, but if a ``savefile'' is being read, the byte order and PF_
732 necessarily those of the machine reading the capture file.
735 Ethernet (10Mb, 100Mb, 1000Mb, and up)
738 IEEE 802.5 Token Ring
744 SLIP; the link layer header contains, in order:
747 a 1-byte flag, which is 0 for packets received by the machine and 1 for
748 packets sent by the machine;
750 a 1-byte field, the upper 4 bits of which indicate the type of packet,
755 an unmodified IP datagram (TYPE_IP);
758 an uncompressed-TCP IP datagram (UNCOMPRESSED_TCP), with that byte being
759 the first byte of the raw IP header on the wire, containing the
760 connection number in the protocol field;
763 a compressed-TCP IP datagram (COMPRESSED_TCP), with that byte being the
764 first byte of the compressed TCP/IP datagram header;
767 for UNCOMPRESSED_TCP, the rest of the modified IP header, and for
768 COMPRESSED_TCP, the compressed TCP/IP datagram header;
772 for a total of 16 bytes; the uncompressed IP datagram follows the header.
776 PPP; if the first 2 bytes are 0xff and 0x03, it's PPP in HDLC-like
777 framing, with the PPP header following those two bytes, otherwise it's
778 PPP without framing, and the packet begins with the PPP header.
784 RFC 1483 LLC/SNAP-encapsulated ATM; the packet begins with an IEEE 802.2
788 raw IP; the packet begins with an IP header.
791 PPP in HDLC-like framing, as per RFC 1662, or Cisco PPP with HDLC
792 framing, as per section 4.3.1 of RFC 1547; the first byte will be 0xFF
793 for PPP in HDLC-like framing, and will be 0x0F or 0x8F for Cisco PPP
797 PPPoE; the packet begins with a PPPoE header, as per RFC 2516.
800 Cisco PPP with HDLC framing, as per section 4.3.1 of RFC 1547.
803 IEEE 802.11 wireless LAN
809 OpenBSD loopback encapsulation; the link layer header is a 4-byte field, in
811 byte order, containing a PF_ value from OpenBSD's
813 for the network-layer protocol of the packet.
815 Note that, if a ``savefile'' is being read, those PF_ values are
817 necessarily those of the machine reading the capture file.
820 Linux "cooked" capture encapsulation; the link layer header contains, in
824 a 2-byte "packet type", in network byte order, which is one of:
828 packet was sent to us by somebody else
831 packet was broadcast by somebody else
834 packet was multicast, but not broadcast, by somebody else
837 packet was sent by somebody else to somebody else
840 packet was sent by us
843 a 2-byte field, in network byte order, containing a Linux ARPHRD_ value
844 for the link layer device type;
846 a 2-byte field, in network byte order, containing the length of the
847 link layer address of the sender of the packet (which could be 0);
849 an 8-byte field containing that number of bytes of the link layer header
850 (if there are more than 8 bytes, only the first 8 are present);
852 a 2-byte field containing an Ethernet protocol type, in network byte
853 order, or containing 1 for Novell 802.3 frames without an 802.2 LLC
854 header or 4 for frames beginning with an 802.2 LLC header.
858 Apple LocalTalk; the packet begins with an AppleTalk LLAP header.
861 OpenBSD pflog; the link layer header contains, in order:
864 a 1-byte header length, in host byte order;
866 a 4-byte PF_ value, in host byte order;
868 a 2-byte action code, in network byte order, which is one of:
881 a 2-byte reason code, in network byte order, which is one of:
903 a 16-character interface name;
905 a 16-character ruleset name (only meaningful if subrule is set);
907 a 4-byte rule number, in network byte order;
909 a 4-byte subrule number, in network byte order;
911 a 1-byte direction, in network byte order, which is one of:
926 Prism monitor mode information followed by an 802.11 header.
929 RFC 2625 IP-over-Fibre Channel, with the link-layer header being the
930 Network_Header as described in that RFC.
933 SunATM devices; the link layer header contains, in order:
936 a 1-byte flag field, containing a direction flag in the uppermost bit,
937 which is set for packets transmitted by the machine and clear for
938 packets received by the machine, and a 4-byte traffic type in the
939 low-order 4 bits, which is one of:
949 LLC-encapsulated traffic
966 a 2-byte VCI field, in network byte order.
969 .B DLT_IEEE802_11_RADIO
970 link-layer information followed by an 802.11 header - see
971 http://www.shaftnet.org/~pizza/software/capturefrm.txt for a description
972 of the link-layer information.
975 ARCNET, with no exception frames, reassembled packets rather than raw
976 frames, and an extra 16-bit offset field between the destination host
980 Linux-IrDA packets, with a
982 header followed by the IrLAP header.
985 .B pcap_list_datalinks()
986 is used to get a list of the supported data link types of the interface
987 associated with the pcap descriptor.
988 .B pcap_list_datalinks()
989 allocates an array to hold the list and sets
991 The caller is responsible for freeing the array.
993 is returned on failure;
994 otherwise, the number of data link types in the array is returned.
996 .B pcap_set_datalink()
997 is used to set the current data link type of the pcap descriptor
998 to the type specified by
1001 is returned on failure.
1003 .B pcap_datalink_name_to_val()
1004 translates a data link type name, which is a
1008 removed, to the corresponding data link type value. The translation
1009 is case-insensitive.
1011 is returned on failure.
1013 .B pcap_datalink_val_to_name()
1014 translates a data link type value to the corresponding data link type
1015 name. NULL is returned on failure.
1017 .B pcap_datalink_val_to_description()
1018 translates a data link type value to a short description of that data
1019 link type. NULL is returned on failure.
1021 .B pcap_list_datalinks()
1022 is used to get a list of the supported data link types of the interface
1023 associated with the pcap descriptor.
1024 .B pcap_list_datalinks()
1025 allocates an array to hold the list and sets
1027 The caller is responsible for freeing the array.
1029 is returned on failure;
1030 otherwise, the number of data link types in the array is returned.
1032 .B pcap_set_datalink()
1033 is used to set the current data link type of the pcap descriptor
1034 to the type specified by
1037 is returned on failure.
1040 returns the snapshot length specified when
1044 .B pcap_is_swapped()
1045 returns true if the current ``savefile'' uses a different byte order
1046 than the current system.
1048 .B pcap_major_version()
1049 returns the major number of the file format of the savefile;
1050 .B pcap_minor_version()
1051 returns the minor number of the file format of the savefile. The
1052 version number is stored in the header of the savefile.
1055 returns the standard I/O stream of the ``savefile,'' if a ``savefile''
1057 .BR pcap_open_offline() ,
1058 or NULL, if a network device was opened with
1059 .BR pcap_open_live() .
1062 returns 0 and fills in a
1064 struct. The values represent packet statistics from the start of the
1065 run to the time of the call. If there is an error or the underlying
1066 packet capture doesn't support packet statistics, \-1 is returned and
1067 the error text can be obtained with
1072 is supported only on live captures, not on ``savefiles''; no statistics
1073 are stored in ``savefiles'', so no statistics are available when reading
1074 from a ``savefile''.
1077 returns the file descriptor number from which captured packets are read,
1078 if a network device was opened with
1079 .BR pcap_open_live() ,
1080 or \-1, if a ``savefile'' was opened with
1081 .BR pcap_open_offline() .
1083 .B pcap_get_selectable_fd()
1084 returns, on UNIX, a file descriptor number for a file descriptor on
1090 to wait for it to be possible to read packets without blocking, if such
1091 a descriptor exists, or \-1, if no such descriptor exists. Some network
1098 (for example, regular network devices on FreeBSD 4.3 and 4.4, and Endace
1099 DAG devices), so \-1 is returned for those devices.
1101 Note that on most versions of most BSDs (including Mac OS X)
1105 do not work correctly on BPF devices;
1106 .B pcap_get_selectable_fd()
1107 will return a file descriptor on most of those versions (the exceptions
1108 being FreeBSD 4.3 and 4.4), a simple
1112 will not return even after a timeout specified in
1114 expires. To work around this, an application that uses
1118 to wait for packets to arrive must put the
1120 in non-blocking mode, and must arrange that the
1124 have a timeout less than or equal to the timeout specified in
1125 .BR pcap_open_live() ,
1126 and must try to read packets after that timeout expires, regardless of
1131 indicated that the file descriptor for the
1133 is ready to be read or not. (That workaround will not work in FreeBSD
1134 4.3 and later; however, in FreeBSD 4.6 and later,
1138 work correctly on BPF devices, so the workaround isn't necessary,
1139 although it does no harm.)
1141 .B pcap_get_selectable_fd()
1142 is not available on Windows.
1145 prints the text of the last pcap library error on
1151 returns the error text pertaining to the last pcap library error.
1153 the pointer it returns will no longer point to a valid error message
1156 passed to it is closed; you must use or copy the string before closing
1165 .B pcap_lib_version()
1166 returns a pointer to a string giving information about the version of
1167 the libpcap library being used; note that it contains more information
1168 than just a version number.
1171 closes the files associated with
1173 and deallocates resources.
1176 returns the standard I/O stream of the ``savefile'' opened by
1177 .BR pcap_dump_open().
1179 .B pcap_dump_flush()
1180 flushes the output buffer to the ``savefile,'' so that any packets
1183 but not yet written to the ``savefile'' will be written.
1185 is returned on error, 0 on success.
1187 .B pcap_dump_close()
1188 closes the ``savefile.''
1191 tcpdump(1), tcpslice(1)
1193 The original authors are:
1197 Steven McCanne, all of the
1198 Lawrence Berkeley National Laboratory, University of California, Berkeley, CA.
1200 The current version is available from "The Tcpdump Group"'s Web site at
1203 .I http://www.tcpdump.org/
1206 Please send problems, bugs, questions, desirable enhancements, etc. to:
1209 tcpdump-workers@tcpdump.org
1212 Please send source code contributions, etc. to:
projects / FreeBSD / FreeBSD.git / blob