pylibpcap-0.6.4/000755 000766 000024 00000000000 11704160630 013616 5ustar00wimlstaff000000 000000 pylibpcap-0.6.4/build-tools/000755 000766 000024 00000000000 11701436300 016050 5ustar00wimlstaff000000 000000 pylibpcap-0.6.4/ChangeLog000644 000766 000024 00000005125 11701433014 015367 0ustar00wimlstaff000000 000000 2012-01-05 Wim Lewis pylibpcap-0.6.3, 5 January 2012 * pcap_interface.c: Release the GIL when calling into libpcap, to allow other threads to run. (SF bug #2080784) * pcap_interface.c: Minor improvements to exception processing. Fixes SF bug #1758709, probably others. * mk-constants.py: Added more DLT_ values from tcpdump.org. * Regenerated pcap.c and pcap.py using SWIG 1.3.31. 2008-01-25 Wim Lewis pylibpcap-0.6.2, 25 January 2008 Some files were missing from the tarball depending on how it was packaged; added them to MANIFEST.in to make sure they get included. Also updated mk-constants with the latest DLT_* entries from tcpdump.org. 2007-07-25 Wim Lewis pylibpcap-0.6.1, 25 July 2007 Clarified the license terms. Rewrote some of the module initialization to hopefully make it less fragile when SWIG changes. Added a bunch of new DLT_* constants. Made a few changes to the syntax in pcap.i to match with the current SWIG-1.3.x syntax. 2007-02-14 Noah Spurrier pylibpcap-0.6, 2007-02-14 To install run: python ./setup.py install For Ubuntu/Debian systems you will probably need to install the libpcap development package: apt-get install libpcap-dev Had to manually add SWIG_PY_INT to mk-constants.py to support swig-1.3.31 Normalized indentation to Python semi-standard 4 spaces. Changed #!/usr/bin/env lines from python2 to python, since no distros use python2 anymore. 2005-07-05 Wim Lewis pylibpcap-0.5, released 7/3/2005 This release contains the patches that have been accumulating in CVS, and supports some features of newer libpcaps. It should build for libpcap bersions >= 0.8.3. It can be built for earlier versions by uncommenting lines in setup.py according to which features your version of libpcap supports. [wiml] 2004-04-25 Wim Lewis Apr 25, 2004 [wiml]: There is a bug in libpcap and/or OpenBSD3.4 which results in a SEGV if you call findalldevs() and you have a gif tunnel configured. (See libpcap bug #941924 for details: http://sourceforge.net/tracker/index.php? func=detail&aid=941924&group_id=53067&atid=469577 ) 2002-06-14 David Margrave pylibpcap-0.4, released 6/14/02 Thanks to the following people who supplied patches: - PC Drew for a fix to exception handling in callbacks. - Gustavo Carneiro for various fixes to pcap_next() and to handling of packet capture lengths. - Jon Nelson for distutil patch. - T. Meyarivan for finding and fixing memory leaks pylibpcap-0.6.4/constants.c000644 000766 000024 00000021315 11701436273 016006 0ustar00wimlstaff000000 000000 /* Automatically generated from Id: mk-constants.py,v 1.8 2012/01/05 10:15:27 wiml Exp Do not edit this file directly, it will be overwritten */ static struct { const char *name; long value; } const pcapmodule_DLT[] = { #ifdef DLT_NULL { "DLT_NULL", (DLT_NULL) }, #endif #ifdef DLT_EN10MB { "DLT_EN10MB", (DLT_EN10MB) }, #endif #ifdef DLT_EN3MB { "DLT_EN3MB", (DLT_EN3MB) }, #endif #ifdef DLT_AX25 { "DLT_AX25", (DLT_AX25) }, #endif #ifdef DLT_PRONET { "DLT_PRONET", (DLT_PRONET) }, #endif #ifdef DLT_CHAOS { "DLT_CHAOS", (DLT_CHAOS) }, #endif #ifdef DLT_ARCNET { "DLT_ARCNET", (DLT_ARCNET) }, #endif #ifdef DLT_ARCNET_LINUX { "DLT_ARCNET_LINUX", (DLT_ARCNET_LINUX) }, #endif #ifdef DLT_SLIP { "DLT_SLIP", (DLT_SLIP) }, #endif #ifdef DLT_SLIP_BSDOS { "DLT_SLIP_BSDOS", (DLT_SLIP_BSDOS) }, #endif #ifdef DLT_FDDI { "DLT_FDDI", (DLT_FDDI) }, #endif #ifdef DLT_HIPPI { "DLT_HIPPI", (DLT_HIPPI) }, #endif #ifdef DLT_ATM_RFC1483 { "DLT_ATM_RFC1483", (DLT_ATM_RFC1483) }, #endif #ifdef DLT_RAW { "DLT_RAW", (DLT_RAW) }, #endif #ifdef DLT_PPP { "DLT_PPP", (DLT_PPP) }, #endif #ifdef DLT_PPP_BSDOS { "DLT_PPP_BSDOS", (DLT_PPP_BSDOS) }, #endif #ifdef DLT_PPP_SERIAL { "DLT_PPP_SERIAL", (DLT_PPP_SERIAL) }, #endif #ifdef DLT_PPP_ETHER { "DLT_PPP_ETHER", (DLT_PPP_ETHER) }, #endif #ifdef DLT_C_HDLC { "DLT_C_HDLC", (DLT_C_HDLC) }, #endif #ifdef DLT_HDLC { "DLT_HDLC", (DLT_HDLC) }, #endif #ifdef DLT_ATM_CLIP { "DLT_ATM_CLIP", (DLT_ATM_CLIP) }, #endif #ifdef DLT_IEEE802 { "DLT_IEEE802", (DLT_IEEE802) }, #endif #ifdef DLT_IEEE802_11 { "DLT_IEEE802_11", (DLT_IEEE802_11) }, #endif #ifdef DLT_IEEE802_11_RADIO { "DLT_IEEE802_11_RADIO", (DLT_IEEE802_11_RADIO) }, #endif #ifdef DLT_IEEE802_11_RADIO_AVS { "DLT_IEEE802_11_RADIO_AVS", (DLT_IEEE802_11_RADIO_AVS) }, #endif #ifdef DLT_LOOP { "DLT_LOOP", (DLT_LOOP) }, #endif #ifdef DLT_LINUX_SLL { "DLT_LINUX_SLL", (DLT_LINUX_SLL) }, #endif #ifdef DLT_LTALK { "DLT_LTALK", (DLT_LTALK) }, #endif #ifdef DLT_ECONET { "DLT_ECONET", (DLT_ECONET) }, #endif #ifdef DLT_IPFILTER { "DLT_IPFILTER", (DLT_IPFILTER) }, #endif #ifdef DLT_PFLOG { "DLT_PFLOG", (DLT_PFLOG) }, #endif #ifdef DLT_PFSYNC { "DLT_PFSYNC", (DLT_PFSYNC) }, #endif #ifdef DLT_CISCO_IOS { "DLT_CISCO_IOS", (DLT_CISCO_IOS) }, #endif #ifdef DLT_PRISM_HEADER { "DLT_PRISM_HEADER", (DLT_PRISM_HEADER) }, #endif #ifdef DLT_AIRONET_HEADER { "DLT_AIRONET_HEADER", (DLT_AIRONET_HEADER) }, #endif #ifdef DLT_ENC { "DLT_ENC", (DLT_ENC) }, #endif #ifdef DLT_APPLE_IP_OVER_IEEE1394 { "DLT_APPLE_IP_OVER_IEEE1394", (DLT_APPLE_IP_OVER_IEEE1394) }, #endif #ifdef DLT_AURORA { "DLT_AURORA", (DLT_AURORA) }, #endif #ifdef DLT_DOCSIS { "DLT_DOCSIS", (DLT_DOCSIS) }, #endif #ifdef DLT_FRELAY { "DLT_FRELAY", (DLT_FRELAY) }, #endif #ifdef DLT_IP_OVER_FC { "DLT_IP_OVER_FC", (DLT_IP_OVER_FC) }, #endif #ifdef DLT_JUNIPER_ATM1 { "DLT_JUNIPER_ATM1", (DLT_JUNIPER_ATM1) }, #endif #ifdef DLT_JUNIPER_ATM2 { "DLT_JUNIPER_ATM2", (DLT_JUNIPER_ATM2) }, #endif #ifdef DLT_JUNIPER_ES { "DLT_JUNIPER_ES", (DLT_JUNIPER_ES) }, #endif #ifdef DLT_JUNIPER_GGSN { "DLT_JUNIPER_GGSN", (DLT_JUNIPER_GGSN) }, #endif #ifdef DLT_JUNIPER_MFR { "DLT_JUNIPER_MFR", (DLT_JUNIPER_MFR) }, #endif #ifdef DLT_JUNIPER_MLFR { "DLT_JUNIPER_MLFR", (DLT_JUNIPER_MLFR) }, #endif #ifdef DLT_JUNIPER_MLPPP { "DLT_JUNIPER_MLPPP", (DLT_JUNIPER_MLPPP) }, #endif #ifdef DLT_JUNIPER_MONITOR { "DLT_JUNIPER_MONITOR", (DLT_JUNIPER_MONITOR) }, #endif #ifdef DLT_JUNIPER_SERVICES { "DLT_JUNIPER_SERVICES", (DLT_JUNIPER_SERVICES) }, #endif #ifdef DLT_LINUX_IRDA { "DLT_LINUX_IRDA", (DLT_LINUX_IRDA) }, #endif #ifdef DLT_RIO { "DLT_RIO", (DLT_RIO) }, #endif #ifdef DLT_SUNATM { "DLT_SUNATM", (DLT_SUNATM) }, #endif #ifdef DLT_SYMANTEC_FIREWALL { "DLT_SYMANTEC_FIREWALL", (DLT_SYMANTEC_FIREWALL) }, #endif #ifdef DLT_TZSP { "DLT_TZSP", (DLT_TZSP) }, #endif #ifdef DLT_REDBACK_SMARTEDGE { "DLT_REDBACK_SMARTEDGE", (DLT_REDBACK_SMARTEDGE) }, #endif #ifdef DLT_OLD_PFLOG { "DLT_OLD_PFLOG", (DLT_OLD_PFLOG) }, #endif #ifdef DLT_HHDLC { "DLT_HHDLC", (DLT_HHDLC) }, #endif #ifdef DLT_PCI_EXP { "DLT_PCI_EXP", (DLT_PCI_EXP) }, #endif #ifdef DLT_MTP2_WITH_PHDR { "DLT_MTP2_WITH_PHDR", (DLT_MTP2_WITH_PHDR) }, #endif #ifdef DLT_MTP2 { "DLT_MTP2", (DLT_MTP2) }, #endif #ifdef DLT_MTP3 { "DLT_MTP3", (DLT_MTP3) }, #endif #ifdef DLT_SCCP { "DLT_SCCP", (DLT_SCCP) }, #endif #ifdef DLT_IBM_SP { "DLT_IBM_SP", (DLT_IBM_SP) }, #endif #ifdef DLT_IBM_SN { "DLT_IBM_SN", (DLT_IBM_SN) }, #endif #ifdef DLT_BACNET_MS_TP { "DLT_BACNET_MS_TP", (DLT_BACNET_MS_TP) }, #endif #ifdef DLT_LINUX_PPP_WITHDIRECTION { "DLT_LINUX_PPP_WITHDIRECTION", (DLT_LINUX_PPP_WITHDIRECTION) }, #endif #ifdef DLT_GPRS_LLC { "DLT_GPRS_LLC", (DLT_GPRS_LLC) }, #endif #ifdef DLT_GPF_T { "DLT_GPF_T", (DLT_GPF_T) }, #endif #ifdef DLT_GPF_F { "DLT_GPF_F", (DLT_GPF_F) }, #endif #ifdef DLT_GCOM_T1E1 { "DLT_GCOM_T1E1", (DLT_GCOM_T1E1) }, #endif #ifdef DLT_GCOM_SERIAL { "DLT_GCOM_SERIAL", (DLT_GCOM_SERIAL) }, #endif #ifdef DLT_JUNIPER_PIC_PEER { "DLT_JUNIPER_PIC_PEER", (DLT_JUNIPER_PIC_PEER) }, #endif #ifdef DLT_ERF_ETH { "DLT_ERF_ETH", (DLT_ERF_ETH) }, #endif #ifdef DLT_ERF_POS { "DLT_ERF_POS", (DLT_ERF_POS) }, #endif #ifdef DLT_LINUX_LAPD { "DLT_LINUX_LAPD", (DLT_LINUX_LAPD) }, #endif #ifdef DLT_JUNIPER_ETHER { "DLT_JUNIPER_ETHER", (DLT_JUNIPER_ETHER) }, #endif #ifdef DLT_JUNIPER_PPP { "DLT_JUNIPER_PPP", (DLT_JUNIPER_PPP) }, #endif #ifdef DLT_JUNIPER_PPPOE { "DLT_JUNIPER_PPPOE", (DLT_JUNIPER_PPPOE) }, #endif #ifdef DLT_JUNIPER_PPPOE_ATM { "DLT_JUNIPER_PPPOE_ATM", (DLT_JUNIPER_PPPOE_ATM) }, #endif #ifdef DLT_JUNIPER_FRELAY { "DLT_JUNIPER_FRELAY", (DLT_JUNIPER_FRELAY) }, #endif #ifdef DLT_JUNIPER_CHDLC { "DLT_JUNIPER_CHDLC", (DLT_JUNIPER_CHDLC) }, #endif #ifdef DLT_JUNIPER_ISM { "DLT_JUNIPER_ISM", (DLT_JUNIPER_ISM) }, #endif #ifdef DLT_JUNIPER_ST { "DLT_JUNIPER_ST", (DLT_JUNIPER_ST) }, #endif #ifdef DLT_JUNIPER_VP { "DLT_JUNIPER_VP", (DLT_JUNIPER_VP) }, #endif #ifdef DLT_PPP_PPPD { "DLT_PPP_PPPD", (DLT_PPP_PPPD) }, #endif #ifdef DLT_MFR { "DLT_MFR", (DLT_MFR) }, #endif #ifdef DLT_A429 { "DLT_A429", (DLT_A429) }, #endif #ifdef DLT_A653_ICM { "DLT_A653_ICM", (DLT_A653_ICM) }, #endif #ifdef DLT_USB { "DLT_USB", (DLT_USB) }, #endif #ifdef DLT_USB_LINUX { "DLT_USB_LINUX", (DLT_USB_LINUX) }, #endif #ifdef DLT_CAN20B { "DLT_CAN20B", (DLT_CAN20B) }, #endif #ifdef DLT_BLUETOOTH_HCI_H4 { "DLT_BLUETOOTH_HCI_H4", (DLT_BLUETOOTH_HCI_H4) }, #endif #ifdef DLT_BLUETOOTH_HCI_H4_WITH_PHDR { "DLT_BLUETOOTH_HCI_H4_WITH_PHDR", (DLT_BLUETOOTH_HCI_H4_WITH_PHDR) }, #endif #ifdef DLT_IEEE802_16_MAC_CPS { "DLT_IEEE802_16_MAC_CPS", (DLT_IEEE802_16_MAC_CPS) }, #endif #ifdef DLT_IEEE802_16_MAC_CPS_RADIO { "DLT_IEEE802_16_MAC_CPS_RADIO", (DLT_IEEE802_16_MAC_CPS_RADIO) }, #endif #ifdef DLT_IEEE802_15_4_LINUX { "DLT_IEEE802_15_4_LINUX", (DLT_IEEE802_15_4_LINUX) }, #endif #ifdef DLT_IEEE802_15_4 { "DLT_IEEE802_15_4", (DLT_IEEE802_15_4) }, #endif #ifdef DLT_PPI { "DLT_PPI", (DLT_PPI) }, #endif #ifdef DLT_SITA { "DLT_SITA", (DLT_SITA) }, #endif #ifdef DLT_ERF { "DLT_ERF", (DLT_ERF) }, #endif #ifdef DLT_RAIF1 { "DLT_RAIF1", (DLT_RAIF1) }, #endif #ifdef DLT_IPMB { "DLT_IPMB", (DLT_IPMB) }, #endif #ifdef DLT_AX25_KISS { "DLT_AX25_KISS", (DLT_AX25_KISS) }, #endif #ifdef DLT_LAPD { "DLT_LAPD", (DLT_LAPD) }, #endif #ifdef DLT_PPP_WITH_DIR { "DLT_PPP_WITH_DIR", (DLT_PPP_WITH_DIR) }, #endif #ifdef DLT_C_HDLC_WITH_DIR { "DLT_C_HDLC_WITH_DIR", (DLT_C_HDLC_WITH_DIR) }, #endif #ifdef DLT_FRELAY_WITH_DIR { "DLT_FRELAY_WITH_DIR", (DLT_FRELAY_WITH_DIR) }, #endif #ifdef DLT_LAPB_WITH_DIR { "DLT_LAPB_WITH_DIR", (DLT_LAPB_WITH_DIR) }, #endif #ifdef DLT_IPMB_LINUX { "DLT_IPMB_LINUX", (DLT_IPMB_LINUX) }, #endif #ifdef DLT_FLEXRAY { "DLT_FLEXRAY", (DLT_FLEXRAY) }, #endif #ifdef DLT_MOST { "DLT_MOST", (DLT_MOST) }, #endif #ifdef DLT_LIN { "DLT_LIN", (DLT_LIN) }, #endif #ifdef DLT_IEEE802_15_4_NONASK_PHY { "DLT_IEEE802_15_4_NONASK_PHY", (DLT_IEEE802_15_4_NONASK_PHY) }, #endif #ifdef DLT_GSMTAP_UM { "DLT_GSMTAP_UM", (DLT_GSMTAP_UM) }, #endif #ifdef DLT_GSMTAP_ABIS { "DLT_GSMTAP_ABIS", (DLT_GSMTAP_ABIS) }, #endif #ifdef DLT_MPLS { "DLT_MPLS", (DLT_MPLS) }, #endif #ifdef DLT_DECT { "DLT_DECT", (DLT_DECT) }, #endif #ifdef DLT_AOS { "DLT_AOS", (DLT_AOS) }, #endif #ifdef DLT_WIHART { "DLT_WIHART", (DLT_WIHART) }, #endif #ifdef DLT_FC_2 { "DLT_FC_2", (DLT_FC_2) }, #endif #ifdef DLT_FC_2_WITH_FRAME_DELIMS { "DLT_FC_2_WITH_FRAME_DELIMS", (DLT_FC_2_WITH_FRAME_DELIMS) }, #endif #ifdef DLT_IPNET { "DLT_IPNET", (DLT_IPNET) }, #endif #ifdef DLT_CAN_SOCKETCAN { "DLT_CAN_SOCKETCAN", (DLT_CAN_SOCKETCAN) }, #endif #ifdef DLT_IPV4 { "DLT_IPV4", (DLT_IPV4) }, #endif #ifdef DLT_IPV6 { "DLT_IPV6", (DLT_IPV6) }, #endif #ifdef DLT_IEEE802_15_4_NOFCS { "DLT_IEEE802_15_4_NOFCS", (DLT_IEEE802_15_4_NOFCS) }, #endif #ifdef DLT_MUX27010 { "DLT_MUX27010", (DLT_MUX27010) }, #endif #ifdef DLT_STANAG_5066_D_PDU { "DLT_STANAG_5066_D_PDU", (DLT_STANAG_5066_D_PDU) }, #endif #ifdef DLT_IPOIB { "DLT_IPOIB", (DLT_IPOIB) }, #endif { NULL, 0 } }; pylibpcap-0.6.4/COPYING000644 000766 000024 00000002032 11701433777 014662 0ustar00wimlstaff000000 000000 Python libpcap Copyright (C) 2000, 2001, 2002 David Margrave Copyright (C) 2004, 2005, 2012 William Lewis Based on PY-libpcap (C) 1998, Aaron L. Rhodes This program is free software. 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. The names of the authors may not be used to endorse or promote products derived from this software without specific prior written permission. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; it is provided "AS IS", without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. pylibpcap-0.6.4/doc.i000644 000766 000024 00000014671 10073704202 014543 0ustar00wimlstaff000000 000000 #define pcap_doc \ "pcap module\n" \ "-----------\n" \ "pcapObject(): Returns a pcapObject instance, with the following methods.\n"\ "Please see the __doc__ attributes of the instance methods of a pcapObject\n"\ "for more information. (there are no method __doc__ attributes in the\n"\ "class). Also please note that at this time, method __doc__ attributes are\n"\ "only functional for python2.\n"\ " open_live(device, snaplen, promisc, to_ms)\n" \ " open_dead(linktype, snaplen)\n" \ " open_offline(filename)\n" \ " dump_open(filename)\n" \ " setnonblock(nonblock)\n" \ " getnonblock()\n" \ " setfilter(filter, optimize, netmask)\n" \ " loop(count, callback)\n" \ " dispatch(count, callback)\n" \ " next()\n" \ " datalink()\n" \ " snapshot()\n" \ " is_swapped()\n" \ " major_version()\n" \ " stats()\n" \ " fileno()\n\n"\ "Please see the __doc__ attributes of the following pcap module functions\n"\ "for further information:\n" \ " lookupdev()\n" \ " lookupnet(device)\n" \ " findalldevs()\n" \ " aton(addr)\n" \ " ntoa(addr)\n" #define pcapObject_open_live_doc \ "open_live(device, snaplen, promisc, to_ms)\n\n" \ "Opens the interface specificed by 'device' for packet capture. 'snaplen'\n"\ "is the maximum number of bytes to capture per packet, 'promisc' indicates\n"\ "whether promiscuous mode should be used, and 'to_ms' specifies the read\n"\ "timeout in milliseconds." #define pcapObject_open_dead_doc \ "open_dead(linktype, snaplen)\n\n" \ "open_dead is used to initialize the pcapObject so that methods that\n"\ "require the object to be initialized can be called, such as for compiling\n"\ "BPF code. 'snaplen' is the maximum number of bytes to capture per packet." #define pcapObject_open_offline_doc \ "open_offline(filename)\n\n" \ "Opens a saved pcap/tcpdump-format file for reading. 'filename' is the name\n"\ "of the file to open. The filename '-' is synonymous with stdin" #define pcapObject_dump_open_doc \ "dump_open(filename)\n\n" \ "Opens a saved pcap/tcpdump-format file for writing. 'filename' is the name\n"\ "of the file to open. The filename '-' is synonymous with stdout" #define pcapObject_setnonblock_doc \ "setnonblock(nonblock)\n\n" \ "Puts the pcapObject in non-blocking mode ('nonblock'==1) or blocking mode\n"\ "('nonblock'==0). Non-blocking behavior is only applicable to the\n"\ "dispatch method, and not the loop and next methods. It has no effect on\n"\ "savefiles." #define pcapObject_getnonblock_doc \ "getnonblock()\n\n" \ "Returns the non-blocking status of the pcapObject (returns 1 for\n"\ "non-blocking, returns 0 for blocking). 0 is always returned for savefiles\n"\ "Non-blocking behavior is only applicable to the dispatch method, and not\n"\ "the loop and next methods. It has no effect on savefiles." #define pcapObject_setfilter_doc \ "setfilter(filter, optimize, netmask)\n\n" \ "Applies a filtering rule to the pcapObject. 'filter' is a BPF-style \n"\ "filter expression, 'optimize' controls whether the compiled BPF code is \n"\ "optimized, and 'netmask' in a network byte-order integer specifying the \n"\ "netmask of the local network." #define pcapObject_loop_doc \ "loop(count, callback)\n\n" \ "Read packets until 'count' packets have been received or an exception\n"\ "occurs. The 'callback' argument is a python function of the form\n"\ "callback(pktlen, data, timestamp). 'pktlen' is the integer length of the\n"\ "observed packet on the wire, data is a string containing the captured\n"\ "bytes (may be less than the pktlen bytes), and the timestamp." #define pcapObject_dispatch_doc \ "dispatch(count, callback)\n\n" \ "Read packets until at most 'count' packets have been read, or a timeout"\ "occurs, or an exception is raised. Timeout behavior is not supported on\n"\ "all platforms, and on some platforms, the timer doesn't start until at least\n"\ "one packet arrives. \n"\ "The 'callback' argument is a python function of the form\n"\ "callback(pktlen, data, timestamp). 'pktlen' is the integer length of the\n"\ "observed packet on the wire, data is a string containing the captured\n"\ "bytes (may be less than the pktlen bytes), and the timestamp." #define pcapObject_next_doc \ "next()\n\n" \ "Reads the next packet from the interface, returning a tuple containing\n"\ "the integer length of the observed packet on the wire, a string containing\n"\ "the captured bytes (may be less than the pktlen bytes), and the timestamp." #define pcapObject_datalink_doc \ "datalink()\n\n" \ "Returns an integer value representing the link layer type (e.g. DLT_EN10MB)" #define pcapObject_datalinks_doc \ "datalinks()\n\n" \ "Returns a tuple of integer values representing the link layer types\n"\ "available on this interface (e.g. DLT_EN10MB)" #define pcapObject_snapshot_doc \ "snapshot()\n\n" \ "Returns the snapshot length specified when open_live was called" #define pcapObject_is_swapped_doc \ "is_swapped()\n\n" \ "Returns true if the current savefile uses a different byte order than the\n"\ "current system" #define pcapObject_major_version_doc \ "major_version()\n\n" \ "returns the major number of the version of the pcap used to write the savefile.\n" #define pcapObject_minor_version_doc \ "minor_version()\n\n" \ "returns the minor number of the version of the pcap used to write the savefile.\n" #define pcapObject_stats_doc \ "stats()\n\n" \ "Returns a tuple containing number of packets received, number of packets\n"\ "dropped, and number of packets dropped by the interface. This method is\n"\ "not applicable for savefiles" #define pcapObject_fileno_doc \ "fileno()\n\n"\ "Returns the file descriptor number from which captured packets are read,\n"\ "if a network device was opened with open_live(), or -1, if a savefile was\n"\ "opened with pcap_open_offline()." #define lookupdev_doc \ "lookupdev()\n\n" \ "Returns a string containing the name of an interface suitable for use\n" \ "with pcapObject.open_live and lookupnet.\n" #define lookupnet_doc \ "lookupnet(interface)\n\n" \ "Returns a tuple containing the network number and mask associated with\n" \ "the network device 'interface' in network byte order.\n" #define findalldevs_doc \ "findalldevs()\n\n" \ "Returns a list of tuples for each device that can be opened with\n" \ "open_live(). Each tuple contains the following members:\n" \ " name\n" \ " description\n" \ " addressess: a tuple of tuples for each address, containing the address,\n" \ " netmask, broadcast address, and point-to-point address.\n" \ " flags: PCAP_IF_LOOPBACK if a loopback interface\n" pylibpcap-0.6.4/error.c000644 000766 000024 00000002221 10564532100 015106 0ustar00wimlstaff000000 000000 /* Python libpcap Copyright (C) 2001, David Margrave Copyright (C) 2004, William Lewis Based PY-libpcap (C) 1998, Aaron L. Rhodes This program is free software; you can redistribute it and/or modify it under the terms of the BSD Licence. See the file COPYING for details. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include /* static */ PyObject *pcapError; static PyObject *error_object; void init_errors(PyObject *m) { const char *modname; char *namebuf; PyObject *d; d = PyModule_GetDict(m); modname = PyModule_GetName(m); namebuf = malloc(strlen(modname) + 11 /* ".EXCEPTION" + NUL */ ); /* the base class */ sprintf(namebuf, "%s.error", modname); pcapError = PyErr_NewException(namebuf, NULL, NULL); PyDict_SetItemString(d, "error", pcapError); sprintf(namebuf, "%s.EXCEPTION", modname); error_object = PyErr_NewException(namebuf,pcapError,NULL); PyDict_SetItemString(d, "EXCEPTION", error_object); Py_DECREF(error_object); free(namebuf); return; } pylibpcap-0.6.4/examples/000755 000766 000024 00000000000 11701436300 015431 5ustar00wimlstaff000000 000000 pylibpcap-0.6.4/exception.c000644 000766 000024 00000002003 10564532100 015751 0ustar00wimlstaff000000 000000 /* Python libpcap Copyright (C) 2001, David Margrave Copyright (C) 2004, William Lewis Based PY-libpcap (C) 1998, Aaron L. Rhodes This program is free software; you can redistribute it and/or modify it under the terms of the BSD Licence. See the file COPYING for details. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include #include "pypcap.h" void throw_exception(int err, char *ebuf) { if (err == -1) { PyErr_SetString(PyExc_Exception, ebuf); } else { PyErr_Format(PyExc_Exception, "[Error %d] %s", err, ebuf); } } void throw_pcap_exception(pcap_t *pcap, char *fname) { PyObject *errorArgs; if (fname == NULL) errorArgs = Py_BuildValue("(s)", pcap_geterr(pcap)); else errorArgs = Py_BuildValue("(ss)", pcap_geterr(pcap), fname); PyErr_SetObject(pcapError, errorArgs); Py_DECREF(errorArgs); } pylibpcap-0.6.4/MANIFEST.in000644 000766 000024 00000000364 10746525352 015372 0ustar00wimlstaff000000 000000 include pypcap.h include pypcap-int.h include pcap.c include pcap.i include doc.i include mk-constants.py include constants.c include COPYING include ChangeLog include MANIFEST.in recursive-include examples * recursive-include build-tools *.py pylibpcap-0.6.4/mk-constants.py000644 000766 000024 00000006601 11701274077 016624 0ustar00wimlstaff000000 000000 # $Id: mk-constants.py,v 1.8 2012/01/05 10:15:27 wiml Exp $ # # Python libpcap # Copyright (C) 2004,2007 Wim Lewis # Based on: # PY-libpcap (C) 1998, Aaron L. Rhodes # constants.i (C) 2001,2002, David Margrave # # This program is free software; you can redistribute it and/or # modify it under the terms of the BSD Licence. See the file COPYING # for details. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. linktypes = ( 'DLT_NULL', 'DLT_EN10MB', 'DLT_EN3MB', 'DLT_AX25', 'DLT_PRONET', 'DLT_CHAOS', 'DLT_ARCNET', 'DLT_ARCNET_LINUX', 'DLT_SLIP', 'DLT_SLIP_BSDOS', 'DLT_FDDI', 'DLT_HIPPI', 'DLT_ATM_RFC1483', 'DLT_RAW', 'DLT_PPP', 'DLT_PPP_BSDOS', 'DLT_PPP_SERIAL', 'DLT_PPP_ETHER', 'DLT_C_HDLC', # 'DLT_CHDLC', # CHDLC is a compatibility alias for C_HDLC 'DLT_HDLC', 'DLT_ATM_CLIP', 'DLT_IEEE802', 'DLT_IEEE802_11', 'DLT_IEEE802_11_RADIO', 'DLT_IEEE802_11_RADIO_AVS', 'DLT_LOOP', 'DLT_LINUX_SLL', 'DLT_LTALK', 'DLT_ECONET', 'DLT_IPFILTER', 'DLT_PFLOG', 'DLT_PFSYNC', 'DLT_CISCO_IOS', 'DLT_PRISM_HEADER', 'DLT_AIRONET_HEADER', 'DLT_ENC', 'DLT_APPLE_IP_OVER_IEEE1394', 'DLT_AURORA', 'DLT_DOCSIS', 'DLT_FRELAY', 'DLT_IP_OVER_FC', 'DLT_JUNIPER_ATM1', 'DLT_JUNIPER_ATM2', 'DLT_JUNIPER_ES', 'DLT_JUNIPER_GGSN', 'DLT_JUNIPER_MFR', 'DLT_JUNIPER_MLFR', 'DLT_JUNIPER_MLPPP', 'DLT_JUNIPER_MONITOR', 'DLT_JUNIPER_SERVICES', 'DLT_LINUX_IRDA', 'DLT_RIO', 'DLT_SUNATM', 'DLT_SYMANTEC_FIREWALL', 'DLT_TZSP', 'DLT_REDBACK_SMARTEDGE', 'DLT_OLD_PFLOG', 'DLT_HHDLC', 'DLT_PCI_EXP', 'DLT_MTP2_WITH_PHDR', 'DLT_MTP2', 'DLT_MTP3', 'DLT_SCCP', 'DLT_IBM_SP', 'DLT_IBM_SN', 'DLT_BACNET_MS_TP', 'DLT_LINUX_PPP_WITHDIRECTION', # Replaced by DLT_PPP_PPPD 'DLT_GPRS_LLC', 'DLT_GPF_T', 'DLT_GPF_F', 'DLT_GCOM_T1E1', 'DLT_GCOM_SERIAL', 'DLT_JUNIPER_PIC_PEER', 'DLT_ERF_ETH', 'DLT_ERF_POS', 'DLT_LINUX_LAPD', 'DLT_JUNIPER_ETHER', 'DLT_JUNIPER_PPP', 'DLT_JUNIPER_PPPOE', 'DLT_JUNIPER_PPPOE_ATM', 'DLT_JUNIPER_FRELAY', 'DLT_JUNIPER_CHDLC', 'DLT_JUNIPER_ISM', 'DLT_JUNIPER_ST', 'DLT_JUNIPER_VP', 'DLT_PPP_PPPD', 'DLT_MFR', 'DLT_A429', 'DLT_A653_ICM', 'DLT_USB', 'DLT_USB_LINUX', 'DLT_CAN20B', 'DLT_BLUETOOTH_HCI_H4', 'DLT_BLUETOOTH_HCI_H4_WITH_PHDR', 'DLT_IEEE802_16_MAC_CPS', 'DLT_IEEE802_16_MAC_CPS_RADIO', 'DLT_IEEE802_15_4_LINUX', 'DLT_IEEE802_15_4', 'DLT_PPI', 'DLT_SITA', 'DLT_ERF', 'DLT_RAIF1', 'DLT_IPMB', 'DLT_AX25_KISS', 'DLT_LAPD', 'DLT_PPP_WITH_DIR', 'DLT_C_HDLC_WITH_DIR', 'DLT_FRELAY_WITH_DIR', 'DLT_LAPB_WITH_DIR', 'DLT_IPMB_LINUX', 'DLT_FLEXRAY', 'DLT_MOST', 'DLT_LIN', 'DLT_IEEE802_15_4_NONASK_PHY', 'DLT_GSMTAP_UM', 'DLT_GSMTAP_ABIS', 'DLT_MPLS', 'DLT_DECT', 'DLT_AOS', 'DLT_WIHART', 'DLT_FC_2', 'DLT_FC_2_WITH_FRAME_DELIMS', 'DLT_IPNET', 'DLT_CAN_SOCKETCAN', 'DLT_IPV4', 'DLT_IPV6', 'DLT_IEEE802_15_4_NOFCS', 'DLT_MUX27010', 'DLT_STANAG_5066_D_PDU', 'DLT_IPOIB', ) import string fp = open('constants.c', 'w') fp.write('/* Automatically generated from\n') rcs = ' $Id: mk-constants.py,v 1.8 2012/01/05 10:15:27 wiml Exp $\n' fp.write(string.replace(rcs, '$', '')) fp.write(' Do not edit this file directly, it will be overwritten \n*/\n\n') fp.write('static struct { const char *name; long value; } ') fp.write(' const pcapmodule_DLT[] = {\n') for dlt in linktypes: fp.write('#ifdef %s\n' % (dlt,)) fp.write('{ "%s", (%s) },\n' % (dlt,dlt)) fp.write('#endif\n') fp.write('{ NULL, 0 }\n};\n') fp.close() pylibpcap-0.6.4/pcap.c000644 000766 000024 00000413617 11701436273 014727 0ustar00wimlstaff000000 000000 /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). * Version 1.3.31 * * This file is not intended to be easily readable and contains a number of * coding conventions designed to improve portability and efficiency. Do not make * changes to this file unless you know what you are doing--modify the SWIG * interface file instead. * ----------------------------------------------------------------------------- */ #define SWIGPYTHON #define SWIG_PYTHON_DIRECTOR_NO_VTABLE /* ----------------------------------------------------------------------------- * This section contains generic SWIG labels for method/variable * declarations/attributes, and other compiler dependent labels. * ----------------------------------------------------------------------------- */ /* template workaround for compilers that cannot correctly implement the C++ standard */ #ifndef SWIGTEMPLATEDISAMBIGUATOR # if defined(__SUNPRO_CC) # if (__SUNPRO_CC <= 0x560) # define SWIGTEMPLATEDISAMBIGUATOR template # else # define SWIGTEMPLATEDISAMBIGUATOR # endif # else # define SWIGTEMPLATEDISAMBIGUATOR # endif #endif /* inline attribute */ #ifndef SWIGINLINE # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) # define SWIGINLINE inline # else # define SWIGINLINE # endif #endif /* attribute recognised by some compilers to avoid 'unused' warnings */ #ifndef SWIGUNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define SWIGUNUSED __attribute__ ((__unused__)) # else # define SWIGUNUSED # endif # elif defined(__ICC) # define SWIGUNUSED __attribute__ ((__unused__)) # else # define SWIGUNUSED # endif #endif #ifndef SWIGUNUSEDPARM # ifdef __cplusplus # define SWIGUNUSEDPARM(p) # else # define SWIGUNUSEDPARM(p) p SWIGUNUSED # endif #endif /* internal SWIG method */ #ifndef SWIGINTERN # define SWIGINTERN static SWIGUNUSED #endif /* internal inline SWIG method */ #ifndef SWIGINTERNINLINE # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE #endif /* exporting methods */ #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) # ifndef GCC_HASCLASSVISIBILITY # define GCC_HASCLASSVISIBILITY # endif #endif #ifndef SWIGEXPORT # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) # if defined(STATIC_LINKED) # define SWIGEXPORT # else # define SWIGEXPORT __declspec(dllexport) # endif # else # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) # define SWIGEXPORT __attribute__ ((visibility("default"))) # else # define SWIGEXPORT # endif # endif #endif /* calling conventions for Windows */ #ifndef SWIGSTDCALL # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) # define SWIGSTDCALL __stdcall # else # define SWIGSTDCALL # endif #endif /* Deal with Microsoft's attempt at deprecating C standard runtime functions */ #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) # define _CRT_SECURE_NO_DEPRECATE #endif /* Python.h has to appear first */ #include /* ----------------------------------------------------------------------------- * swigrun.swg * * This file contains generic CAPI SWIG runtime support for pointer * type checking. * ----------------------------------------------------------------------------- */ /* This should only be incremented when either the layout of swig_type_info changes, or for whatever reason, the runtime changes incompatibly */ #define SWIG_RUNTIME_VERSION "3" /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ #ifdef SWIG_TYPE_TABLE # define SWIG_QUOTE_STRING(x) #x # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) #else # define SWIG_TYPE_TABLE_NAME #endif /* You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for creating a static or dynamic library from the swig runtime code. In 99.9% of the cases, swig just needs to declare them as 'static'. But only do this if is strictly necessary, ie, if you have problems with your compiler or so. */ #ifndef SWIGRUNTIME # define SWIGRUNTIME SWIGINTERN #endif #ifndef SWIGRUNTIMEINLINE # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE #endif /* Generic buffer size */ #ifndef SWIG_BUFFER_SIZE # define SWIG_BUFFER_SIZE 1024 #endif /* Flags for pointer conversions */ #define SWIG_POINTER_DISOWN 0x1 /* Flags for new pointer objects */ #define SWIG_POINTER_OWN 0x1 /* Flags/methods for returning states. The swig conversion methods, as ConvertPtr, return and integer that tells if the conversion was successful or not. And if not, an error code can be returned (see swigerrors.swg for the codes). Use the following macros/flags to set or process the returning states. In old swig versions, you usually write code as: if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { // success code } else { //fail code } Now you can be more explicit as: int res = SWIG_ConvertPtr(obj,vptr,ty.flags); if (SWIG_IsOK(res)) { // success code } else { // fail code } that seems to be the same, but now you can also do Type *ptr; int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); if (SWIG_IsOK(res)) { // success code if (SWIG_IsNewObj(res) { ... delete *ptr; } else { ... } } else { // fail code } I.e., now SWIG_ConvertPtr can return new objects and you can identify the case and take care of the deallocation. Of course that requires also to SWIG_ConvertPtr to return new result values, as int SWIG_ConvertPtr(obj, ptr,...) { if () { if () { *ptr = ; return SWIG_NEWOBJ; } else { *ptr = ; return SWIG_OLDOBJ; } } else { return SWIG_BADOBJ; } } Of course, returning the plain '0(success)/-1(fail)' still works, but you can be more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the swig errors code. Finally, if the SWIG_CASTRANK_MODE is enabled, the result code allows to return the 'cast rank', for example, if you have this int food(double) int fooi(int); and you call food(1) // cast rank '1' (1 -> 1.0) fooi(1) // cast rank '0' just use the SWIG_AddCast()/SWIG_CheckState() */ #define SWIG_OK (0) #define SWIG_ERROR (-1) #define SWIG_IsOK(r) (r >= 0) #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) /* The CastRankLimit says how many bits are used for the cast rank */ #define SWIG_CASTRANKLIMIT (1 << 8) /* The NewMask denotes the object was created (using new/malloc) */ #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) /* The TmpMask is for in/out typemaps that use temporal objects */ #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) /* Simple returning values */ #define SWIG_BADOBJ (SWIG_ERROR) #define SWIG_OLDOBJ (SWIG_OK) #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) /* Check, add and del mask methods */ #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) /* Cast-Rank Mode */ #if defined(SWIG_CASTRANK_MODE) # ifndef SWIG_TypeRank # define SWIG_TypeRank unsigned long # endif # ifndef SWIG_MAXCASTRANK /* Default cast allowed */ # define SWIG_MAXCASTRANK (2) # endif # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) SWIGINTERNINLINE int SWIG_AddCast(int r) { return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; } SWIGINTERNINLINE int SWIG_CheckState(int r) { return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; } #else /* no cast-rank mode */ # define SWIG_AddCast # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) #endif #include #ifdef __cplusplus extern "C" { #endif typedef void *(*swig_converter_func)(void *); typedef struct swig_type_info *(*swig_dycast_func)(void **); /* Structure to store inforomation on one type */ typedef struct swig_type_info { const char *name; /* mangled name of this type */ const char *str; /* human readable name of this type */ swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ struct swig_cast_info *cast; /* linked list of types that can cast into this type */ void *clientdata; /* language specific type data */ int owndata; /* flag if the structure owns the clientdata */ } swig_type_info; /* Structure to store a type and conversion function used for casting */ typedef struct swig_cast_info { swig_type_info *type; /* pointer to type that is equivalent to this type */ swig_converter_func converter; /* function to cast the void pointers */ struct swig_cast_info *next; /* pointer to next cast in linked list */ struct swig_cast_info *prev; /* pointer to the previous cast */ } swig_cast_info; /* Structure used to store module information * Each module generates one structure like this, and the runtime collects * all of these structures and stores them in a circularly linked list.*/ typedef struct swig_module_info { swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ size_t size; /* Number of types in this module */ struct swig_module_info *next; /* Pointer to next element in circularly linked list */ swig_type_info **type_initial; /* Array of initially generated type structures */ swig_cast_info **cast_initial; /* Array of initially generated casting structures */ void *clientdata; /* Language specific module data */ } swig_module_info; /* Compare two type names skipping the space characters, therefore "char*" == "char *" and "Class" == "Class", etc. Return 0 when the two name types are equivalent, as in strncmp, but skipping ' '. */ SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2) { for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { while ((*f1 == ' ') && (f1 != l1)) ++f1; while ((*f2 == ' ') && (f2 != l2)) ++f2; if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; } return (l1 - f1) - (l2 - f2); } /* Check type equivalence in a name list like ||... Return 0 if not equal, 1 if equal */ SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb) { int equiv = 0; const char* te = tb + strlen(tb); const char* ne = nb; while (!equiv && *ne) { for (nb = ne; *ne; ++ne) { if (*ne == '|') break; } equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; if (*ne) ++ne; } return equiv; } /* Check type equivalence in a name list like ||... Return 0 if equal, -1 if nb < tb, 1 if nb > tb */ SWIGRUNTIME int SWIG_TypeCompare(const char *nb, const char *tb) { int equiv = 0; const char* te = tb + strlen(tb); const char* ne = nb; while (!equiv && *ne) { for (nb = ne; *ne; ++ne) { if (*ne == '|') break; } equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; if (*ne) ++ne; } return equiv; } /* think of this as a c++ template<> or a scheme macro */ #define SWIG_TypeCheck_Template(comparison, ty) \ if (ty) { \ swig_cast_info *iter = ty->cast; \ while (iter) { \ if (comparison) { \ if (iter == ty->cast) return iter; \ /* Move iter to the top of the linked list */ \ iter->prev->next = iter->next; \ if (iter->next) \ iter->next->prev = iter->prev; \ iter->next = ty->cast; \ iter->prev = 0; \ if (ty->cast) ty->cast->prev = iter; \ ty->cast = iter; \ return iter; \ } \ iter = iter->next; \ } \ } \ return 0 /* Check the typename */ SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty) { SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty); } /* Same as previous function, except strcmp is replaced with a pointer comparison */ SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) { SWIG_TypeCheck_Template(iter->type == from, into); } /* Cast a pointer up an inheritance hierarchy */ SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr) { return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr); } /* Dynamic pointer casting. Down an inheritance hierarchy */ SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { swig_type_info *lastty = ty; if (!ty || !ty->dcast) return ty; while (ty && (ty->dcast)) { ty = (*ty->dcast)(ptr); if (ty) lastty = ty; } return lastty; } /* Return the name associated with this type */ SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty) { return ty->name; } /* Return the pretty name associated with this type, that is an unmangled type name in a form presentable to the user. */ SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type) { /* The "str" field contains the equivalent pretty names of the type, separated by vertical-bar characters. We choose to print the last name, as it is often (?) the most specific. */ if (!type) return NULL; if (type->str != NULL) { const char *last_name = type->str; const char *s; for (s = type->str; *s; s++) if (*s == '|') last_name = s+1; return last_name; } else return type->name; } /* Set the clientdata field for a type */ SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { swig_cast_info *cast = ti->cast; /* if (ti->clientdata == clientdata) return; */ ti->clientdata = clientdata; while (cast) { if (!cast->converter) { swig_type_info *tc = cast->type; if (!tc->clientdata) { SWIG_TypeClientData(tc, clientdata); } } cast = cast->next; } } SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { SWIG_TypeClientData(ti, clientdata); ti->owndata = 1; } /* Search for a swig_type_info structure only by mangled name Search is a O(log #types) We start searching at module start, and finish searching when start == end. Note: if start == end at the beginning of the function, we go all the way around the circular list. */ SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name) { swig_module_info *iter = start; do { if (iter->size) { register size_t l = 0; register size_t r = iter->size - 1; do { /* since l+r >= 0, we can (>> 1) instead (/ 2) */ register size_t i = (l + r) >> 1; const char *iname = iter->types[i]->name; if (iname) { register int compare = strcmp(name, iname); if (compare == 0) { return iter->types[i]; } else if (compare < 0) { if (i) { r = i - 1; } else { break; } } else if (compare > 0) { l = i + 1; } } else { break; /* should never happen */ } } while (l <= r); } iter = iter->next; } while (iter != end); return 0; } /* Search for a swig_type_info structure for either a mangled name or a human readable name. It first searches the mangled names of the types, which is a O(log #types) If a type is not found it then searches the human readable names, which is O(#types). We start searching at module start, and finish searching when start == end. Note: if start == end at the beginning of the function, we go all the way around the circular list. */ SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name) { /* STEP 1: Search the name field using binary search */ swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); if (ret) { return ret; } else { /* STEP 2: If the type hasn't been found, do a complete search of the str field (the human readable name) */ swig_module_info *iter = start; do { register size_t i = 0; for (; i < iter->size; ++i) { if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) return iter->types[i]; } iter = iter->next; } while (iter != end); } /* neither found a match */ return 0; } /* Pack binary data into a string */ SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz) { static const char hex[17] = "0123456789abcdef"; register const unsigned char *u = (unsigned char *) ptr; register const unsigned char *eu = u + sz; for (; u != eu; ++u) { register unsigned char uu = *u; *(c++) = hex[(uu & 0xf0) >> 4]; *(c++) = hex[uu & 0xf]; } return c; } /* Unpack binary data from a string */ SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) { register unsigned char *u = (unsigned char *) ptr; register const unsigned char *eu = u + sz; for (; u != eu; ++u) { register char d = *(c++); register unsigned char uu; if ((d >= '0') && (d <= '9')) uu = ((d - '0') << 4); else if ((d >= 'a') && (d <= 'f')) uu = ((d - ('a'-10)) << 4); else return (char *) 0; d = *(c++); if ((d >= '0') && (d <= '9')) uu |= (d - '0'); else if ((d >= 'a') && (d <= 'f')) uu |= (d - ('a'-10)); else return (char *) 0; *u = uu; } return c; } /* Pack 'void *' into a string buffer. */ SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { char *r = buff; if ((2*sizeof(void *) + 2) > bsz) return 0; *(r++) = '_'; r = SWIG_PackData(r,&ptr,sizeof(void *)); if (strlen(name) + 1 > (bsz - (r - buff))) return 0; strcpy(r,name); return buff; } SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { if (*c != '_') { if (strcmp(c,"NULL") == 0) { *ptr = (void *) 0; return name; } else { return 0; } } return SWIG_UnpackData(++c,ptr,sizeof(void *)); } SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { char *r = buff; size_t lname = (name ? strlen(name) : 0); if ((2*sz + 2 + lname) > bsz) return 0; *(r++) = '_'; r = SWIG_PackData(r,ptr,sz); if (lname) { strncpy(r,name,lname+1); } else { *r = 0; } return buff; } SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { if (*c != '_') { if (strcmp(c,"NULL") == 0) { memset(ptr,0,sz); return name; } else { return 0; } } return SWIG_UnpackData(++c,ptr,sz); } #ifdef __cplusplus } #endif /* Errors in SWIG */ #define SWIG_UnknownError -1 #define SWIG_IOError -2 #define SWIG_RuntimeError -3 #define SWIG_IndexError -4 #define SWIG_TypeError -5 #define SWIG_DivisionByZero -6 #define SWIG_OverflowError -7 #define SWIG_SyntaxError -8 #define SWIG_ValueError -9 #define SWIG_SystemError -10 #define SWIG_AttributeError -11 #define SWIG_MemoryError -12 #define SWIG_NullReferenceError -13 /* Add PyOS_snprintf for old Pythons */ #if PY_VERSION_HEX < 0x02020000 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM) # define PyOS_snprintf _snprintf # else # define PyOS_snprintf snprintf # endif #endif /* A crude PyString_FromFormat implementation for old Pythons */ #if PY_VERSION_HEX < 0x02020000 #ifndef SWIG_PYBUFFER_SIZE # define SWIG_PYBUFFER_SIZE 1024 #endif static PyObject * PyString_FromFormat(const char *fmt, ...) { va_list ap; char buf[SWIG_PYBUFFER_SIZE * 2]; int res; va_start(ap, fmt); res = vsnprintf(buf, sizeof(buf), fmt, ap); va_end(ap); return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf); } #endif /* Add PyObject_Del for old Pythons */ #if PY_VERSION_HEX < 0x01060000 # define PyObject_Del(op) PyMem_DEL((op)) #endif #ifndef PyObject_DEL # define PyObject_DEL PyObject_Del #endif /* A crude PyExc_StopIteration exception for old Pythons */ #if PY_VERSION_HEX < 0x02020000 # ifndef PyExc_StopIteration # define PyExc_StopIteration PyExc_RuntimeError # endif # ifndef PyObject_GenericGetAttr # define PyObject_GenericGetAttr 0 # endif #endif /* Py_NotImplemented is defined in 2.1 and up. */ #if PY_VERSION_HEX < 0x02010000 # ifndef Py_NotImplemented # define Py_NotImplemented PyExc_RuntimeError # endif #endif /* A crude PyString_AsStringAndSize implementation for old Pythons */ #if PY_VERSION_HEX < 0x02010000 # ifndef PyString_AsStringAndSize # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;} # endif #endif /* PySequence_Size for old Pythons */ #if PY_VERSION_HEX < 0x02000000 # ifndef PySequence_Size # define PySequence_Size PySequence_Length # endif #endif /* PyBool_FromLong for old Pythons */ #if PY_VERSION_HEX < 0x02030000 static PyObject *PyBool_FromLong(long ok) { PyObject *result = ok ? Py_True : Py_False; Py_INCREF(result); return result; } #endif /* Py_ssize_t for old Pythons */ /* This code is as recommended by: */ /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */ #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) typedef int Py_ssize_t; # define PY_SSIZE_T_MAX INT_MAX # define PY_SSIZE_T_MIN INT_MIN #endif /* ----------------------------------------------------------------------------- * error manipulation * ----------------------------------------------------------------------------- */ SWIGRUNTIME PyObject* SWIG_Python_ErrorType(int code) { PyObject* type = 0; switch(code) { case SWIG_MemoryError: type = PyExc_MemoryError; break; case SWIG_IOError: type = PyExc_IOError; break; case SWIG_RuntimeError: type = PyExc_RuntimeError; break; case SWIG_IndexError: type = PyExc_IndexError; break; case SWIG_TypeError: type = PyExc_TypeError; break; case SWIG_DivisionByZero: type = PyExc_ZeroDivisionError; break; case SWIG_OverflowError: type = PyExc_OverflowError; break; case SWIG_SyntaxError: type = PyExc_SyntaxError; break; case SWIG_ValueError: type = PyExc_ValueError; break; case SWIG_SystemError: type = PyExc_SystemError; break; case SWIG_AttributeError: type = PyExc_AttributeError; break; default: type = PyExc_RuntimeError; } return type; } SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char* mesg) { PyObject *type = 0; PyObject *value = 0; PyObject *traceback = 0; if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback); if (value) { PyObject *old_str = PyObject_Str(value); PyErr_Clear(); Py_XINCREF(type); PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); Py_DECREF(old_str); Py_DECREF(value); } else { PyErr_Format(PyExc_RuntimeError, mesg); } } #if defined(SWIG_PYTHON_NO_THREADS) # if defined(SWIG_PYTHON_THREADS) # undef SWIG_PYTHON_THREADS # endif #endif #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */ # define SWIG_PYTHON_USE_GIL # endif # endif # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ # ifndef SWIG_PYTHON_INITIALIZE_THREADS # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() # endif # ifdef __cplusplus /* C++ code */ class SWIG_Python_Thread_Block { bool status; PyGILState_STATE state; public: void end() { if (status) { PyGILState_Release(state); status = false;} } SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} ~SWIG_Python_Thread_Block() { end(); } }; class SWIG_Python_Thread_Allow { bool status; PyThreadState *save; public: void end() { if (status) { PyEval_RestoreThread(save); status = false; }} SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} ~SWIG_Python_Thread_Allow() { end(); } }; # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() # else /* C code */ # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) # endif # else /* Old thread way, not implemented, user must provide it */ # if !defined(SWIG_PYTHON_INITIALIZE_THREADS) # define SWIG_PYTHON_INITIALIZE_THREADS # endif # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) # define SWIG_PYTHON_THREAD_BEGIN_BLOCK # endif # if !defined(SWIG_PYTHON_THREAD_END_BLOCK) # define SWIG_PYTHON_THREAD_END_BLOCK # endif # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) # define SWIG_PYTHON_THREAD_BEGIN_ALLOW # endif # if !defined(SWIG_PYTHON_THREAD_END_ALLOW) # define SWIG_PYTHON_THREAD_END_ALLOW # endif # endif #else /* No thread support */ # define SWIG_PYTHON_INITIALIZE_THREADS # define SWIG_PYTHON_THREAD_BEGIN_BLOCK # define SWIG_PYTHON_THREAD_END_BLOCK # define SWIG_PYTHON_THREAD_BEGIN_ALLOW # define SWIG_PYTHON_THREAD_END_ALLOW #endif /* ----------------------------------------------------------------------------- * Python API portion that goes into the runtime * ----------------------------------------------------------------------------- */ #ifdef __cplusplus extern "C" { #if 0 } /* cc-mode */ #endif #endif /* ----------------------------------------------------------------------------- * Constant declarations * ----------------------------------------------------------------------------- */ /* Constant Types */ #define SWIG_PY_POINTER 4 #define SWIG_PY_BINARY 5 /* Constant information structure */ typedef struct swig_const_info { int type; char *name; long lvalue; double dvalue; void *pvalue; swig_type_info **ptype; } swig_const_info; #ifdef __cplusplus #if 0 { /* cc-mode */ #endif } #endif /* ----------------------------------------------------------------------------- * See the LICENSE file for information on copyright, usage and redistribution * of SWIG, and the README file for authors - http://www.swig.org/release.html. * * pyrun.swg * * This file contains the runtime support for Python modules * and includes code for managing global variables and pointer * type checking. * * ----------------------------------------------------------------------------- */ /* Common SWIG API */ /* for raw pointers */ #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags) #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) #define swig_owntype int /* for raw packed data */ #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) /* for class or struct pointers */ #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) /* for C or C++ function pointers */ #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0) /* for C++ member pointers, ie, member methods */ #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) /* Runtime API */ #define SWIG_GetModule(clientdata) SWIG_Python_GetModule() #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) #define SWIG_NewClientData(obj) PySwigClientData_New(obj) #define SWIG_SetErrorObj SWIG_Python_SetErrorObj #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) #define SWIG_fail goto fail /* Runtime API implementation */ /* Error manipulation */ SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { SWIG_PYTHON_THREAD_BEGIN_BLOCK; PyErr_SetObject(errtype, obj); Py_DECREF(obj); SWIG_PYTHON_THREAD_END_BLOCK; } SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { SWIG_PYTHON_THREAD_BEGIN_BLOCK; PyErr_SetString(errtype, (char *) msg); SWIG_PYTHON_THREAD_END_BLOCK; } #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) /* Set a constant value */ SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { PyDict_SetItemString(d, (char*) name, obj); Py_DECREF(obj); } /* Append a value to the result obj */ SWIGINTERN PyObject* SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { #if !defined(SWIG_PYTHON_OUTPUT_TUPLE) if (!result) { result = obj; } else if (result == Py_None) { Py_DECREF(result); result = obj; } else { if (!PyList_Check(result)) { PyObject *o2 = result; result = PyList_New(1); PyList_SetItem(result, 0, o2); } PyList_Append(result,obj); Py_DECREF(obj); } return result; #else PyObject* o2; PyObject* o3; if (!result) { result = obj; } else if (result == Py_None) { Py_DECREF(result); result = obj; } else { if (!PyTuple_Check(result)) { o2 = result; result = PyTuple_New(1); PyTuple_SET_ITEM(result, 0, o2); } o3 = PyTuple_New(1); PyTuple_SET_ITEM(o3, 0, obj); o2 = result; result = PySequence_Concat(o2, o3); Py_DECREF(o2); Py_DECREF(o3); } return result; #endif } /* Unpack the argument tuple */ SWIGINTERN int SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs) { if (!args) { if (!min && !max) { return 1; } else { PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", name, (min == max ? "" : "at least "), min); return 0; } } if (!PyTuple_Check(args)) { PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); return 0; } else { register int l = PyTuple_GET_SIZE(args); if (l < min) { PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", name, (min == max ? "" : "at least "), min, l); return 0; } else if (l > max) { PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", name, (min == max ? "" : "at most "), max, l); return 0; } else { register int i; for (i = 0; i < l; ++i) { objs[i] = PyTuple_GET_ITEM(args, i); } for (; l < max; ++l) { objs[l] = 0; } return i + 1; } } } /* A functor is a function object with one single object argument */ #if PY_VERSION_HEX >= 0x02020000 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); #else #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj); #endif /* Helper for static pointer initialization for both C and C++ code, for example static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); */ #ifdef __cplusplus #define SWIG_STATIC_POINTER(var) var #else #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var #endif /* ----------------------------------------------------------------------------- * Pointer declarations * ----------------------------------------------------------------------------- */ /* Flags for new pointer objects */ #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) #ifdef __cplusplus extern "C" { #if 0 } /* cc-mode */ #endif #endif /* How to access Py_None */ #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) # ifndef SWIG_PYTHON_NO_BUILD_NONE # ifndef SWIG_PYTHON_BUILD_NONE # define SWIG_PYTHON_BUILD_NONE # endif # endif #endif #ifdef SWIG_PYTHON_BUILD_NONE # ifdef Py_None # undef Py_None # define Py_None SWIG_Py_None() # endif SWIGRUNTIMEINLINE PyObject * _SWIG_Py_None(void) { PyObject *none = Py_BuildValue((char*)""); Py_DECREF(none); return none; } SWIGRUNTIME PyObject * SWIG_Py_None(void) { static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None(); return none; } #endif /* The python void return value */ SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void) { PyObject *none = Py_None; Py_INCREF(none); return none; } /* PySwigClientData */ typedef struct { PyObject *klass; PyObject *newraw; PyObject *newargs; PyObject *destroy; int delargs; int implicitconv; } PySwigClientData; SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty) { PySwigClientData *data = (PySwigClientData *)ty->clientdata; return data ? data->implicitconv : 0; } SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc) { PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0; PyObject *klass = data ? data->klass : 0; return (klass ? klass : PyExc_RuntimeError); } SWIGRUNTIME PySwigClientData * PySwigClientData_New(PyObject* obj) { if (!obj) { return 0; } else { PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData)); /* the klass element */ data->klass = obj; Py_INCREF(data->klass); /* the newraw method and newargs arguments used to create a new raw instance */ if (PyClass_Check(obj)) { data->newraw = 0; data->newargs = obj; Py_INCREF(obj); } else { #if (PY_VERSION_HEX < 0x02020000) data->newraw = 0; #else data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__"); #endif if (data->newraw) { Py_INCREF(data->newraw); data->newargs = PyTuple_New(1); PyTuple_SetItem(data->newargs, 0, obj); } else { data->newargs = obj; } Py_INCREF(data->newargs); } /* the destroy method, aka as the C++ delete method */ data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__"); if (PyErr_Occurred()) { PyErr_Clear(); data->destroy = 0; } if (data->destroy) { int flags; Py_INCREF(data->destroy); flags = PyCFunction_GET_FLAGS(data->destroy); #ifdef METH_O data->delargs = !(flags & (METH_O)); #else data->delargs = 0; #endif } else { data->delargs = 0; } data->implicitconv = 0; return data; } } SWIGRUNTIME void PySwigClientData_Del(PySwigClientData* data) { Py_XDECREF(data->newraw); Py_XDECREF(data->newargs); Py_XDECREF(data->destroy); } /* =============== PySwigObject =====================*/ typedef struct { PyObject_HEAD void *ptr; swig_type_info *ty; int own; PyObject *next; } PySwigObject; SWIGRUNTIME PyObject * PySwigObject_long(PySwigObject *v) { return PyLong_FromVoidPtr(v->ptr); } SWIGRUNTIME PyObject * PySwigObject_format(const char* fmt, PySwigObject *v) { PyObject *res = NULL; PyObject *args = PyTuple_New(1); if (args) { if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) { PyObject *ofmt = PyString_FromString(fmt); if (ofmt) { res = PyString_Format(ofmt,args); Py_DECREF(ofmt); } Py_DECREF(args); } } return res; } SWIGRUNTIME PyObject * PySwigObject_oct(PySwigObject *v) { return PySwigObject_format("%o",v); } SWIGRUNTIME PyObject * PySwigObject_hex(PySwigObject *v) { return PySwigObject_format("%x",v); } SWIGRUNTIME PyObject * #ifdef METH_NOARGS PySwigObject_repr(PySwigObject *v) #else PySwigObject_repr(PySwigObject *v, PyObject *args) #endif { const char *name = SWIG_TypePrettyName(v->ty); PyObject *hex = PySwigObject_hex(v); PyObject *repr = PyString_FromFormat("", name, PyString_AsString(hex)); Py_DECREF(hex); if (v->next) { #ifdef METH_NOARGS PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next); #else PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args); #endif PyString_ConcatAndDel(&repr,nrep); } return repr; } SWIGRUNTIME int PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { #ifdef METH_NOARGS PyObject *repr = PySwigObject_repr(v); #else PyObject *repr = PySwigObject_repr(v, NULL); #endif if (repr) { fputs(PyString_AsString(repr), fp); Py_DECREF(repr); return 0; } else { return 1; } } SWIGRUNTIME PyObject * PySwigObject_str(PySwigObject *v) { char result[SWIG_BUFFER_SIZE]; return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ? PyString_FromString(result) : 0; } SWIGRUNTIME int PySwigObject_compare(PySwigObject *v, PySwigObject *w) { void *i = v->ptr; void *j = w->ptr; return (i < j) ? -1 : ((i > j) ? 1 : 0); } SWIGRUNTIME PyTypeObject* _PySwigObject_type(void); SWIGRUNTIME PyTypeObject* PySwigObject_type(void) { static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type(); return type; } SWIGRUNTIMEINLINE int PySwigObject_Check(PyObject *op) { return ((op)->ob_type == PySwigObject_type()) || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0); } SWIGRUNTIME PyObject * PySwigObject_New(void *ptr, swig_type_info *ty, int own); SWIGRUNTIME void PySwigObject_dealloc(PyObject *v) { PySwigObject *sobj = (PySwigObject *) v; PyObject *next = sobj->next; if (sobj->own) { swig_type_info *ty = sobj->ty; PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0; PyObject *destroy = data ? data->destroy : 0; if (destroy) { /* destroy is always a VARARGS method */ PyObject *res; if (data->delargs) { /* we need to create a temporal object to carry the destroy operation */ PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0); res = SWIG_Python_CallFunctor(destroy, tmp); Py_DECREF(tmp); } else { PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); PyObject *mself = PyCFunction_GET_SELF(destroy); res = ((*meth)(mself, v)); } Py_XDECREF(res); } else { const char *name = SWIG_TypePrettyName(ty); #if !defined(SWIG_PYTHON_SILENT_MEMLEAK) printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name); #endif } } Py_XDECREF(next); PyObject_DEL(v); } SWIGRUNTIME PyObject* PySwigObject_append(PyObject* v, PyObject* next) { PySwigObject *sobj = (PySwigObject *) v; #ifndef METH_O PyObject *tmp = 0; if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL; next = tmp; #endif if (!PySwigObject_Check(next)) { return NULL; } sobj->next = next; Py_INCREF(next); return SWIG_Py_Void(); } SWIGRUNTIME PyObject* #ifdef METH_NOARGS PySwigObject_next(PyObject* v) #else PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) #endif { PySwigObject *sobj = (PySwigObject *) v; if (sobj->next) { Py_INCREF(sobj->next); return sobj->next; } else { return SWIG_Py_Void(); } } SWIGINTERN PyObject* #ifdef METH_NOARGS PySwigObject_disown(PyObject *v) #else PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) #endif { PySwigObject *sobj = (PySwigObject *)v; sobj->own = 0; return SWIG_Py_Void(); } SWIGINTERN PyObject* #ifdef METH_NOARGS PySwigObject_acquire(PyObject *v) #else PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) #endif { PySwigObject *sobj = (PySwigObject *)v; sobj->own = SWIG_POINTER_OWN; return SWIG_Py_Void(); } SWIGINTERN PyObject* PySwigObject_own(PyObject *v, PyObject *args) { PyObject *val = 0; #if (PY_VERSION_HEX < 0x02020000) if (!PyArg_ParseTuple(args,(char *)"|O:own",&val)) #else if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) #endif { return NULL; } else { PySwigObject *sobj = (PySwigObject *)v; PyObject *obj = PyBool_FromLong(sobj->own); if (val) { #ifdef METH_NOARGS if (PyObject_IsTrue(val)) { PySwigObject_acquire(v); } else { PySwigObject_disown(v); } #else if (PyObject_IsTrue(val)) { PySwigObject_acquire(v,args); } else { PySwigObject_disown(v,args); } #endif } return obj; } } #ifdef METH_O static PyMethodDef swigobject_methods[] = { {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"}, {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"}, {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"}, {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"}, {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"}, {0, 0, 0, 0} }; #else static PyMethodDef swigobject_methods[] = { {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"}, {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"}, {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"}, {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"}, {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"}, {0, 0, 0, 0} }; #endif #if PY_VERSION_HEX < 0x02020000 SWIGINTERN PyObject * PySwigObject_getattr(PySwigObject *sobj,char *name) { return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); } #endif SWIGRUNTIME PyTypeObject* _PySwigObject_type(void) { static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; static PyNumberMethods PySwigObject_as_number = { (binaryfunc)0, /*nb_add*/ (binaryfunc)0, /*nb_subtract*/ (binaryfunc)0, /*nb_multiply*/ (binaryfunc)0, /*nb_divide*/ (binaryfunc)0, /*nb_remainder*/ (binaryfunc)0, /*nb_divmod*/ (ternaryfunc)0,/*nb_power*/ (unaryfunc)0, /*nb_negative*/ (unaryfunc)0, /*nb_positive*/ (unaryfunc)0, /*nb_absolute*/ (inquiry)0, /*nb_nonzero*/ 0, /*nb_invert*/ 0, /*nb_lshift*/ 0, /*nb_rshift*/ 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ (coercion)0, /*nb_coerce*/ (unaryfunc)PySwigObject_long, /*nb_int*/ (unaryfunc)PySwigObject_long, /*nb_long*/ (unaryfunc)0, /*nb_float*/ (unaryfunc)PySwigObject_oct, /*nb_oct*/ (unaryfunc)PySwigObject_hex, /*nb_hex*/ #if PY_VERSION_HEX >= 0x02020000 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ #elif PY_VERSION_HEX >= 0x02000000 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */ #endif }; static PyTypeObject pyswigobject_type; static int type_init = 0; if (!type_init) { const PyTypeObject tmp = { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ (char *)"PySwigObject", /* tp_name */ sizeof(PySwigObject), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)PySwigObject_dealloc, /* tp_dealloc */ (printfunc)PySwigObject_print, /* tp_print */ #if PY_VERSION_HEX < 0x02020000 (getattrfunc)PySwigObject_getattr, /* tp_getattr */ #else (getattrfunc)0, /* tp_getattr */ #endif (setattrfunc)0, /* tp_setattr */ (cmpfunc)PySwigObject_compare, /* tp_compare */ (reprfunc)PySwigObject_repr, /* tp_repr */ &PySwigObject_as_number, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ (hashfunc)0, /* tp_hash */ (ternaryfunc)0, /* tp_call */ (reprfunc)PySwigObject_str, /* tp_str */ PyObject_GenericGetAttr, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT, /* tp_flags */ swigobject_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ #if PY_VERSION_HEX >= 0x02020000 0, /* tp_iter */ 0, /* tp_iternext */ swigobject_methods, /* tp_methods */ 0, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ 0, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ 0, /* tp_free */ 0, /* tp_is_gc */ 0, /* tp_bases */ 0, /* tp_mro */ 0, /* tp_cache */ 0, /* tp_subclasses */ 0, /* tp_weaklist */ #endif #if PY_VERSION_HEX >= 0x02030000 0, /* tp_del */ #endif #ifdef COUNT_ALLOCS 0,0,0,0 /* tp_alloc -> tp_next */ #endif }; pyswigobject_type = tmp; pyswigobject_type.ob_type = &PyType_Type; type_init = 1; } return &pyswigobject_type; } SWIGRUNTIME PyObject * PySwigObject_New(void *ptr, swig_type_info *ty, int own) { PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type()); if (sobj) { sobj->ptr = ptr; sobj->ty = ty; sobj->own = own; sobj->next = 0; } return (PyObject *)sobj; } /* ----------------------------------------------------------------------------- * Implements a simple Swig Packed type, and use it instead of string * ----------------------------------------------------------------------------- */ typedef struct { PyObject_HEAD void *pack; swig_type_info *ty; size_t size; } PySwigPacked; SWIGRUNTIME int PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { char result[SWIG_BUFFER_SIZE]; fputs("pack, v->size, 0, sizeof(result))) { fputs("at ", fp); fputs(result, fp); } fputs(v->ty->name,fp); fputs(">", fp); return 0; } SWIGRUNTIME PyObject * PySwigPacked_repr(PySwigPacked *v) { char result[SWIG_BUFFER_SIZE]; if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { return PyString_FromFormat("", result, v->ty->name); } else { return PyString_FromFormat("", v->ty->name); } } SWIGRUNTIME PyObject * PySwigPacked_str(PySwigPacked *v) { char result[SWIG_BUFFER_SIZE]; if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ return PyString_FromFormat("%s%s", result, v->ty->name); } else { return PyString_FromString(v->ty->name); } } SWIGRUNTIME int PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w) { size_t i = v->size; size_t j = w->size; int s = (i < j) ? -1 : ((i > j) ? 1 : 0); return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size); } SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void); SWIGRUNTIME PyTypeObject* PySwigPacked_type(void) { static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type(); return type; } SWIGRUNTIMEINLINE int PySwigPacked_Check(PyObject *op) { return ((op)->ob_type == _PySwigPacked_type()) || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0); } SWIGRUNTIME void PySwigPacked_dealloc(PyObject *v) { if (PySwigPacked_Check(v)) { PySwigPacked *sobj = (PySwigPacked *) v; free(sobj->pack); } PyObject_DEL(v); } SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void) { static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; static PyTypeObject pyswigpacked_type; static int type_init = 0; if (!type_init) { const PyTypeObject tmp = { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ (char *)"PySwigPacked", /* tp_name */ sizeof(PySwigPacked), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)PySwigPacked_dealloc, /* tp_dealloc */ (printfunc)PySwigPacked_print, /* tp_print */ (getattrfunc)0, /* tp_getattr */ (setattrfunc)0, /* tp_setattr */ (cmpfunc)PySwigPacked_compare, /* tp_compare */ (reprfunc)PySwigPacked_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ (hashfunc)0, /* tp_hash */ (ternaryfunc)0, /* tp_call */ (reprfunc)PySwigPacked_str, /* tp_str */ PyObject_GenericGetAttr, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT, /* tp_flags */ swigpacked_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ #if PY_VERSION_HEX >= 0x02020000 0, /* tp_iter */ 0, /* tp_iternext */ 0, /* tp_methods */ 0, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ 0, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ 0, /* tp_free */ 0, /* tp_is_gc */ 0, /* tp_bases */ 0, /* tp_mro */ 0, /* tp_cache */ 0, /* tp_subclasses */ 0, /* tp_weaklist */ #endif #if PY_VERSION_HEX >= 0x02030000 0, /* tp_del */ #endif #ifdef COUNT_ALLOCS 0,0,0,0 /* tp_alloc -> tp_next */ #endif }; pyswigpacked_type = tmp; pyswigpacked_type.ob_type = &PyType_Type; type_init = 1; } return &pyswigpacked_type; } SWIGRUNTIME PyObject * PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty) { PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type()); if (sobj) { void *pack = malloc(size); if (pack) { memcpy(pack, ptr, size); sobj->pack = pack; sobj->ty = ty; sobj->size = size; } else { PyObject_DEL((PyObject *) sobj); sobj = 0; } } return (PyObject *) sobj; } SWIGRUNTIME swig_type_info * PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size) { if (PySwigPacked_Check(obj)) { PySwigPacked *sobj = (PySwigPacked *)obj; if (sobj->size != size) return 0; memcpy(ptr, sobj->pack, size); return sobj->ty; } else { return 0; } } /* ----------------------------------------------------------------------------- * pointers/data manipulation * ----------------------------------------------------------------------------- */ SWIGRUNTIMEINLINE PyObject * _SWIG_This(void) { return PyString_FromString("this"); } SWIGRUNTIME PyObject * SWIG_This(void) { static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This(); return swig_this; } /* #define SWIG_PYTHON_SLOW_GETSET_THIS */ SWIGRUNTIME PySwigObject * SWIG_Python_GetSwigThis(PyObject *pyobj) { if (PySwigObject_Check(pyobj)) { return (PySwigObject *) pyobj; } else { PyObject *obj = 0; #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000)) if (PyInstance_Check(pyobj)) { obj = _PyInstance_Lookup(pyobj, SWIG_This()); } else { PyObject **dictptr = _PyObject_GetDictPtr(pyobj); if (dictptr != NULL) { PyObject *dict = *dictptr; obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; } else { #ifdef PyWeakref_CheckProxy if (PyWeakref_CheckProxy(pyobj)) { PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; } #endif obj = PyObject_GetAttr(pyobj,SWIG_This()); if (obj) { Py_DECREF(obj); } else { if (PyErr_Occurred()) PyErr_Clear(); return 0; } } } #else obj = PyObject_GetAttr(pyobj,SWIG_This()); if (obj) { Py_DECREF(obj); } else { if (PyErr_Occurred()) PyErr_Clear(); return 0; } #endif if (obj && !PySwigObject_Check(obj)) { /* a PyObject is called 'this', try to get the 'real this' PySwigObject from it */ return SWIG_Python_GetSwigThis(obj); } return (PySwigObject *)obj; } } /* Acquire a pointer value */ SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own) { if (own) { PySwigObject *sobj = SWIG_Python_GetSwigThis(obj); if (sobj) { int oldown = sobj->own; sobj->own = own; return oldown; } } return 0; } /* Convert a pointer value */ SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { if (!obj) return SWIG_ERROR; if (obj == Py_None) { if (ptr) *ptr = 0; return SWIG_OK; } else { PySwigObject *sobj = SWIG_Python_GetSwigThis(obj); while (sobj) { void *vptr = sobj->ptr; if (ty) { swig_type_info *to = sobj->ty; if (to == ty) { /* no type cast needed */ if (ptr) *ptr = vptr; break; } else { swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); if (!tc) { sobj = (PySwigObject *)sobj->next; } else { if (ptr) *ptr = SWIG_TypeCast(tc,vptr); break; } } } else { if (ptr) *ptr = vptr; break; } } if (sobj) { if (own) *own = sobj->own; if (flags & SWIG_POINTER_DISOWN) { sobj->own = 0; } return SWIG_OK; } else { int res = SWIG_ERROR; if (flags & SWIG_POINTER_IMPLICIT_CONV) { PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0; if (data && !data->implicitconv) { PyObject *klass = data->klass; if (klass) { PyObject *impconv; data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ impconv = SWIG_Python_CallFunctor(klass, obj); data->implicitconv = 0; if (PyErr_Occurred()) { PyErr_Clear(); impconv = 0; } if (impconv) { PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv); if (iobj) { void *vptr; res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); if (SWIG_IsOK(res)) { if (ptr) { *ptr = vptr; /* transfer the ownership to 'ptr' */ iobj->own = 0; res = SWIG_AddCast(res); res = SWIG_AddNewMask(res); } else { res = SWIG_AddCast(res); } } } Py_DECREF(impconv); } } } } return res; } } } /* Convert a function ptr value */ SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { if (!PyCFunction_Check(obj)) { return SWIG_ConvertPtr(obj, ptr, ty, 0); } else { void *vptr = 0; /* here we get the method pointer for callbacks */ const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; if (desc) { desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; if (!desc) return SWIG_ERROR; } if (ty) { swig_cast_info *tc = SWIG_TypeCheck(desc,ty); if (!tc) return SWIG_ERROR; *ptr = SWIG_TypeCast(tc,vptr); } else { *ptr = vptr; } return SWIG_OK; } } /* Convert a packed value value */ SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz); if (!to) return SWIG_ERROR; if (ty) { if (to != ty) { /* check type cast? */ swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); if (!tc) return SWIG_ERROR; } } return SWIG_OK; } /* ----------------------------------------------------------------------------- * Create a new pointer object * ----------------------------------------------------------------------------- */ /* Create a new instance object, whitout calling __init__, and set the 'this' attribute. */ SWIGRUNTIME PyObject* SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this) { #if (PY_VERSION_HEX >= 0x02020000) PyObject *inst = 0; PyObject *newraw = data->newraw; if (newraw) { inst = PyObject_Call(newraw, data->newargs, NULL); if (inst) { #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) PyObject **dictptr = _PyObject_GetDictPtr(inst); if (dictptr != NULL) { PyObject *dict = *dictptr; if (dict == NULL) { dict = PyDict_New(); *dictptr = dict; PyDict_SetItem(dict, SWIG_This(), swig_this); } } #else PyObject *key = SWIG_This(); PyObject_SetAttr(inst, key, swig_this); #endif } } else { PyObject *dict = PyDict_New(); PyDict_SetItem(dict, SWIG_This(), swig_this); inst = PyInstance_NewRaw(data->newargs, dict); Py_DECREF(dict); } return inst; #else #if (PY_VERSION_HEX >= 0x02010000) PyObject *inst; PyObject *dict = PyDict_New(); PyDict_SetItem(dict, SWIG_This(), swig_this); inst = PyInstance_NewRaw(data->newargs, dict); Py_DECREF(dict); return (PyObject *) inst; #else PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type); if (inst == NULL) { return NULL; } inst->in_class = (PyClassObject *)data->newargs; Py_INCREF(inst->in_class); inst->in_dict = PyDict_New(); if (inst->in_dict == NULL) { Py_DECREF(inst); return NULL; } #ifdef Py_TPFLAGS_HAVE_WEAKREFS inst->in_weakreflist = NULL; #endif #ifdef Py_TPFLAGS_GC PyObject_GC_Init(inst); #endif PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this); return (PyObject *) inst; #endif #endif } SWIGRUNTIME void SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) { PyObject *dict; #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS) PyObject **dictptr = _PyObject_GetDictPtr(inst); if (dictptr != NULL) { dict = *dictptr; if (dict == NULL) { dict = PyDict_New(); *dictptr = dict; } PyDict_SetItem(dict, SWIG_This(), swig_this); return; } #endif dict = PyObject_GetAttrString(inst, (char*)"__dict__"); PyDict_SetItem(dict, SWIG_This(), swig_this); Py_DECREF(dict); } SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args) { PyObject *obj[2]; if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) { return NULL; } else { PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]); if (sthis) { PySwigObject_append((PyObject*) sthis, obj[1]); } else { SWIG_Python_SetSwigThis(obj[0], obj[1]); } return SWIG_Py_Void(); } } /* Create a new pointer object */ SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) { if (!ptr) { return SWIG_Py_Void(); } else { int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; PyObject *robj = PySwigObject_New(ptr, type, own); PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0; if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); if (inst) { Py_DECREF(robj); robj = inst; } } return robj; } } /* Create a new packed object */ SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); } /* -----------------------------------------------------------------------------* * Get type list * -----------------------------------------------------------------------------*/ #ifdef SWIG_LINK_RUNTIME void *SWIG_ReturnGlobalTypeList(void *); #endif SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void) { static void *type_pointer = (void *)0; /* first check if module already created */ if (!type_pointer) { #ifdef SWIG_LINK_RUNTIME type_pointer = SWIG_ReturnGlobalTypeList((void *)0); #else type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); if (PyErr_Occurred()) { PyErr_Clear(); type_pointer = (void *)0; } #endif } return (swig_module_info *) type_pointer; } #if PY_MAJOR_VERSION < 2 /* PyModule_AddObject function was introduced in Python 2.0. The following function is copied out of Python/modsupport.c in python version 2.3.4 */ SWIGINTERN int PyModule_AddObject(PyObject *m, char *name, PyObject *o) { PyObject *dict; if (!PyModule_Check(m)) { PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg"); return SWIG_ERROR; } if (!o) { PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value"); return SWIG_ERROR; } dict = PyModule_GetDict(m); if (dict == NULL) { /* Internal error -- modules must have a dict! */ PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", PyModule_GetName(m)); return SWIG_ERROR; } if (PyDict_SetItemString(dict, name, o)) return SWIG_ERROR; Py_DECREF(o); return SWIG_OK; } #endif SWIGRUNTIME void SWIG_Python_DestroyModule(void *vptr) { swig_module_info *swig_module = (swig_module_info *) vptr; swig_type_info **types = swig_module->types; size_t i; for (i =0; i < swig_module->size; ++i) { swig_type_info *ty = types[i]; if (ty->owndata) { PySwigClientData *data = (PySwigClientData *) ty->clientdata; if (data) PySwigClientData_Del(data); } } Py_DECREF(SWIG_This()); } SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module) { static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */ PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule); if (pointer && module) { PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); } else { Py_XDECREF(pointer); } } /* The python cached type query */ SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void) { static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); return cache; } SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type) { PyObject *cache = SWIG_Python_TypeCache(); PyObject *key = PyString_FromString(type); PyObject *obj = PyDict_GetItem(cache, key); swig_type_info *descriptor; if (obj) { descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj); } else { swig_module_info *swig_module = SWIG_Python_GetModule(); descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); if (descriptor) { obj = PyCObject_FromVoidPtr(descriptor, NULL); PyDict_SetItem(cache, key, obj); Py_DECREF(obj); } } Py_DECREF(key); return descriptor; } /* For backward compatibility only */ #define SWIG_POINTER_EXCEPTION 0 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) SWIGRUNTIME int SWIG_Python_AddErrMesg(const char* mesg, int infront) { if (PyErr_Occurred()) { PyObject *type = 0; PyObject *value = 0; PyObject *traceback = 0; PyErr_Fetch(&type, &value, &traceback); if (value) { PyObject *old_str = PyObject_Str(value); Py_XINCREF(type); PyErr_Clear(); if (infront) { PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str)); } else { PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); } Py_DECREF(old_str); } return 1; } else { return 0; } } SWIGRUNTIME int SWIG_Python_ArgFail(int argnum) { if (PyErr_Occurred()) { /* add information about failing argument */ char mesg[256]; PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); return SWIG_Python_AddErrMesg(mesg, 1); } else { return 0; } } SWIGRUNTIMEINLINE const char * PySwigObject_GetDesc(PyObject *self) { PySwigObject *v = (PySwigObject *)self; swig_type_info *ty = v ? v->ty : 0; return ty ? ty->str : (char*)""; } SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj) { if (type) { #if defined(SWIG_COBJECT_TYPES) if (obj && PySwigObject_Check(obj)) { const char *otype = (const char *) PySwigObject_GetDesc(obj); if (otype) { PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received", type, otype); return; } } else #endif { const char *otype = (obj ? obj->ob_type->tp_name : 0); if (otype) { PyObject *str = PyObject_Str(obj); const char *cstr = str ? PyString_AsString(str) : 0; if (cstr) { PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", type, otype, cstr); } else { PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", type, otype); } Py_XDECREF(str); return; } } PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); } else { PyErr_Format(PyExc_TypeError, "unexpected type is received"); } } /* Convert a pointer value, signal an exception on a type mismatch */ SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) { void *result; if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { PyErr_Clear(); if (flags & SWIG_POINTER_EXCEPTION) { SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); SWIG_Python_ArgFail(argnum); } } return result; } #ifdef __cplusplus #if 0 { /* cc-mode */ #endif } #endif #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_char swig_types[0] #define SWIGTYPE_p_in_addr_t swig_types[1] #define SWIGTYPE_p_pcapObject swig_types[2] static swig_type_info *swig_types[4]; static swig_module_info swig_module = {swig_types, 3, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) /* -------- TYPES TABLE (END) -------- */ #if (PY_VERSION_HEX <= 0x02000000) # if !defined(SWIG_PYTHON_CLASSIC) # error "This python version requires swig to be run with the '-classic' option" # endif #endif /*----------------------------------------------- @(target):= _pcap.so ------------------------------------------------*/ #define SWIG_init init_pcap #define SWIG_name "_pcap" #define SWIGVERSION 0x010331 #define SWIG_VERSION SWIGVERSION #define SWIG_as_voidptr(a) (void *)((const void *)(a)) #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) SWIGINTERN swig_type_info* SWIG_pchar_descriptor(void) { static int init = 0; static swig_type_info* info = 0; if (!init) { info = SWIG_TypeQuery("_p_char"); init = 1; } return info; } SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char* carray, size_t size) { if (carray) { if (size > INT_MAX) { swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); return pchar_descriptor ? SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void(); } else { return PyString_FromStringAndSize(carray, (int)(size)); } } else { return SWIG_Py_Void(); } } SWIGINTERNINLINE PyObject * SWIG_FromCharPtr(const char *cptr) { return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); } #include #include "pypcap.h" #include "constants.c" #if defined(WITHOUT_PCAP_LIB_VERSION) && !defined(WITHOUT_VERSION_STRING) extern char pcap_version[]; #endif static char _doc_new_pcapObject[] = "create a pcapObject instance"; static char _doc_delete_pcapObject[] = "destroy a pcapObject instance"; SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) { if (PyString_Check(obj)) { char *cstr; Py_ssize_t len; PyString_AsStringAndSize(obj, &cstr, &len); if (cptr) { if (alloc) { /* In python the user should not be able to modify the inner string representation. To warranty that, if you define SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string buffer is always returned. The default behavior is just to return the pointer value, so, be careful. */ #if defined(SWIG_PYTHON_SAFE_CSTRINGS) if (*alloc != SWIG_OLDOBJ) #else if (*alloc == SWIG_NEWOBJ) #endif { *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1)); *alloc = SWIG_NEWOBJ; } else { *cptr = cstr; *alloc = SWIG_OLDOBJ; } } else { *cptr = PyString_AsString(obj); } } if (psize) *psize = len + 1; return SWIG_OK; } else { swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); if (pchar_descriptor) { void* vptr = 0; if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) { if (cptr) *cptr = (char *) vptr; if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0; if (alloc) *alloc = SWIG_OLDOBJ; return SWIG_OK; } } } return SWIG_TypeError; } #include #ifndef LLONG_MIN # define LLONG_MIN LONG_LONG_MIN #endif #ifndef LLONG_MAX # define LLONG_MAX LONG_LONG_MAX #endif #ifndef ULLONG_MAX # define ULLONG_MAX ULONG_LONG_MAX #endif SWIGINTERN int SWIG_AsVal_double (PyObject *obj, double *val) { int res = SWIG_TypeError; if (PyFloat_Check(obj)) { if (val) *val = PyFloat_AsDouble(obj); return SWIG_OK; } else if (PyInt_Check(obj)) { if (val) *val = PyInt_AsLong(obj); return SWIG_OK; } else if (PyLong_Check(obj)) { double v = PyLong_AsDouble(obj); if (!PyErr_Occurred()) { if (val) *val = v; return SWIG_OK; } else { PyErr_Clear(); } } #ifdef SWIG_PYTHON_CAST_MODE { int dispatch = 0; double d = PyFloat_AsDouble(obj); if (!PyErr_Occurred()) { if (val) *val = d; return SWIG_AddCast(SWIG_OK); } else { PyErr_Clear(); } if (!dispatch) { long v = PyLong_AsLong(obj); if (!PyErr_Occurred()) { if (val) *val = v; return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); } else { PyErr_Clear(); } } } #endif return res; } #include #include SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max) { double x = *d; if ((min <= x && x <= max)) { double fx = floor(x); double cx = ceil(x); double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ if ((errno == EDOM) || (errno == ERANGE)) { errno = 0; } else { double summ, reps, diff; if (rd < x) { diff = x - rd; } else if (rd > x) { diff = rd - x; } else { return 1; } summ = rd + x; reps = diff/summ; if (reps < 8*DBL_EPSILON) { *d = rd; return 1; } } } return 0; } SWIGINTERN int SWIG_AsVal_long (PyObject *obj, long* val) { if (PyInt_Check(obj)) { if (val) *val = PyInt_AsLong(obj); return SWIG_OK; } else if (PyLong_Check(obj)) { long v = PyLong_AsLong(obj); if (!PyErr_Occurred()) { if (val) *val = v; return SWIG_OK; } else { PyErr_Clear(); } } #ifdef SWIG_PYTHON_CAST_MODE { int dispatch = 0; long v = PyInt_AsLong(obj); if (!PyErr_Occurred()) { if (val) *val = v; return SWIG_AddCast(SWIG_OK); } else { PyErr_Clear(); } if (!dispatch) { double d; int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { if (val) *val = (long)(d); return res; } } } #endif return SWIG_TypeError; } SWIGINTERN int SWIG_AsVal_int (PyObject * obj, int *val) { long v; int res = SWIG_AsVal_long (obj, &v); if (SWIG_IsOK(res)) { if ((v < INT_MIN || v > INT_MAX)) { return SWIG_OverflowError; } else { if (val) *val = (int)(v); } } return res; } static char _doc_pcapObject_open_live[] = "open_live(device, snaplen, promisc, to_ms)\n\n" "Opens the interface specificed by 'device' for packet capture. 'snaplen'\n" "is the maximum number of bytes to capture per packet, 'promisc' indicates\n" "whether promiscuous mode should be used, and 'to_ms' specifies the read\n" "timeout in milliseconds."; static char _doc_pcapObject_open_dead[] = "open_dead(linktype, snaplen)\n\n" "open_dead is used to initialize the pcapObject so that methods that\n" "require the object to be initialized can be called, such as for compiling\n" "BPF code. 'snaplen' is the maximum number of bytes to capture per packet."; static char _doc_pcapObject_open_offline[] = "open_offline(filename)\n\n" "Opens a saved pcap/tcpdump-format file for reading. 'filename' is the name\n" "of the file to open. The filename '-' is synonymous with stdin"; static char _doc_pcapObject_dump_open[] = "dump_open(filename)\n\n" "Opens a saved pcap/tcpdump-format file for writing. 'filename' is the name\n" "of the file to open. The filename '-' is synonymous with stdout"; static char _doc_pcapObject_setnonblock[] = "setnonblock(nonblock)\n\n" "Puts the pcapObject in non-blocking mode ('nonblock'==1) or blocking mode\n" "('nonblock'==0). Non-blocking behavior is only applicable to the\n" "dispatch method, and not the loop and next methods. It has no effect on\n" "savefiles."; #define SWIG_From_long PyInt_FromLong SWIGINTERNINLINE PyObject * SWIG_From_int (int value) { return SWIG_From_long (value); } static char _doc_pcapObject_getnonblock[] = "getnonblock()\n\n" "Returns the non-blocking status of the pcapObject (returns 1 for\n" "non-blocking, returns 0 for blocking). 0 is always returned for savefiles\n" "Non-blocking behavior is only applicable to the dispatch method, and not\n" "the loop and next methods. It has no effect on savefiles."; static char _doc_pcapObject_setfilter[] = "setfilter(filter, optimize, netmask)\n\n" "Applies a filtering rule to the pcapObject. 'filter' is a BPF-style \n" "filter expression, 'optimize' controls whether the compiled BPF code is \n" "optimized, and 'netmask' in a network byte-order integer specifying the \n" "netmask of the local network."; static char _doc_pcapObject_loop[] = "loop(count, callback)\n\n" "Read packets until 'count' packets have been received or an exception\n" "occurs. The 'callback' argument is a python function of the form\n" "callback(pktlen, data, timestamp). 'pktlen' is the integer length of the\n" "observed packet on the wire, data is a string containing the captured\n" "bytes (may be less than the pktlen bytes), and the timestamp."; static char _doc_pcapObject_dispatch[] = "dispatch(count, callback)\n\n" "Read packets until at most 'count' packets have been read, or a timeout" "occurs, or an exception is raised. Timeout behavior is not supported on\n" "all platforms, and on some platforms, the timer doesn't start until at least\n" "one packet arrives. \n" "The 'callback' argument is a python function of the form\n" "callback(pktlen, data, timestamp). 'pktlen' is the integer length of the\n" "observed packet on the wire, data is a string containing the captured\n" "bytes (may be less than the pktlen bytes), and the timestamp."; static char _doc_pcapObject_next[] = "next()\n\n" "Reads the next packet from the interface, returning a tuple containing\n" "the integer length of the observed packet on the wire, a string containing\n" "the captured bytes (may be less than the pktlen bytes), and the timestamp."; static char _doc_pcapObject_datalink[] = "datalink()\n\n" "Returns an integer value representing the link layer type (e.g. DLT_EN10MB)"; static char _doc_pcapObject_datalinks[] = "datalinks()\n\n" "Returns a tuple of integer values representing the link layer types\n" "available on this interface (e.g. DLT_EN10MB)"; static char _doc_pcapObject_snapshot[] = "snapshot()\n\n" "Returns the snapshot length specified when open_live was called"; static char _doc_pcapObject_is_swapped[] = "is_swapped()\n\n" "Returns true if the current savefile uses a different byte order than the\n" "current system"; static char _doc_pcapObject_major_version[] = "major_version()\n\n" "returns the major number of the version of the pcap used to write the savefile.\n"; static char _doc_pcapObject_minor_version[] = "minor_version()\n\n" "returns the minor number of the version of the pcap used to write the savefile.\n"; static char _doc_pcapObject_stats[] = "stats()\n\n" "Returns a tuple containing number of packets received, number of packets\n" "dropped, and number of packets dropped by the interface. This method is\n" "not applicable for savefiles"; static char _doc_pcapObject_fileno[] = "fileno()\n\n" "Returns the file descriptor number from which captured packets are read,\n" "if a network device was opened with open_live(), or -1, if a savefile was\n" "opened with pcap_open_offline()."; static char _doc_lookupdev[] = "lookupdev()\n\n" "Returns a string containing the name of an interface suitable for use\n" "with pcapObject.open_live and lookupnet.\n"; static char _doc_findalldevs[] = "findalldevs()\n\n" "Returns a list of tuples for each device that can be opened with\n" "open_live(). Each tuple contains the following members:\n" " name\n" " description\n" " addressess: a tuple of tuples for each address, containing the address,\n" " netmask, broadcast address, and point-to-point address.\n" " flags: PCAP_IF_LOOPBACK if a loopback interface\n"; static char _doc_lookupnet[] = "lookupnet(interface)\n\n" "Returns a tuple containing the network number and mask associated with\n" "the network device 'interface' in network byte order.\n"; static char _doc_aton[] = "aton(addr)\n\nconvert dotted decimal IP string to network byte order int"; static char _doc_ntoa[] = "ntoa(addr)\n\nconvert network byte order int to dotted decimal IP string"; #ifdef __cplusplus extern "C" { #endif SWIGINTERN PyObject *_wrap_new_pcapObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_pcapObject")) SWIG_fail; { result = (pcapObject *)new_pcapObject(); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pcapObject, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_open_live(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; char *arg2 = (char *) 0 ; int arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ; int ecode5 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOOOO:pcapObject_open_live",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_open_live" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pcapObject_open_live" "', argument " "2"" of type '" "char *""'"); } arg2 = (char *)(buf2); ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pcapObject_open_live" "', argument " "3"" of type '" "int""'"); } arg3 = (int)(val3); ecode4 = SWIG_AsVal_int(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pcapObject_open_live" "', argument " "4"" of type '" "int""'"); } arg4 = (int)(val4); ecode5 = SWIG_AsVal_int(obj4, &val5); if (!SWIG_IsOK(ecode5)) { SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pcapObject_open_live" "', argument " "5"" of type '" "int""'"); } arg5 = (int)(val5); { pcapObject_open_live(arg1,arg2,arg3,arg4,arg5); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_Py_Void(); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); return resultobj; fail: if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_open_dead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:pcapObject_open_dead",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_open_dead" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pcapObject_open_dead" "', argument " "2"" of type '" "int""'"); } arg2 = (int)(val2); ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pcapObject_open_dead" "', argument " "3"" of type '" "int""'"); } arg3 = (int)(val3); { pcapObject_open_dead(arg1,arg2,arg3); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_open_offline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:pcapObject_open_offline",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_open_offline" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pcapObject_open_offline" "', argument " "2"" of type '" "char *""'"); } arg2 = (char *)(buf2); { pcapObject_open_offline(arg1,arg2); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_Py_Void(); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); return resultobj; fail: if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_dump_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:pcapObject_dump_open",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_dump_open" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pcapObject_dump_open" "', argument " "2"" of type '" "char *""'"); } arg2 = (char *)(buf2); { pcapObject_dump_open(arg1,arg2); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_Py_Void(); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); return resultobj; fail: if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_setnonblock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:pcapObject_setnonblock",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_setnonblock" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pcapObject_setnonblock" "', argument " "2"" of type '" "int""'"); } arg2 = (int)(val2); { pcapObject_setnonblock(arg1,arg2); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_getnonblock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; int result; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:pcapObject_getnonblock",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_getnonblock" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); { result = (int)pcapObject_getnonblock(arg1); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_From_int((int)(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_setfilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; char *arg2 = (char *) 0 ; int arg3 ; in_addr_t arg4 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOOO:pcapObject_setfilter",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_setfilter" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pcapObject_setfilter" "', argument " "2"" of type '" "char *""'"); } arg2 = (char *)(buf2); ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pcapObject_setfilter" "', argument " "3"" of type '" "int""'"); } arg3 = (int)(val3); { if (PyInt_CheckExact(obj3)) { arg4 = (unsigned long)PyInt_AS_LONG(obj3); } else if (!PyNumber_Check(obj3)) { PyErr_SetString(PyExc_TypeError, "argument must be an integer"); SWIG_fail; } else { PyObject *longobject = PyNumber_Long(obj3); if (longobject == NULL) { SWIG_fail; } arg4 = PyLong_AsUnsignedLong(longobject); Py_DECREF(longobject); if (PyErr_Occurred()) { SWIG_fail; } /* In case AsUnsignedLong() failed */ } } { pcapObject_setfilter(arg1,arg2,arg3,arg4); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_Py_Void(); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); return resultobj; fail: if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_loop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; int arg2 ; PyObject *arg3 = (PyObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:pcapObject_loop",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_loop" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pcapObject_loop" "', argument " "2"" of type '" "int""'"); } arg2 = (int)(val2); { arg3 = obj2; } { pcapObject_loop(arg1,arg2,arg3); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; int arg2 ; PyObject *arg3 = (PyObject *) 0 ; int result; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:pcapObject_dispatch",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_dispatch" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pcapObject_dispatch" "', argument " "2"" of type '" "int""'"); } arg2 = (int)(val2); { arg3 = obj2; } { result = (int)pcapObject_dispatch(arg1,arg2,arg3); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_From_int((int)(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; PyObject *result = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:pcapObject_next",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_next" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); { result = (PyObject *)pcapObject_next(arg1); if(PyErr_Occurred()) { SWIG_fail; } } { resultobj = result; } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_datalink(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; int result; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:pcapObject_datalink",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_datalink" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); { result = (int)pcapObject_datalink(arg1); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_From_int((int)(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_datalinks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; PyObject *result = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:pcapObject_datalinks",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_datalinks" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); { result = (PyObject *)pcapObject_datalinks(arg1); if(PyErr_Occurred()) { SWIG_fail; } } { resultobj = result; } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_snapshot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; int result; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:pcapObject_snapshot",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_snapshot" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); { result = (int)pcapObject_snapshot(arg1); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_From_int((int)(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_is_swapped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; int result; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:pcapObject_is_swapped",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_is_swapped" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); { result = (int)pcapObject_is_swapped(arg1); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_From_int((int)(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_major_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; int result; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:pcapObject_major_version",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_major_version" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); { result = (int)pcapObject_major_version(arg1); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_From_int((int)(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_minor_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; int result; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:pcapObject_minor_version",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_minor_version" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); { result = (int)pcapObject_minor_version(arg1); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_From_int((int)(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_stats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; PyObject *result = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:pcapObject_stats",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_stats" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); { result = (PyObject *)pcapObject_stats(arg1); if(PyErr_Occurred()) { SWIG_fail; } } { resultobj = result; } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_pcapObject_fileno(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; int result; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:pcapObject_fileno",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pcapObject_fileno" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); { result = (int)pcapObject_fileno(arg1); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_From_int((int)(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_pcapObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; pcapObject *arg1 = (pcapObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_pcapObject",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pcapObject, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pcapObject" "', argument " "1"" of type '" "pcapObject *""'"); } arg1 = (pcapObject *)(argp1); { free((char *) arg1); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_pcapObject(PyObject *self, PyObject *args) { int argc; PyObject *argv[2]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = PyObject_Length(args); for (ii = 0; (ii < argc) && (ii < 1); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_pcapObject, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_delete_pcapObject__SWIG_1(self, args); } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'delete_pcapObject'.\n Possible C/C++ prototypes are:\n ~pcapObject()\n pcapObject::~pcapObject()\n"); return NULL; } SWIGINTERN PyObject *pcapObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_pcapObject, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_lookupdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; char *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":lookupdev")) SWIG_fail; { result = (char *)lookupdev(); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_FromCharPtr((const char *)result); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_findalldevs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; int arg1 = (int) 1 ; PyObject *result = 0 ; int val1 ; int ecode1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"|O:findalldevs",&obj0)) SWIG_fail; if (obj0) { ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "findalldevs" "', argument " "1"" of type '" "int""'"); } arg1 = (int)(val1); } { result = (PyObject *)findalldevs(arg1); if(PyErr_Occurred()) { SWIG_fail; } } { resultobj = result; } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_lookupnet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; PyObject *result = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:lookupnet",&obj0)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lookupnet" "', argument " "1"" of type '" "char *""'"); } arg1 = (char *)(buf1); { result = (PyObject *)lookupnet(arg1); if(PyErr_Occurred()) { SWIG_fail; } } { resultobj = result; } if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); return resultobj; fail: if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); return NULL; } SWIGINTERN PyObject *_wrap_aton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; PyObject *result = 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:aton",&obj0)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aton" "', argument " "1"" of type '" "char *""'"); } arg1 = (char *)(buf1); { result = (PyObject *)aton(arg1); if(PyErr_Occurred()) { SWIG_fail; } } { resultobj = result; } if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); return resultobj; fail: if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); return NULL; } SWIGINTERN PyObject *_wrap_ntoa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; in_addr_t arg1 ; char *result = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ntoa",&obj0)) SWIG_fail; { if (PyInt_CheckExact(obj0)) { arg1 = (unsigned long)PyInt_AS_LONG(obj0); } else if (!PyNumber_Check(obj0)) { PyErr_SetString(PyExc_TypeError, "argument must be an integer"); SWIG_fail; } else { PyObject *longobject = PyNumber_Long(obj0); if (longobject == NULL) { SWIG_fail; } arg1 = PyLong_AsUnsignedLong(longobject); Py_DECREF(longobject); if (PyErr_Occurred()) { SWIG_fail; } /* In case AsUnsignedLong() failed */ } } { result = (char *)ntoa(arg1); if(PyErr_Occurred()) { SWIG_fail; } } resultobj = SWIG_FromCharPtr((const char *)result); return resultobj; fail: return NULL; } static PyMethodDef SwigMethods[] = { { (char *)"new_pcapObject", _wrap_new_pcapObject, METH_VARARGS, _doc_new_pcapObject }, { (char *)"pcapObject_open_live", _wrap_pcapObject_open_live, METH_VARARGS, _doc_pcapObject_open_live }, { (char *)"pcapObject_open_dead", _wrap_pcapObject_open_dead, METH_VARARGS, _doc_pcapObject_open_dead }, { (char *)"pcapObject_open_offline", _wrap_pcapObject_open_offline, METH_VARARGS, _doc_pcapObject_open_offline }, { (char *)"pcapObject_dump_open", _wrap_pcapObject_dump_open, METH_VARARGS, _doc_pcapObject_dump_open }, { (char *)"pcapObject_setnonblock", _wrap_pcapObject_setnonblock, METH_VARARGS, _doc_pcapObject_setnonblock }, { (char *)"pcapObject_getnonblock", _wrap_pcapObject_getnonblock, METH_VARARGS, _doc_pcapObject_getnonblock }, { (char *)"pcapObject_setfilter", _wrap_pcapObject_setfilter, METH_VARARGS, _doc_pcapObject_setfilter }, { (char *)"pcapObject_loop", _wrap_pcapObject_loop, METH_VARARGS, _doc_pcapObject_loop }, { (char *)"pcapObject_dispatch", _wrap_pcapObject_dispatch, METH_VARARGS, _doc_pcapObject_dispatch }, { (char *)"pcapObject_next", _wrap_pcapObject_next, METH_VARARGS, _doc_pcapObject_next }, { (char *)"pcapObject_datalink", _wrap_pcapObject_datalink, METH_VARARGS, _doc_pcapObject_datalink }, { (char *)"pcapObject_datalinks", _wrap_pcapObject_datalinks, METH_VARARGS, _doc_pcapObject_datalinks }, { (char *)"pcapObject_snapshot", _wrap_pcapObject_snapshot, METH_VARARGS, _doc_pcapObject_snapshot }, { (char *)"pcapObject_is_swapped", _wrap_pcapObject_is_swapped, METH_VARARGS, _doc_pcapObject_is_swapped }, { (char *)"pcapObject_major_version", _wrap_pcapObject_major_version, METH_VARARGS, _doc_pcapObject_major_version }, { (char *)"pcapObject_minor_version", _wrap_pcapObject_minor_version, METH_VARARGS, _doc_pcapObject_minor_version }, { (char *)"pcapObject_stats", _wrap_pcapObject_stats, METH_VARARGS, _doc_pcapObject_stats }, { (char *)"pcapObject_fileno", _wrap_pcapObject_fileno, METH_VARARGS, _doc_pcapObject_fileno }, { (char *)"delete_pcapObject", _wrap_delete_pcapObject, METH_VARARGS, _doc_delete_pcapObject }, { (char *)"pcapObject_swigregister", pcapObject_swigregister, METH_VARARGS, NULL}, { (char *)"lookupdev", _wrap_lookupdev, METH_VARARGS, _doc_lookupdev }, { (char *)"findalldevs", _wrap_findalldevs, METH_VARARGS, _doc_findalldevs }, { (char *)"lookupnet", _wrap_lookupnet, METH_VARARGS, _doc_lookupnet }, { (char *)"aton", _wrap_aton, METH_VARARGS, _doc_aton }, { (char *)"ntoa", _wrap_ntoa, METH_VARARGS, _doc_ntoa }, { NULL, NULL, 0, NULL } }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_in_addr_t = {"_p_in_addr_t", "in_addr_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_pcapObject = {"_p_pcapObject", "pcapObject *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_char, &_swigt__p_in_addr_t, &_swigt__p_pcapObject, }; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_in_addr_t[] = { {&_swigt__p_in_addr_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_pcapObject[] = { {&_swigt__p_pcapObject, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { _swigc__p_char, _swigc__p_in_addr_t, _swigc__p_pcapObject, }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ static swig_const_info swig_const_table[] = { {0, 0, 0, 0.0, 0, 0}}; #ifdef __cplusplus } #endif /* ----------------------------------------------------------------------------- * Type initialization: * This problem is tough by the requirement that no dynamic * memory is used. Also, since swig_type_info structures store pointers to * swig_cast_info structures and swig_cast_info structures store pointers back * to swig_type_info structures, we need some lookup code at initialization. * The idea is that swig generates all the structures that are needed. * The runtime then collects these partially filled structures. * The SWIG_InitializeModule function takes these initial arrays out of * swig_module, and does all the lookup, filling in the swig_module.types * array with the correct data and linking the correct swig_cast_info * structures together. * * The generated swig_type_info structures are assigned staticly to an initial * array. We just loop through that array, and handle each type individually. * First we lookup if this type has been already loaded, and if so, use the * loaded structure instead of the generated one. Then we have to fill in the * cast linked list. The cast data is initially stored in something like a * two-dimensional array. Each row corresponds to a type (there are the same * number of rows as there are in the swig_type_initial array). Each entry in * a column is one of the swig_cast_info structures for that type. * The cast_initial array is actually an array of arrays, because each row has * a variable number of columns. So to actually build the cast linked list, * we find the array of casts associated with the type, and loop through it * adding the casts to the list. The one last trick we need to do is making * sure the type pointer in the swig_cast_info struct is correct. * * First off, we lookup the cast->type name to see if it is already loaded. * There are three cases to handle: * 1) If the cast->type has already been loaded AND the type we are adding * casting info to has not been loaded (it is in this module), THEN we * replace the cast->type pointer with the type pointer that has already * been loaded. * 2) If BOTH types (the one we are adding casting info to, and the * cast->type) are loaded, THEN the cast info has already been loaded by * the previous module so we just ignore it. * 3) Finally, if cast->type has not already been loaded, then we add that * swig_cast_info to the linked list (because the cast->type) pointer will * be correct. * ----------------------------------------------------------------------------- */ #ifdef __cplusplus extern "C" { #if 0 } /* c-mode */ #endif #endif #if 0 #define SWIGRUNTIME_DEBUG #endif SWIGRUNTIME void SWIG_InitializeModule(void *clientdata) { size_t i; swig_module_info *module_head, *iter; int found; clientdata = clientdata; /* check to see if the circular list has been setup, if not, set it up */ if (swig_module.next==0) { /* Initialize the swig_module */ swig_module.type_initial = swig_type_initial; swig_module.cast_initial = swig_cast_initial; swig_module.next = &swig_module; } /* Try and load any already created modules */ module_head = SWIG_GetModule(clientdata); if (!module_head) { /* This is the first module loaded for this interpreter */ /* so set the swig module into the interpreter */ SWIG_SetModule(clientdata, &swig_module); module_head = &swig_module; } else { /* the interpreter has loaded a SWIG module, but has it loaded this one? */ found=0; iter=module_head; do { if (iter==&swig_module) { found=1; break; } iter=iter->next; } while (iter!= module_head); /* if the is found in the list, then all is done and we may leave */ if (found) return; /* otherwise we must add out module into the list */ swig_module.next = module_head->next; module_head->next = &swig_module; } /* Now work on filling in swig_module.types */ #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: size %d\n", swig_module.size); #endif for (i = 0; i < swig_module.size; ++i) { swig_type_info *type = 0; swig_type_info *ret; swig_cast_info *cast; #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); #endif /* if there is another module already loaded */ if (swig_module.next != &swig_module) { type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); } if (type) { /* Overwrite clientdata field */ #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: found type %s\n", type->name); #endif if (swig_module.type_initial[i]->clientdata) { type->clientdata = swig_module.type_initial[i]->clientdata; #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); #endif } } else { type = swig_module.type_initial[i]; } /* Insert casting types */ cast = swig_module.cast_initial[i]; while (cast->type) { /* Don't need to add information already in the list */ ret = 0; #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); #endif if (swig_module.next != &swig_module) { ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); #ifdef SWIGRUNTIME_DEBUG if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); #endif } if (ret) { if (type == swig_module.type_initial[i]) { #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: skip old type %s\n", ret->name); #endif cast->type = ret; ret = 0; } else { /* Check for casting already in the list */ swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); #ifdef SWIGRUNTIME_DEBUG if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); #endif if (!ocast) ret = 0; } } if (!ret) { #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); #endif if (type->cast) { type->cast->prev = cast; cast->next = type->cast; } type->cast = cast; } cast++; } /* Set entry in modules->types array equal to the type */ swig_module.types[i] = type; } swig_module.types[i] = 0; #ifdef SWIGRUNTIME_DEBUG printf("**** SWIG_InitializeModule: Cast List ******\n"); for (i = 0; i < swig_module.size; ++i) { int j = 0; swig_cast_info *cast = swig_module.cast_initial[i]; printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); while (cast->type) { printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); cast++; ++j; } printf("---- Total casts: %d\n",j); } printf("**** SWIG_InitializeModule: Cast List ******\n"); #endif } /* This function will propagate the clientdata field of type to * any new swig_type_info structures that have been added into the list * of equivalent types. It is like calling * SWIG_TypeClientData(type, clientdata) a second time. */ SWIGRUNTIME void SWIG_PropagateClientData(void) { size_t i; swig_cast_info *equiv; static int init_run = 0; if (init_run) return; init_run = 1; for (i = 0; i < swig_module.size; i++) { if (swig_module.types[i]->clientdata) { equiv = swig_module.types[i]->cast; while (equiv) { if (!equiv->converter) { if (equiv->type && !equiv->type->clientdata) SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); } equiv = equiv->next; } } } } #ifdef __cplusplus #if 0 { /* c-mode */ #endif } #endif #ifdef __cplusplus extern "C" { #endif /* Python-specific SWIG API */ #define SWIG_newvarlink() SWIG_Python_newvarlink() #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) /* ----------------------------------------------------------------------------- * global variable support code. * ----------------------------------------------------------------------------- */ typedef struct swig_globalvar { char *name; /* Name of global variable */ PyObject *(*get_attr)(void); /* Return the current value */ int (*set_attr)(PyObject *); /* Set the value */ struct swig_globalvar *next; } swig_globalvar; typedef struct swig_varlinkobject { PyObject_HEAD swig_globalvar *vars; } swig_varlinkobject; SWIGINTERN PyObject * swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { return PyString_FromString(""); } SWIGINTERN PyObject * swig_varlink_str(swig_varlinkobject *v) { PyObject *str = PyString_FromString("("); swig_globalvar *var; for (var = v->vars; var; var=var->next) { PyString_ConcatAndDel(&str,PyString_FromString(var->name)); if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); } PyString_ConcatAndDel(&str,PyString_FromString(")")); return str; } SWIGINTERN int swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { PyObject *str = swig_varlink_str(v); fprintf(fp,"Swig global variables "); fprintf(fp,"%s\n", PyString_AsString(str)); Py_DECREF(str); return 0; } SWIGINTERN void swig_varlink_dealloc(swig_varlinkobject *v) { swig_globalvar *var = v->vars; while (var) { swig_globalvar *n = var->next; free(var->name); free(var); var = n; } } SWIGINTERN PyObject * swig_varlink_getattr(swig_varlinkobject *v, char *n) { PyObject *res = NULL; swig_globalvar *var = v->vars; while (var) { if (strcmp(var->name,n) == 0) { res = (*var->get_attr)(); break; } var = var->next; } if (res == NULL && !PyErr_Occurred()) { PyErr_SetString(PyExc_NameError,"Unknown C global variable"); } return res; } SWIGINTERN int swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { int res = 1; swig_globalvar *var = v->vars; while (var) { if (strcmp(var->name,n) == 0) { res = (*var->set_attr)(p); break; } var = var->next; } if (res == 1 && !PyErr_Occurred()) { PyErr_SetString(PyExc_NameError,"Unknown C global variable"); } return res; } SWIGINTERN PyTypeObject* swig_varlink_type(void) { static char varlink__doc__[] = "Swig var link object"; static PyTypeObject varlink_type; static int type_init = 0; if (!type_init) { const PyTypeObject tmp = { PyObject_HEAD_INIT(NULL) 0, /* Number of items in variable part (ob_size) */ (char *)"swigvarlink", /* Type name (tp_name) */ sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */ 0, /* Itemsize (tp_itemsize) */ (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */ (printfunc) swig_varlink_print, /* Print (tp_print) */ (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */ (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */ 0, /* tp_compare */ (reprfunc) swig_varlink_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ (reprfunc)swig_varlink_str, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ 0, /* tp_flags */ varlink__doc__, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ #if PY_VERSION_HEX >= 0x02020000 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ #endif #if PY_VERSION_HEX >= 0x02030000 0, /* tp_del */ #endif #ifdef COUNT_ALLOCS 0,0,0,0 /* tp_alloc -> tp_next */ #endif }; varlink_type = tmp; varlink_type.ob_type = &PyType_Type; type_init = 1; } return &varlink_type; } /* Create a variable linking object for use later */ SWIGINTERN PyObject * SWIG_Python_newvarlink(void) { swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); if (result) { result->vars = 0; } return ((PyObject*) result); } SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { swig_varlinkobject *v = (swig_varlinkobject *) p; swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); if (gv) { size_t size = strlen(name)+1; gv->name = (char *)malloc(size); if (gv->name) { strncpy(gv->name,name,size); gv->get_attr = get_attr; gv->set_attr = set_attr; gv->next = v->vars; } } v->vars = gv; } SWIGINTERN PyObject * SWIG_globals(void) { static PyObject *_SWIG_globals = 0; if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink(); return _SWIG_globals; } /* ----------------------------------------------------------------------------- * constants/methods manipulation * ----------------------------------------------------------------------------- */ /* Install Constants */ SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { PyObject *obj = 0; size_t i; for (i = 0; constants[i].type; ++i) { switch(constants[i].type) { case SWIG_PY_POINTER: obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); break; case SWIG_PY_BINARY: obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); break; default: obj = 0; break; } if (obj) { PyDict_SetItemString(d, constants[i].name, obj); Py_DECREF(obj); } } } /* -----------------------------------------------------------------------------*/ /* Fix SwigMethods to carry the callback ptrs when needed */ /* -----------------------------------------------------------------------------*/ SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) { size_t i; for (i = 0; methods[i].ml_name; ++i) { const char *c = methods[i].ml_doc; if (c && (c = strstr(c, "swig_ptr: "))) { int j; swig_const_info *ci = 0; const char *name = c + 10; for (j = 0; const_table[j].type; ++j) { if (strncmp(const_table[j].name, name, strlen(const_table[j].name)) == 0) { ci = &(const_table[j]); break; } } if (ci) { size_t shift = (ci->ptype) - types; swig_type_info *ty = types_initial[shift]; size_t ldoc = (c - methods[i].ml_doc); size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; char *ndoc = (char*)malloc(ldoc + lptr + 10); if (ndoc) { char *buff = ndoc; void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; if (ptr) { strncpy(buff, methods[i].ml_doc, ldoc); buff += ldoc; strncpy(buff, "swig_ptr: ", 10); buff += 10; SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); methods[i].ml_doc = ndoc; } } } } } } #ifdef __cplusplus } #endif /* -----------------------------------------------------------------------------* * Partial Init method * -----------------------------------------------------------------------------*/ #ifdef __cplusplus extern "C" #endif SWIGEXPORT void SWIG_init(void) { PyObject *m, *d; /* Fix SwigMethods to carry the callback ptrs when needed */ SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); m = Py_InitModule((char *) SWIG_name, SwigMethods); d = PyModule_GetDict(m); SWIG_InitializeModule(0); SWIG_InstallConstants(d,swig_const_table); SWIG_Python_SetConstant(d, "pcap_doc",SWIG_FromCharPtr("pcap module\n-----------\npcapObject(): Returns a pcapObject instance, with the following methods.\nPlease see the __doc__ attributes of the instance methods of a pcapObject\nfor more information. (there are no method __doc__ attributes in the\nclass). Also please note that at this time, method __doc__ attributes are\nonly functional for python2.\n open_live(device, snaplen, promisc, to_ms)\n open_dead(linktype, snaplen)\n open_offline(filename)\n dump_open(filename)\n setnonblock(nonblock)\n getnonblock()\n setfilter(filter, optimize, netmask)\n loop(count, callback)\n dispatch(count, callback)\n next()\n datalink()\n snapshot()\n is_swapped()\n major_version()\n stats()\n fileno()\n\nPlease see the __doc__ attributes of the following pcap module functions\nfor further information:\n lookupdev()\n lookupnet(device)\n findalldevs()\n aton(addr)\n ntoa(addr)\n")); SWIG_Python_SetConstant(d, "pcapObject_open_live_doc",SWIG_FromCharPtr("open_live(device, snaplen, promisc, to_ms)\n\nOpens the interface specificed by \'device\' for packet capture. \'snaplen\'\nis the maximum number of bytes to capture per packet, \'promisc\' indicates\nwhether promiscuous mode should be used, and \'to_ms\' specifies the read\ntimeout in milliseconds.")); SWIG_Python_SetConstant(d, "pcapObject_open_dead_doc",SWIG_FromCharPtr("open_dead(linktype, snaplen)\n\nopen_dead is used to initialize the pcapObject so that methods that\nrequire the object to be initialized can be called, such as for compiling\nBPF code. \'snaplen\' is the maximum number of bytes to capture per packet.")); SWIG_Python_SetConstant(d, "pcapObject_open_offline_doc",SWIG_FromCharPtr("open_offline(filename)\n\nOpens a saved pcap/tcpdump-format file for reading. \'filename\' is the name\nof the file to open. The filename \'-\' is synonymous with stdin")); SWIG_Python_SetConstant(d, "pcapObject_dump_open_doc",SWIG_FromCharPtr("dump_open(filename)\n\nOpens a saved pcap/tcpdump-format file for writing. \'filename\' is the name\nof the file to open. The filename \'-\' is synonymous with stdout")); SWIG_Python_SetConstant(d, "pcapObject_setnonblock_doc",SWIG_FromCharPtr("setnonblock(nonblock)\n\nPuts the pcapObject in non-blocking mode (\'nonblock\'==1) or blocking mode\n(\'nonblock\'==0). Non-blocking behavior is only applicable to the\ndispatch method, and not the loop and next methods. It has no effect on\nsavefiles.")); SWIG_Python_SetConstant(d, "pcapObject_getnonblock_doc",SWIG_FromCharPtr("getnonblock()\n\nReturns the non-blocking status of the pcapObject (returns 1 for\nnon-blocking, returns 0 for blocking). 0 is always returned for savefiles\nNon-blocking behavior is only applicable to the dispatch method, and not\nthe loop and next methods. It has no effect on savefiles.")); SWIG_Python_SetConstant(d, "pcapObject_setfilter_doc",SWIG_FromCharPtr("setfilter(filter, optimize, netmask)\n\nApplies a filtering rule to the pcapObject. \'filter\' is a BPF-style \nfilter expression, \'optimize\' controls whether the compiled BPF code is \noptimized, and \'netmask\' in a network byte-order integer specifying the \nnetmask of the local network.")); SWIG_Python_SetConstant(d, "pcapObject_loop_doc",SWIG_FromCharPtr("loop(count, callback)\n\nRead packets until \'count\' packets have been received or an exception\noccurs. The \'callback\' argument is a python function of the form\ncallback(pktlen, data, timestamp). \'pktlen\' is the integer length of the\nobserved packet on the wire, data is a string containing the captured\nbytes (may be less than the pktlen bytes), and the timestamp.")); SWIG_Python_SetConstant(d, "pcapObject_dispatch_doc",SWIG_FromCharPtr("dispatch(count, callback)\n\nRead packets until at most \'count\' packets have been read, or a timeoutoccurs, or an exception is raised. Timeout behavior is not supported on\nall platforms, and on some platforms, the timer doesn\'t start until at least\none packet arrives. \nThe \'callback\' argument is a python function of the form\ncallback(pktlen, data, timestamp). \'pktlen\' is the integer length of the\nobserved packet on the wire, data is a string containing the captured\nbytes (may be less than the pktlen bytes), and the timestamp.")); SWIG_Python_SetConstant(d, "pcapObject_next_doc",SWIG_FromCharPtr("next()\n\nReads the next packet from the interface, returning a tuple containing\nthe integer length of the observed packet on the wire, a string containing\nthe captured bytes (may be less than the pktlen bytes), and the timestamp.")); SWIG_Python_SetConstant(d, "pcapObject_datalink_doc",SWIG_FromCharPtr("datalink()\n\nReturns an integer value representing the link layer type (e.g. DLT_EN10MB)")); SWIG_Python_SetConstant(d, "pcapObject_datalinks_doc",SWIG_FromCharPtr("datalinks()\n\nReturns a tuple of integer values representing the link layer types\navailable on this interface (e.g. DLT_EN10MB)")); SWIG_Python_SetConstant(d, "pcapObject_snapshot_doc",SWIG_FromCharPtr("snapshot()\n\nReturns the snapshot length specified when open_live was called")); SWIG_Python_SetConstant(d, "pcapObject_is_swapped_doc",SWIG_FromCharPtr("is_swapped()\n\nReturns true if the current savefile uses a different byte order than the\ncurrent system")); SWIG_Python_SetConstant(d, "pcapObject_major_version_doc",SWIG_FromCharPtr("major_version()\n\nreturns the major number of the version of the pcap used to write the savefile.\n")); SWIG_Python_SetConstant(d, "pcapObject_minor_version_doc",SWIG_FromCharPtr("minor_version()\n\nreturns the minor number of the version of the pcap used to write the savefile.\n")); SWIG_Python_SetConstant(d, "pcapObject_stats_doc",SWIG_FromCharPtr("stats()\n\nReturns a tuple containing number of packets received, number of packets\ndropped, and number of packets dropped by the interface. This method is\nnot applicable for savefiles")); SWIG_Python_SetConstant(d, "pcapObject_fileno_doc",SWIG_FromCharPtr("fileno()\n\nReturns the file descriptor number from which captured packets are read,\nif a network device was opened with open_live(), or -1, if a savefile was\nopened with pcap_open_offline().")); SWIG_Python_SetConstant(d, "lookupdev_doc",SWIG_FromCharPtr("lookupdev()\n\nReturns a string containing the name of an interface suitable for use\nwith pcapObject.open_live and lookupnet.\n")); SWIG_Python_SetConstant(d, "lookupnet_doc",SWIG_FromCharPtr("lookupnet(interface)\n\nReturns a tuple containing the network number and mask associated with\nthe network device \'interface\' in network byte order.\n")); SWIG_Python_SetConstant(d, "findalldevs_doc",SWIG_FromCharPtr("findalldevs()\n\nReturns a list of tuples for each device that can be opened with\nopen_live(). Each tuple contains the following members:\n name\n description\n addressess: a tuple of tuples for each address, containing the address,\n netmask, broadcast address, and point-to-point address.\n flags: PCAP_IF_LOOPBACK if a loopback interface\n")); SWIG_Python_SetConstant(d, "__doc__",SWIG_FromCharPtr("pcap module\n-----------\npcapObject(): Returns a pcapObject instance, with the following methods.\nPlease see the __doc__ attributes of the instance methods of a pcapObject\nfor more information. (there are no method __doc__ attributes in the\nclass). Also please note that at this time, method __doc__ attributes are\nonly functional for python2.\n open_live(device, snaplen, promisc, to_ms)\n open_dead(linktype, snaplen)\n open_offline(filename)\n dump_open(filename)\n setnonblock(nonblock)\n getnonblock()\n setfilter(filter, optimize, netmask)\n loop(count, callback)\n dispatch(count, callback)\n next()\n datalink()\n snapshot()\n is_swapped()\n major_version()\n stats()\n fileno()\n\nPlease see the __doc__ attributes of the following pcap module functions\nfor further information:\n lookupdev()\n lookupnet(device)\n findalldevs()\n aton(addr)\n ntoa(addr)\n")); /* m is the current module */ /* d is the dictionary for the current module */ init_errors(m); /* the DLT dictionary holds any DLT_* constants available on this platform */ { PyObject *dlt = PyDict_New(); int constantIndex; for(constantIndex = 0; pcapmodule_DLT[constantIndex].name; constantIndex ++) { PyObject *v = PyInt_FromLong(pcapmodule_DLT[constantIndex].value); PyDict_SetItemString(dlt, pcapmodule_DLT[constantIndex].name, v); Py_DECREF(v); } PyModule_AddObject(m, "DLT", dlt); /* consumes a reference to dlt */ } #if defined(WITHOUT_PCAP_LIB_VERSION) #if !defined(WITHOUT_VERSION_STRING) PyModule_AddStringConstant(m, "version", pcap_version); #endif #else PyModule_AddStringConstant(m, "version", pcap_lib_version()); #endif } pylibpcap-0.6.4/pcap.i000644 000766 000024 00000011671 11701432613 014721 0ustar00wimlstaff000000 000000 /* * $Id: pcap.i,v 1.19 2012/01/05 23:43:07 wiml Exp $ * Python libpcap * Copyright (C) 2001,2002, David Margrave * Copyright (C) 2004,2007 William Lewis * Based PY-libpcap (C) 1998, Aaron L. Rhodes * * This program is free software; you can redistribute it and/or * modify it under the terms of the BSD Licence. See the file COPYING * for details. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ %module pcap #define DOC(NAME, VALUE)\ %{\ static char _doc_##NAME[] = VALUE;\ %} %include doc.i #define __doc__ pcap_doc %{ #include #include "pypcap.h" #include "constants.c" #if defined(WITHOUT_PCAP_LIB_VERSION) && !defined(WITHOUT_VERSION_STRING) extern char pcap_version[]; #endif %} %init %{ /* m is the current module */ /* d is the dictionary for the current module */ init_errors(m); /* the DLT dictionary holds any DLT_* constants available on this platform */ { PyObject *dlt = PyDict_New(); int constantIndex; for(constantIndex = 0; pcapmodule_DLT[constantIndex].name; constantIndex ++) { PyObject *v = PyInt_FromLong(pcapmodule_DLT[constantIndex].value); PyDict_SetItemString(dlt, pcapmodule_DLT[constantIndex].name, v); Py_DECREF(v); } PyModule_AddObject(m, "DLT", dlt); /* consumes a reference to dlt */ } #if defined(WITHOUT_PCAP_LIB_VERSION) #if !defined(WITHOUT_VERSION_STRING) PyModule_AddStringConstant(m, "version", pcap_version); #endif #else PyModule_AddStringConstant(m, "version", pcap_lib_version()); #endif %} %pythoncode %{ for dltname, dltvalue in _pcap.DLT.items(): globals()[dltname] = dltvalue del dltname, dltvalue %} /* typemaps */ /* let functions return raw python objects */ %typemap(out) PyObject * { $result = $1; } /* let functions take raw python objects */ %typemap(in) PyObject * { $1 = $input; } /* functions taking IPv4 addresses as unsigned 32-bit integers */ %typemap(in) in_addr_t { if (PyInt_CheckExact($input)) { $1 = (unsigned long)PyInt_AS_LONG($input); } else if (!PyNumber_Check($input)) { PyErr_SetString(PyExc_TypeError, "argument must be an integer"); SWIG_fail; } else { PyObject *longobject = PyNumber_Long($input); if (longobject == NULL) { SWIG_fail; } $1 = PyLong_AsUnsignedLong(longobject); Py_DECREF(longobject); if (PyErr_Occurred()) { SWIG_fail; } /* In case AsUnsignedLong() failed */ } } %exception { $function if(PyErr_Occurred()) { SWIG_fail; } } typedef struct { %extend { pcapObject(void); DOC(new_pcapObject,"create a pcapObject instance") ~pcapObject(void); DOC(delete_pcapObject,"destroy a pcapObject instance") void open_live(char *device, int snaplen, int promisc, int to_ms); DOC(pcapObject_open_live,pcapObject_open_live_doc) void open_dead(int linktype, int snaplen); DOC(pcapObject_open_dead,pcapObject_open_dead_doc) void open_offline(char *filename); DOC(pcapObject_open_offline,pcapObject_open_offline_doc) void dump_open(char *fname); DOC(pcapObject_dump_open,pcapObject_dump_open_doc) void setnonblock(int nonblock); DOC(pcapObject_setnonblock,pcapObject_setnonblock_doc) int getnonblock(void); DOC(pcapObject_getnonblock,pcapObject_getnonblock_doc) void setfilter(char *str, int optimize, in_addr_t netmask); DOC(pcapObject_setfilter,pcapObject_setfilter_doc) void loop(int cnt, PyObject *PyObj); DOC(pcapObject_loop,pcapObject_loop_doc) int dispatch(int cnt, PyObject *PyObj); DOC(pcapObject_dispatch,pcapObject_dispatch_doc) PyObject *next(void); DOC(pcapObject_next,pcapObject_next_doc) int datalink(void); DOC(pcapObject_datalink,pcapObject_datalink_doc) #ifndef WITHOUT_LIST_DATALINKS PyObject *datalinks(void); DOC(pcapObject_datalinks,pcapObject_datalinks_doc) #endif int snapshot(void); DOC(pcapObject_snapshot,pcapObject_snapshot_doc) int is_swapped(void); DOC(pcapObject_is_swapped,pcapObject_is_swapped_doc) int major_version(void); DOC(pcapObject_major_version,pcapObject_major_version_doc) int minor_version(void); DOC(pcapObject_minor_version,pcapObject_minor_version_doc) PyObject *stats(void); DOC(pcapObject_stats,pcapObject_stats_doc) int fileno(void); DOC(pcapObject_fileno,pcapObject_fileno_doc) } } pcapObject; /* functions not associated with a pcapObject instance */ char *lookupdev(void); DOC(lookupdev,lookupdev_doc) PyObject *findalldevs(int unpack=1); DOC(findalldevs,findalldevs_doc) PyObject *lookupnet(char *device); DOC(lookupnet,lookupnet_doc) /* useful non-pcap functions */ PyObject *aton(char *cp); DOC(aton,"aton(addr)\n\nconvert dotted decimal IP string to network byte order int") char *ntoa(in_addr_t addr); DOC(ntoa,"ntoa(addr)\n\nconvert network byte order int to dotted decimal IP string") pylibpcap-0.6.4/pcap.py000644 000766 000024 00000011756 11701436273 015133 0ustar00wimlstaff000000 000000 # This file was automatically generated by SWIG (http://www.swig.org). # Version 1.3.31 # # Don't modify this file, modify the SWIG interface instead. # This file is compatible with both classic and new-style classes. import _pcap import new new_instancemethod = new.instancemethod try: _swig_property = property except NameError: pass # Python < 2.2 doesn't have 'property'. def _swig_setattr_nondynamic(self,class_type,name,value,static=1): if (name == "thisown"): return self.this.own(value) if (name == "this"): if type(value).__name__ == 'PySwigObject': self.__dict__[name] = value return method = class_type.__swig_setmethods__.get(name,None) if method: return method(self,value) if (not static) or hasattr(self,name): self.__dict__[name] = value else: raise AttributeError("You cannot add attributes to %s" % self) def _swig_setattr(self,class_type,name,value): return _swig_setattr_nondynamic(self,class_type,name,value,0) def _swig_getattr(self,class_type,name): if (name == "thisown"): return self.this.own() method = class_type.__swig_getmethods__.get(name,None) if method: return method(self) raise AttributeError,name def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() except: strthis = "" return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) import types try: _object = types.ObjectType _newclass = 1 except AttributeError: class _object : pass _newclass = 0 del types __doc__ = _pcap.__doc__ for dltname, dltvalue in _pcap.DLT.items(): globals()[dltname] = dltvalue del dltname, dltvalue class pcapObject(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, pcapObject, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, pcapObject, name) __repr__ = _swig_repr def __init__(self, *args): import sys if int(sys.version[0])>='2': self.datalink.im_func.__doc__ = _pcap.pcapObject_datalink.__doc__ self.fileno.im_func.__doc__ = _pcap.pcapObject_fileno.__doc__ self.datalinks.im_func.__doc__ = _pcap.pcapObject_datalinks.__doc__ self.major_version.im_func.__doc__ = _pcap.pcapObject_major_version.__doc__ self.minor_version.im_func.__doc__ = _pcap.pcapObject_minor_version.__doc__ self.getnonblock.im_func.__doc__ = _pcap.pcapObject_getnonblock.__doc__ self.open_live.im_func.__doc__ = _pcap.pcapObject_open_live.__doc__ self.dispatch.im_func.__doc__ = _pcap.pcapObject_dispatch.__doc__ self.setnonblock.im_func.__doc__ = _pcap.pcapObject_setnonblock.__doc__ self.stats.im_func.__doc__ = _pcap.pcapObject_stats.__doc__ self.is_swapped.im_func.__doc__ = _pcap.pcapObject_is_swapped.__doc__ self.open_dead.im_func.__doc__ = _pcap.pcapObject_open_dead.__doc__ self.dump_open.im_func.__doc__ = _pcap.pcapObject_dump_open.__doc__ self.next.im_func.__doc__ = _pcap.pcapObject_next.__doc__ self.open_offline.im_func.__doc__ = _pcap.pcapObject_open_offline.__doc__ self.snapshot.im_func.__doc__ = _pcap.pcapObject_snapshot.__doc__ self.loop.im_func.__doc__ = _pcap.pcapObject_loop.__doc__ self.setfilter.im_func.__doc__ = _pcap.pcapObject_setfilter.__doc__ this = _pcap.new_pcapObject(*args) try: self.this.append(this) except: self.this = this def open_live(*args): return _pcap.pcapObject_open_live(*args) def open_dead(*args): return _pcap.pcapObject_open_dead(*args) def open_offline(*args): return _pcap.pcapObject_open_offline(*args) def dump_open(*args): return _pcap.pcapObject_dump_open(*args) def setnonblock(*args): return _pcap.pcapObject_setnonblock(*args) def getnonblock(*args): return _pcap.pcapObject_getnonblock(*args) def setfilter(*args): return _pcap.pcapObject_setfilter(*args) def loop(*args): return _pcap.pcapObject_loop(*args) def dispatch(*args): return _pcap.pcapObject_dispatch(*args) def next(*args): return _pcap.pcapObject_next(*args) def datalink(*args): return _pcap.pcapObject_datalink(*args) def datalinks(*args): return _pcap.pcapObject_datalinks(*args) def snapshot(*args): return _pcap.pcapObject_snapshot(*args) def is_swapped(*args): return _pcap.pcapObject_is_swapped(*args) def major_version(*args): return _pcap.pcapObject_major_version(*args) def minor_version(*args): return _pcap.pcapObject_minor_version(*args) def stats(*args): return _pcap.pcapObject_stats(*args) def fileno(*args): return _pcap.pcapObject_fileno(*args) __swig_destroy__ = _pcap.delete_pcapObject __del__ = lambda self : None; pcapObject_swigregister = _pcap.pcapObject_swigregister pcapObject_swigregister(pcapObject) lookupdev = _pcap.lookupdev findalldevs = _pcap.findalldevs lookupnet = _pcap.lookupnet aton = _pcap.aton ntoa = _pcap.ntoa pylibpcap-0.6.4/pcap_interface.c000644 000766 000024 00000040637 11701420260 016732 0ustar00wimlstaff000000 000000 /* Python libpcap Copyright (C) 2001, David Margrave Copyright (C) 2003-2004,2012 William Lewis Based on PY-libpcap (C) 1998, Aaron L. Rhodes This program is free software; you can redistribute it and/or modify it under the terms of the BSD Licence. See the file COPYING for details. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include #include #include #include #include "pypcap.h" #ifdef AF_LINK #include #endif #if defined(AF_INET6) && !defined(INET6_ADDRSTRLEN) #define INET6_ADDRSTRLEN 46 #endif #ifndef MAX #define MAX(a,b) ((a)>(b)?(a):(b)) #endif #if 0 /* this was required with LBL libpcap but is evidently not required with or even present in the new libpcap that comes with RH 7.2 */ void linux_restore_ifr(void); #endif static int check_ctx(pcapObject *self); static int pcapObject_invoke(pcapObject *self, int cnt, PyObject *PyObj, int (*f)(pcap_t *, int, pcap_handler, u_char *)); static void PythonCallBack(u_char *user_data, const struct pcap_pkthdr *header, const u_char *packetdata); struct pythonCallBackContext { PyObject *func; pcap_t *pcap; PyThreadState *threadstate; }; static int check_ctx(pcapObject *self) { if (!self->pcap) { PyErr_SetString(PyExc_RuntimeError, "pcapObject must be initialized via open_live(), " "open_offline(), or open_dead() methods"); return 1; } return 0; } static int check_noctx(pcapObject *self) { if (self->pcap) { PyErr_SetString(PyExc_RuntimeError, "pcapObject was already opened"); return 1; } return 0; } /* pcapObject *new_pcapObject(char *device, int snaplen, int promisc, int to_ms) */ pcapObject *new_pcapObject(void) { pcapObject *self; self = (pcapObject *)malloc(sizeof(pcapObject)); self->pcap = NULL; self->pcap_dumper=NULL; return self; } void delete_pcapObject(pcapObject *self) { if (self->pcap_dumper) pcap_dump_close(self->pcap_dumper); if (self->pcap) pcap_close(self->pcap); #if 0 #ifdef __linux linux_restore_ifr(); #endif #endif free(self); } void pcapObject_open_live(pcapObject *self, char *device, int snaplen, int promisc, int to_ms) { char ebuf[PCAP_ERRBUF_SIZE]; pcap_t *opened; if (check_noctx(self)) return; Py_BEGIN_ALLOW_THREADS opened = pcap_open_live(device, snaplen, promisc, to_ms, ebuf); Py_END_ALLOW_THREADS if (!opened) throw_exception(-1, ebuf); else self->pcap = opened; } void pcapObject_open_dead(pcapObject *self, int linktype, int snaplen) { pcap_t *opened; if (check_noctx(self)) return; Py_BEGIN_ALLOW_THREADS opened = pcap_open_dead(linktype, snaplen); Py_END_ALLOW_THREADS if (!opened) throw_exception(errno, "pcap_open_dead failed"); else self->pcap = opened; } void pcapObject_open_offline(pcapObject *self, char *fname) { char ebuf[PCAP_ERRBUF_SIZE]; pcap_t *opened; if (check_noctx(self)) return; Py_BEGIN_ALLOW_THREADS opened = pcap_open_offline(fname, ebuf); Py_END_ALLOW_THREADS if (!opened) throw_exception(-1, ebuf); else self->pcap = opened; } void pcapObject_dump_open(pcapObject *self, char *fname) { if (check_ctx(self)) return; Py_BEGIN_ALLOW_THREADS if (self->pcap_dumper) pcap_dump_close(self->pcap_dumper); self->pcap_dumper = pcap_dump_open(self->pcap, fname); Py_END_ALLOW_THREADS if (!self->pcap_dumper) throw_pcap_exception(self->pcap, "pcap_dump_open"); } void pcapObject_setnonblock(pcapObject *self, int nonblock) { char ebuf[PCAP_ERRBUF_SIZE]; if (check_ctx(self)) return; if (pcap_setnonblock(self->pcap, nonblock, ebuf)<0) throw_pcap_exception(self->pcap, "pcap_setnonblock"); } int pcapObject_getnonblock(pcapObject *self) { int status; char ebuf[PCAP_ERRBUF_SIZE]; if (check_ctx(self)) return 0; status=pcap_getnonblock(self->pcap, ebuf); if (status<0) throw_exception(-1, ebuf); return status; } void pcapObject_setfilter(pcapObject *self, char *str, int optimize, in_addr_t netmask) { struct bpf_program bpfprog; int status; PyThreadState *saved_state; if (check_ctx(self)) return; saved_state = PyEval_SaveThread(); /* Py_BEGIN_ALLOW_THREADS */ status = pcap_compile(self->pcap, &bpfprog, str, optimize, (bpf_u_int32)netmask); if (status) { PyEval_RestoreThread(saved_state); throw_pcap_exception(self->pcap, "pcap_compile"); return; } status = pcap_setfilter(self->pcap, &bpfprog); PyEval_RestoreThread(saved_state); if (status) throw_pcap_exception(self->pcap, "pcap_setfilter"); } void pcapObject_loop(pcapObject *self, int cnt, PyObject *PyObj) { pcapObject_invoke(self, cnt, PyObj, pcap_loop); } int pcapObject_dispatch(pcapObject *self, int cnt, PyObject *PyObj) { return pcapObject_invoke(self, cnt, PyObj, pcap_dispatch); } static int pcapObject_invoke(pcapObject *self, int cnt, PyObject *PyObj, int (*f)(pcap_t *, int, pcap_handler, u_char *)) { int status; pcap_handler callback; void *callback_arg; struct pythonCallBackContext callbackContextBuf; if (check_ctx(self)) return -1; if (PyCallable_Check(PyObj)) { callback = PythonCallBack; callbackContextBuf.func = PyObj; callbackContextBuf.pcap = self->pcap; callback_arg = &callbackContextBuf; } else if(PyObj == Py_None && self->pcap_dumper != NULL) { callback = pcap_dump; callback_arg = self->pcap_dumper; } else { PyErr_SetString(PyExc_TypeError, "argument must be a callable object, or None to invoke dumper"); return -1; } /* Release the GIL and store the current thread state. We store it in the callbackContextBuf even if we're not otherwise using that buf (the pcap_dump callback doesn't touch Python so it doesn't need to reacquire the GIL). */ callbackContextBuf.threadstate = PyEval_SaveThread(); status=(*f)(self->pcap, cnt, callback, callback_arg); PyEval_RestoreThread(callbackContextBuf.threadstate); /* the pcap(3) man page describes the specal return values -1 and -2 */ if (status == -2 && PyErr_Occurred()) { /* pcap_breakloop() was called */ return status; } if (status<0) { throw_pcap_exception(self->pcap, NULL); return status; } if (PyErr_CheckSignals()) return -1; return status; } PyObject *pcapObject_next(pcapObject *self) { struct pcap_pkthdr header; const unsigned char *buf; PyObject *outObject; if (check_ctx(self)) return NULL; Py_BEGIN_ALLOW_THREADS buf = pcap_next(self->pcap, &header); Py_END_ALLOW_THREADS if (buf == NULL) { Py_INCREF(Py_None); return Py_None; } outObject = Py_BuildValue("is#f", header.len, buf, header.caplen, header.ts.tv_sec*1.0+header.ts.tv_usec*1.0/1e6); return outObject; } int pcapObject_datalink(pcapObject *self) { if (check_ctx(self)) return 0; return pcap_datalink(self->pcap); } #ifndef WITHOUT_LIST_DATALINKS PyObject *pcapObject_datalinks(pcapObject *self) { int *links; int linkcount, i; PyObject *result; if (check_ctx(self)) return NULL; Py_BEGIN_ALLOW_THREADS links = NULL; linkcount = pcap_list_datalinks(self->pcap, &links); Py_END_ALLOW_THREADS if (linkcount < 0) { throw_pcap_exception(self->pcap, "list_datalinks"); return NULL; } result = PyTuple_New(linkcount); if (!result) { free(links); return NULL; } for(i = 0; i < linkcount; i ++) { PyObject *linktype = PyInt_FromLong( (long) (links[i]) ); if (!linktype) { Py_DECREF(result); free(links); return NULL; } PyTuple_SET_ITEM(result, i, linktype); /* consumes a reference to linktype */ } free(links); return result; } #endif /* WITHOUT_LIST_DATALINKS */ int pcapObject_snapshot(pcapObject *self) { if (check_ctx(self)) return 0; return pcap_snapshot(self->pcap); } int pcapObject_is_swapped(pcapObject *self) { if (check_ctx(self)) return 0; return pcap_is_swapped(self->pcap); } int pcapObject_major_version(pcapObject *self) { if (check_ctx(self)) return 0; return pcap_major_version(self->pcap); } int pcapObject_minor_version(pcapObject *self) { if (check_ctx(self)) return 0; return pcap_minor_version(self->pcap); } PyObject *pcapObject_stats(pcapObject *self) { struct pcap_stat pstat; PyObject *outTuple; if (check_ctx(self)) return NULL; Py_BEGIN_ALLOW_THREADS pstat.ps_recv = 0; pstat.ps_drop = 0; pstat.ps_ifdrop = 0; /* pcap_stats always returns 0, no need to check */ pcap_stats(self->pcap, &pstat); Py_END_ALLOW_THREADS outTuple = Py_BuildValue("(iii)", pstat.ps_recv, pstat.ps_drop, pstat.ps_ifdrop); return outTuple; } FILE *pcapObject_file(pcapObject *self) { if (check_ctx(self)) return NULL; return pcap_file(self->pcap); } int pcapObject_fileno(pcapObject *self) { if (check_ctx(self)) return 0; return pcap_fileno(self->pcap); } /* functions that are not methods of pcapObject */ char *lookupdev(void) { char *dev; char ebuf[PCAP_ERRBUF_SIZE]; Py_BEGIN_ALLOW_THREADS dev = pcap_lookupdev(ebuf); Py_END_ALLOW_THREADS if (dev) return dev; else { throw_exception(errno,ebuf); return NULL; } } #ifdef AF_LINK static PyObject * string_from_sockaddr_dl(struct sockaddr_dl *sdl) { char *buf; int sdl_len, dlpos, buf_size; PyObject *str; sdl_len = sdl->sdl_alen + sdl->sdl_slen; if (sdl_len == 0) { Py_INCREF(Py_None); return(Py_None); } buf_size = 3 * sdl_len; buf = malloc(buf_size); for(dlpos = 0; dlpos < sdl_len; dlpos ++) { char *bufpos = buf + (3 * dlpos); unsigned char dlbyte = sdl->sdl_data[sdl->sdl_nlen + dlpos]; sprintf(bufpos, "%02x", dlbyte); if (dlpos == sdl_len - 1) bufpos[2] = (char)0; else if (dlpos == sdl->sdl_alen - 1) bufpos[2] = '#'; else bufpos[2] = ':'; } str = PyString_FromString(buf); free(buf); return str; } #endif /* AF_LINK */ /* Ways to figure out how long a given sockaddr is. This varies a lot from system to system. Fortunately, we have access to Python's autoconf defined from pyconfig.h. */ #if defined(HAVE_SOCKADDR_SA_LEN) #define SOCKADDR_LENGTH(sa) ((sa)->sa_len) #elif defined(SA_LEN) #define SOCKADDR_LENGTH(sa) (SA_LEN(sa)) #else #define SOCKADDR_LENGTH(sa) sockaddr_length(sa) static int sockaddr_length(struct sockaddr *sa) { switch(sa->sa_family) { case AF_INET: return sizeof(struct sockaddr_in); break; #ifdef AF_INET6 case AF_INET6: return sizeof(struct sockaddr_in6); break; #endif #ifdef AF_LINK case AF_LINK: return sizeof(struct sockaddr_dl); break; #endif default: #ifdef HAVE_SOCKADDR_STORAGE return sizeof(struct sockaddr_storage); #else return sizeof(struct sockaddr); #endif break; } } #endif PyObject *packed_sockaddr(struct sockaddr *sa) { int length; if (sa == NULL) { Py_INCREF(Py_None); return Py_None; } length = SOCKADDR_LENGTH(sa); return PyString_FromStringAndSize( (const char *)sa, length ); } PyObject *object_from_sockaddr(struct sockaddr *sa) { char *buf; size_t buf_size; void *src; PyObject *result; if (sa == NULL) { Py_INCREF(Py_None); return Py_None; } switch(sa->sa_family) { case AF_INET: src = &(((struct sockaddr_in *)sa) -> sin_addr); buf_size = INET_ADDRSTRLEN; break; #ifdef AF_INET6 case AF_INET6: src = &(((struct sockaddr_in6 *)sa) -> sin6_addr); buf_size = INET6_ADDRSTRLEN; break; #endif #ifdef AF_LINK case AF_LINK: result = string_from_sockaddr_dl( (struct sockaddr_dl *)sa ); return result; break; #endif default: /* PyErr_Format(PyExc_Exception, "unsupported address family %d", sa->sa_family); return NULL; */ return PyString_FromFormat("", sa->sa_family); case AF_UNSPEC: Py_INCREF(Py_None); return Py_None; } buf = malloc(buf_size); if (inet_ntop(sa->sa_family, src, buf, buf_size) == NULL) { free(buf); throw_exception(errno, "cannot convert address to string"); return NULL; } result = PyString_FromString(buf); free(buf); return result; } static struct sockaddr *fill_netmask(struct sockaddr *ref, struct sockaddr *sa, void **free_this) { if (ref == NULL || sa == NULL) return NULL; #ifdef HAVE_SOCKADDR_SA_LEN if (ref->sa_len == 0) return NULL; if (sa->sa_family == AF_UNSPEC) { int len = MAX(sa->sa_len, ref->sa_len); struct sockaddr *buf; char *sap, *bufp; int offs; buf = *free_this = malloc(len); bufp = (char *)buf; sap = (char *)sa; offs = ( (char *)&(buf->sa_data) ) - ( (char *)buf ); bcopy(ref, buf, offs); while( offs < len ) { bufp[offs] = ( offs < sa->sa_len )? sap[offs] : 0; offs ++; } return buf; } #else if (sa->sa_family == AF_UNSPEC) return NULL; #endif return sa; } PyObject *findalldevs(int unpack) { pcap_if_t *if_head, *if_current; pcap_addr_t *addr_current; PyObject *out, *addrlist, *addrlist2, *tmp; int status; char ebuf[PCAP_ERRBUF_SIZE]; PyObject *(*formatter)(struct sockaddr *); Py_BEGIN_ALLOW_THREADS status = pcap_findalldevs(&if_head, ebuf); Py_END_ALLOW_THREADS if (status) { throw_exception(errno, ebuf); pcap_freealldevs(if_head); return NULL; } if (unpack) formatter = object_from_sockaddr; else formatter = packed_sockaddr; out = PyList_New(0); for (if_current = if_head; if_current; if_current = if_current->next) { addrlist = PyList_New(0); for (addr_current = if_current->addresses; addr_current; addr_current = addr_current->next) { struct sockaddr *filled_mask; void *tmp = NULL; filled_mask = fill_netmask(addr_current->addr, addr_current->netmask, &tmp); addrlist2 = Py_BuildValue("(O&O&O&O&)", formatter, addr_current->addr, formatter, filled_mask, formatter, addr_current->broadaddr, formatter, addr_current->dstaddr); if (tmp != NULL) free(tmp); if (addrlist2 == NULL) { Py_DECREF(addrlist); Py_DECREF(out); pcap_freealldevs(if_head); return NULL; } PyList_Append(addrlist, addrlist2); Py_DECREF(addrlist2); } tmp = Py_BuildValue("ssNi", if_current->name, if_current->description, addrlist, /* refcount consumed by 'N' format */ if_current->flags); PyList_Append(out, tmp); Py_DECREF(tmp); } pcap_freealldevs(if_head); return out; } /* warning: the libpcap that ships with RH 6.2 seems to have a buggy pcap_lookupnet */ PyObject *lookupnet(char *device) { bpf_u_int32 net=0, mask=0; int status; char ebuf[PCAP_ERRBUF_SIZE]; Py_BEGIN_ALLOW_THREADS status = pcap_lookupnet(device, &net, &mask, ebuf); Py_END_ALLOW_THREADS if (status) { throw_exception(errno, ebuf); return NULL; } return Py_BuildValue("ii", net, mask); } PyObject *aton(char *cp) { PyObject *out; struct in_addr addr; int status; status=inet_aton(cp, &addr); if (!status) { throw_exception(errno, "inet_aton()"); return NULL; } out=PyInt_FromLong(addr.s_addr); return out; } char *ntoa(in_addr_t addr) { struct in_addr in; in.s_addr=addr; return inet_ntoa(in); } /* * This function matches the prototype of a libpcap callback function. * It is passed as the function callback for libpcap. */ static void PythonCallBack(u_char *user_data, const struct pcap_pkthdr *header, const u_char *packetdata) { struct pythonCallBackContext *context; PyObject *arglist, *result; context = (struct pythonCallBackContext *)user_data; /* Re-acquire the GIL and restore the Python thread state */ PyEval_RestoreThread(context->threadstate); arglist = Py_BuildValue("is#f", header->len, packetdata, header->caplen, header->ts.tv_sec*1.0+header->ts.tv_usec*1.0e-6); result = PyObject_CallObject(context->func, arglist); Py_DECREF(arglist); if (result == NULL) { /* An exception was raised by the Python callback */ context->threadstate = PyEval_SaveThread(); #ifndef WITHOUT_BREAKLOOP pcap_breakloop(context->pcap); #else /* Unfortunately, there's nothing much we can do here. */ #endif return; } else { /* ignore result (probably None) */ Py_DECREF(result); context->threadstate = PyEval_SaveThread(); return; } } pylibpcap-0.6.4/PKG-INFO000644 000766 000024 00000001357 11704160630 014721 0ustar00wimlstaff000000 000000 Metadata-Version: 1.0 Name: pylibpcap Version: 0.6.4 Summary: pylibpcap is a python module for the libpcap packet capture library. Home-page: http://pylibpcap.sourceforge.net/ Author: Wim Lewis Author-email: wiml@users.sourceforge.net License: BSD Description: pylibpcap is a python module for the libpcap packet capture library. Platform: UNKNOWN Classifier: Development Status :: 4 - Beta Classifier: Intended Audience :: Developers Classifier: Intended Audience :: System Administrators Classifier: License :: OSI Approved :: BSD License Classifier: Programming Language :: C Classifier: Programming Language :: Python Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: System :: Networking :: Monitoring pylibpcap-0.6.4/pypcap.h000644 000766 000024 00000004625 10564532100 015270 0ustar00wimlstaff000000 000000 /* * $Id: pypcap.h,v 1.13 2007/02/14 07:03:28 wiml Exp $ * Python libpcap * Copyright (C) 2001,2002 David Margrave * Copyright (C) 2004 William Lewis * Based PY-libpcap (C) 1998, Aaron L. Rhodes * * This program is free software; you can redistribute it and/or * modify it under the terms of the BSD Licence. See the file COPYING * for details. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include /* the pcap class */ typedef struct { pcap_t *pcap; pcap_dumper_t *pcap_dumper; } pcapObject; /* pcapObject methods */ /* pcapObject *new_pcapObject(char *device, int snaplen, int promisc, int to_ms); */ pcapObject *new_pcapObject(void); void delete_pcapObject(pcapObject *self); void pcapObject_open_live(pcapObject *self, char *device, int snaplen, int promisc, int to_ms); void pcapObject_open_dead(pcapObject *self, int linktype, int snaplen); void pcapObject_open_offline(pcapObject *self, char *fname); void pcapObject_dump_open(pcapObject *self, char *fname); void pcapObject_setnonblock(pcapObject *self, int nonblock); int pcapObject_getnonblock(pcapObject *self); void pcapObject_setfilter(pcapObject *self, char *str, int optimize, in_addr_t netmask); PyObject *pcapObject_next(pcapObject *self); int pcapObject_dispatch(pcapObject *self, int cnt, PyObject *PyObj); void pcapObject_loop(pcapObject *self, int cnt, PyObject *PyObj); int pcapObject_datalink(pcapObject *self); PyObject *pcapObject_datalinks(pcapObject *self); int pcapObject_snapshot(pcapObject *self); int pcapObject_is_swapped(pcapObject *self); int pcapObject_major_version(pcapObject *self); int pcapObject_minor_version(pcapObject *self); PyObject *pcapObject_stats(pcapObject *self); FILE *pcapObject_file(pcapObject *self); int pcapObject_fileno(pcapObject *self); /* functions that are not methods of pcapObject */ PyObject *findalldevs(int unpack); char *lookupdev(void); PyObject *lookupnet(char *device); /* useful non-pcap functions */ PyObject *aton(char *cp); char *ntoa(in_addr_t addr); /* error support fuctions */ extern PyObject *pcapError; void init_errors(PyObject *module); void throw_exception(int err, char *ebuf); void throw_pcap_exception(pcap_t *pcap, char *fname); pylibpcap-0.6.4/README000644 000766 000024 00000002321 10651604462 014502 0ustar00wimlstaff000000 000000 To compile, you will need the Python include files, libpcap 0.7.1 (or later) includes and library, as well as SWIG 1.3.12 if you wish to modify the interface (see http://www.swig.org for more information). If you do wish to modify the interface, you'll need to change 'pcap.c' to 'pcap.i' in the setup.py script. Most users won't need to touch this however. On Ubuntu/Debian systems you can install the libpcap development package in order to get the headers: apt-get install libpcap-dev Alternately, you can download pcap from www.tcpdump.org if it is not already installed on your system (or if your vendor's version is old). To build, simply run "python ./setup.py build", or "python2 ./setup.py build" You may need to edit setup.py if you are not using a recent libpcap. See the comments in that file for more information. To install, run "python ./setup.py install" To run the sample program 'sniff.py', specify the interface name and filter expression on the command line like so: [root@linuxbox pylibpcap]# ./sniff.py eth0 tcp port 80 Please refer to the online module documentation (__doc__ attributes), and the pcap man page further information David Margrave davidma@eskimo.com Wim Lewis wiml@hhhh.org pylibpcap-0.6.4/setup.cfg000644 000766 000024 00000000144 07502317334 015444 0ustar00wimlstaff000000 000000 [bdist_rpm] release = 1 doc_files = COPYING README examples/ python=python2 pylibpcap-0.6.4/setup.py000755 000766 000024 00000016064 11704160617 015347 0ustar00wimlstaff000000 000000 #! /usr/bin/env python # $Id: setup.py,v 1.17 2012/01/06 00:13:13 wiml Exp $ import sys import distutils.command.build from distutils.command.build_ext import build_ext from distutils.command.clean import clean from distutils.core import setup, Extension, Command import os config_defines = [ ] ### CONFIGURATION ### # uncomment this line and comment out the next one if you want to build # pcap.c from the SWIG interface # sourcefiles = ["mk-constants.py", "pcap.i"] sourcefiles = ["pcap.c"] # if you are building against a non-installed version of libpcap, # specify its directory here, otherwise set this to None libpcap_dir = None # libpcap_dir = "/home/wiml/netsrc/libpcap/libpcap-0.7.2" # libpcap_dir = "/home/wiml/netsrc/libpcap/libpcap-0.8.3" # libpcap_dir = "/home/wiml/netsrc/libpcap/cvs.tcpdump.org/libpcap" include_dirs = [ ] # Depending on what version of libpcap you're using, you may need to # uncomment one of these lines. # Versions prior to 0.8 don't have pcap_lib_version(). # config_defines.append('WITHOUT_PCAP_LIB_VERSION') # Versions prior to 0.8 don't have pcap_breakloop(). # config_defines.append('WITHOUT_BREAKLOOP') # Versions prior to 0.7.2 or so don't have pcap_list_datalinks(). # config_defines.append('WITHOUT_LIST_DATALINKS') # Some versions don't have pcap_version[]. # config_defines.append('WITHOUT_VERSION_STRING') ### END OF CONFIGURATION ### # You shouldn't need to modify anything below this point unless you're # doing development sourcefiles += ["pcap_interface.c","exception.c","error.c"] # I modified build_ext to add -shadow to the swig line. # yay! class pcapclean(clean): other_derived = [ 'pcap.py', 'pcap.c', 'constants.c', 'MANIFEST' ] def run (self): #if self.all: for derived in self.other_derived: if os.access(derived, os.F_OK): print derived self.announce('removing: %s' % derived) if not self.dry_run: os.unlink(derived) clean.run (self) # self.run_command('make_clean') class pcap_build_ext(build_ext): def before_swig_sources(self, sources): new_sources = [ ] for source in sources: if source == 'mk-constants.py': self.make_file( (source,), 'constants.c', execfile, (source,) ) else: new_sources.append(source) return new_sources def swig_sources(self, sources, extension=None): """Walk the list of source files in 'sources', looking for SWIG interface (.i) files. Run SWIG on all that are found, and return a modified 'sources' list with SWIG source files replaced by the generated C (or C++) files. """ sources = self.before_swig_sources(sources) new_sources = [] swig_sources = [] swig_targets = {} # XXX this drops generated C/C++ files into the source tree, which # is fine for developers who want to distribute the generated # source -- but there should be an option to put SWIG output in # the temp dir. if self.swig_cpp: target_ext = '.cpp' else: target_ext = '.c' for source in sources: (base, ext) = os.path.splitext(source) if ext == ".i": # SWIG interface file new_sources.append(base + target_ext) swig_sources.append(source) swig_targets[source] = new_sources[-1] else: new_sources.append(source) if not swig_sources: return new_sources swig = self.find_swig() swig_cmd = [swig, "-Wall", "-python", "-shadow", "-ISWIG"] if self.swig_cpp: swig_cmd.append("-c++") for source in swig_sources: target = swig_targets[source] self.announce("swigging %s to %s" % (source, target)) self.spawn(swig_cmd + ["-o", target, source]) self.announce('doc-ifying swig-generated source file %s' % target) self.spawn([sys.executable, './build-tools/docify.py', target]) self.announce('doc-ifying swig-generated shadow class file %s' % 'pcap.py') self.spawn([sys.executable, './build-tools/docify-shadow.py', 'pcap.py']) return new_sources # swig_sources () def find_swig(self): if os.environ.has_key('SWIG'): return os.environ['SWIG'] return build_ext.find_swig(self) # class build_shadowed (distutils.command.build.build): # this moves the 'build_py' subcommand to the end, so it happens # after the pcap.py module has been created by the build_ext command sub_commands = distutils.command.build.build.sub_commands sub_commands = filter(lambda x: x[0] != 'build_py', sub_commands) + \ filter(lambda x: x[0] == 'build_py', sub_commands) defines = [ ('SWIG_COBJECT_TYPES', None) ] + \ map(lambda x: (x, None), config_defines) if libpcap_dir is None: pcap_extension = Extension("_pcapmodule", sourcefiles, include_dirs = include_dirs, define_macros = defines, libraries = [ "pcap" ] ) else: include_dirs.append( libpcap_dir ) # extension_objects=[ os.path.join(libpcap_dir, 'libpcap.a') ] pcap_extension = Extension("_pcapmodule", sourcefiles, include_dirs = include_dirs, define_macros = defines, library_dirs = [ libpcap_dir ], libraries = [ "pcap" ] ) # setup (# Distribution meta-data name = "pylibpcap", version = "0.6.4", license = "BSD", description = 'pylibpcap is a python module for the libpcap packet capture library.', long_description = 'pylibpcap is a python module for the libpcap packet capture library.', url = "http://pylibpcap.sourceforge.net/", author = "David Margrave", author_email = "davidma@eskimo.com", maintainer = "Wim Lewis", maintainer_email = "wiml@users.sourceforge.net", # keywords = "", # platforms = "", py_modules = [ "pcap" ], ext_modules = [ pcap_extension ], cmdclass = {'clean': pcapclean, 'build_ext': pcap_build_ext, 'build': build_shadowed}, classifiers = [ 'Development Status :: 4 - Beta', 'Intended Audience :: Developers', 'Intended Audience :: System Administrators', 'License :: OSI Approved :: BSD License', 'Programming Language :: C', 'Programming Language :: Python', 'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: System :: Networking :: Monitoring' ], ) # vim:set ts=4 sw=4 et: pylibpcap-0.6.4/examples/findalldevs.py000755 000766 000024 00000001327 10564540145 020315 0ustar00wimlstaff000000 000000 #! /usr/bin/env python import pcap def test_findalldevs(): print pcap.findalldevs() for name, descr, addrs, flags in pcap.findalldevs(): print 'Interface name: %s' % name print ' Description: %s ' % descr if addrs: i=1 for ( addr, netmask, broadaddr, dstaddr) in addrs: print ' Address %d: %s ' % (i, addr) print ' Netmask: %s' % netmask print ' Broadcast: %s' % broadaddr print 'Peer dest addr: %s' % dstaddr i=i+1 else: print ' No addresses' print ' flags: %s ' % flags if __name__=="__main__": test_findalldevs() # vim:set ts=4 sw=4 et: pylibpcap-0.6.4/examples/sniff.py000755 000766 000024 00000006506 10564540145 017133 0ustar00wimlstaff000000 000000 #! /usr/bin/env python """ Example to sniff all HTTP traffic on eth0 interface: sudo ./sniff.py eth0 "port 80" """ import sys import pcap import string import time import socket import struct protocols={socket.IPPROTO_TCP:'tcp', socket.IPPROTO_UDP:'udp', socket.IPPROTO_ICMP:'icmp'} def decode_ip_packet(s): d={} d['version']=(ord(s[0]) & 0xf0) >> 4 d['header_len']=ord(s[0]) & 0x0f d['tos']=ord(s[1]) d['total_len']=socket.ntohs(struct.unpack('H',s[2:4])[0]) d['id']=socket.ntohs(struct.unpack('H',s[4:6])[0]) d['flags']=(ord(s[6]) & 0xe0) >> 5 d['fragment_offset']=socket.ntohs(struct.unpack('H',s[6:8])[0] & 0x1f) d['ttl']=ord(s[8]) d['protocol']=ord(s[9]) d['checksum']=socket.ntohs(struct.unpack('H',s[10:12])[0]) d['source_address']=pcap.ntoa(struct.unpack('i',s[12:16])[0]) d['destination_address']=pcap.ntoa(struct.unpack('i',s[16:20])[0]) if d['header_len']>5: d['options']=s[20:4*(d['header_len']-5)] else: d['options']=None d['data']=s[4*d['header_len']:] return d def dumphex(s): bytes = map(lambda x: '%.2x' % x, map(ord, s)) for i in xrange(0,len(bytes)/16): print ' %s' % string.join(bytes[i*16:(i+1)*16],' ') print ' %s' % string.join(bytes[(i+1)*16:],' ') def print_packet(pktlen, data, timestamp): if not data: return if data[12:14]=='\x08\x00': decoded=decode_ip_packet(data[14:]) print '\n%s.%f %s > %s' % (time.strftime('%H:%M', time.localtime(timestamp)), timestamp % 60, decoded['source_address'], decoded['destination_address']) for key in ['version', 'header_len', 'tos', 'total_len', 'id', 'flags', 'fragment_offset', 'ttl']: print ' %s: %d' % (key, decoded[key]) print ' protocol: %s' % protocols[decoded['protocol']] print ' header checksum: %d' % decoded['checksum'] print ' data:' dumphex(decoded['data']) if __name__=='__main__': if len(sys.argv) < 3: print 'usage: sniff.py ' sys.exit(0) p = pcap.pcapObject() #dev = pcap.lookupdev() dev = sys.argv[1] net, mask = pcap.lookupnet(dev) # note: to_ms does nothing on linux p.open_live(dev, 1600, 0, 100) #p.dump_open('dumpfile') p.setfilter(string.join(sys.argv[2:],' '), 0, 0) # try-except block to catch keyboard interrupt. Failure to shut # down cleanly can result in the interface not being taken out of promisc. # mode #p.setnonblock(1) try: while 1: p.dispatch(1, print_packet) # specify 'None' to dump to dumpfile, assuming you have called # the dump_open method # p.dispatch(0, None) # the loop method is another way of doing things # p.loop(1, print_packet) # as is the next() method # p.next() returns a (pktlen, data, timestamp) tuple # apply(print_packet,p.next()) except KeyboardInterrupt: print '%s' % sys.exc_type print 'shutting down' print '%d packets received, %d packets dropped, %d packets dropped by interface' % p.stats() # vim:set ts=4 sw=4 et: pylibpcap-0.6.4/build-tools/docify-shadow.py000755 000766 000024 00000006673 10564540145 021212 0ustar00wimlstaff000000 000000 #!/usr/bin/env python # This adds __doc__ lines to methods in swig-generated .py code. # simple script to hack together python __doc__ support in swig-generated # .py shadow class source files import sys import string import re import os if len(sys.argv)<2: print 'usage: docify.py ' sys.exit(1) f=open(sys.argv[1],'r') outfile=open('%s.tmp' % sys.argv[1],'w') data=f.readlines() ############################################################################# #for i in xrange(0,len(data)): # match=re.search('^.*def __del__',data[i]) # if match: # #print match.group(0) # i=i+1 # break # #if not match: # # One more chance to find __del__... # # This may be a more recent version of SWIG. # # Older versions generated __del__ methods. # # Newer versions appear to assign a lambda to __del__. # for i in xrange(0,len(data)): # match=re.search('^\s*__del__\s*=\s*lambda',data[i]) # if match: # #print match.group(0) # i=i+1 # break # if not match: # raise 'source file does not look like swigged shadow class code: '+sys.argv[1] # ## read ahead to next def statement #for i in xrange (i,len(data)): # if re.search('^\s*def', data[i]): # break # #pymeths=[] #for i in xrange (i,len(data)): # if re.search('^\s*def __repr__', data[i]): # break # pymeths.append(data[i]) # # I think that the above code can be replaced with the following and it will work # on both old-style and new-style SWIG. # collect all the lines that have public method names. pymeths=[] for i in xrange (0,len(data)): #if re.search('^\s*def\s+[^(]*', data[i]) and not re.search('^\s*def __repr__', data[i]) and not re.search('.*__del__.*', data[i]): if re.search('^\s*def\s+[^(]*', data[i]) and not re.search('^\s*def __.*', data[i]): pymeths.append(data[i]) ############################################################################# # Make a dictionary of all the method names from the method lines. methods={} for line in pymeths: methmatch=re.search('def +([^ (]*) *\(\*args\)',line) fnmatch=re.search('\:.*[^_p](_?pcapc?\.[^(, ]+) *[(,]',line) methode=None fname=None if methmatch: methode=methmatch.group(1) if fnmatch: fname=fnmatch.group(1) if methode and fname: methods[methode]=fname else: # print 'warning: method(%s) fname(%s)\n\tline: %s' % ( methode, fname, line ) pass #print methods # delete "_doc = _pcap" lines from global scope # (they get moved in slightly different form to inside __init__ method). for i in xrange(0,len(data)): # write out everything that is NOT a "_doc = _pcap" line. if not re.search('^[^ ]+_doc = _pcap.[^ ]+_doc$',data[i]): outfile.write(data[i]) match=re.search('^\s*def __init__',data[i]) if match: #print match.group(0) i=i+1 break # spit out the next 2 lines verbatim #outfile.write(data[i]) #i=i+1 #outfile.write(data[i]) #i=i+1 # put doc assignments inside of the __init__ outfile.write(' import sys\n') outfile.write(' if int(sys.version[0])>=\'2\':\n') for method, fname in methods.items(): outfile.write(' self.%s.im_func.__doc__ = %s.__doc__\n' % (method, fname)) # spit out rest of file verbatim for i in xrange (i,len(data)): outfile.write(data[i]) outfile.close() f.close() os.system('mv %s.tmp %s' % (sys.argv[1], sys.argv[1])) # vim:set ts=4 sw=4 et: pylibpcap-0.6.4/build-tools/docify.py000755 000766 000024 00000002523 10564540145 017715 0ustar00wimlstaff000000 000000 #!/usr/bin/env python # simple script to hack together python __doc__ support in swig-generated # C source files import sys import string import re import os if len(sys.argv)<2: print 'usage: docify.py ' sys.exit(1) f=open(sys.argv[1],'r') outfile=open('%s.tmp' % sys.argv[1],'w') data=f.readlines() for i in xrange(0,len(data)): outfile.write(data[i]) match=re.search('^static PyMethodDef SwigMethods',data[i]) if match: #print match.group(0) break if not match: raise 'source file does not look like swigged code: ' + argv[1] pymeths=[] for i in xrange (i,len(data)): if re.search('^.*\{.*NULL.*NULL.*\}', data[i]): break pymeths.append(data[i]) for line in pymeths: match=re.search('^.*char \*.*\".*\"',line) if match: fname=re.search('\".*\"',match.group(0)).group(0)[1:-1] if re.search('swigregister',fname): # print 'skipping doc string for %s\n' % fname outfile.write(line) continue # print fname outfile.write('\t{ (char *)\"%s\", _wrap_%s, METH_VARARGS, _doc_%s },\n' % (fname, fname, fname)) for i in xrange (i,len(data)): outfile.write(data[i]) outfile.close() f.close() os.system('mv %s.tmp %s' % (sys.argv[1], sys.argv[1])) # vim:set ts=4 sw=4 et: