# wireshark specifics
wireshark_SOURCES = \
$(WIRESHARK_COMMON_SRC) \
+ airpcap_loader.c \
alert_box.c \
capture.c \
capture_info.c \
# corresponding headers
wireshark_INCLUDES = \
+ airpcap_loader.h \
alert_box.h \
capture.h \
capture_info.h \
-e "s/@HAVE_LIBGCRYPT@/$(LIBGCRYPT_CONFIG)/" \
-e "s/@HAVE_LUA@/$(LUA_CONFIG)/" \
-e "s/@HAVE_LUA_5_1@/$(LUA_VERSION)/" \
+ -e "s/@HAVE_AIRPCAP@/$(LUA_VERSION)/" \
< config.h.win32 > $@
ps.c : rdps.exe print.ps
--- /dev/null
+/*
+ * Copyright (c) 2006 CACE Technologies, Davis (California)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#if !defined(AIRPCAP_H__EAE405F5_0171_9592_B3C2_C19EC426AD34__INCLUDED_)
+#define AIRPCAP_H__EAE405F5_0171_9592_B3C2_C19EC426AD34__INCLUDED_
+
+/* This disables a VS warning for zero-sized arrays. All the compilers we support have that feature */
+#pragma warning( disable : 4200)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ \mainpage AirPcap interface documentation
+
+ \section Introduction
+
+ This document describes the data structures and the functions exported by the CACE Technologies AirPcap library.
+ The AirPcap library provides low-level access to the AirPcap driver including advanced capabilities such as channel setting,
+ link type control and WEP configuration.<br>
+ This manual includes the following sections:
+
+ \note throughout this documentation, \i device refers to a physical USB AirPcap device, wile \i adapter is an open API
+ instance. Most of the AirPcap API operations are adapter-specific but some of them, like setting the channel, are
+ per-device and will be reflected on all the open adapters. These functions will have "Device" in their name, e.g.
+ AirpcapSetDeviceChannel().
+
+ \b Sections:
+
+ - \ref airpcapfuncs
+ - \ref airpcapdefs
+ - \ref radiotap
+*/
+
+/** @defgroup airpcapdefs AirPcap definitions and data structures
+ * @{
+ */
+
+/*!
+ \brief This string is the fixed prefix in the airpcap adapter name.
+ It can be used to parse the name field in an AirpcapDeviceDescription structure.
+*/
+#define AIRPCAP_DEVICE_NAME_PREFIX "\\\\.\\airpcap"
+
+/*!
+ \brief This string is the scanf modifier to extract the adapter number from an adapter name.
+ It can be used to parse the name field in an AirpcapDeviceDescription structure with scanf.
+*/
+#define AIRPCAP_DEVICE_NUMBER_EXTRACT_STRING "\\\\.\\airpcap%u"
+
+/*!
+ \brief Entry in the list returned by \ref AirpcapGetDeviceList();
+*/
+typedef struct _AirpcapDeviceDescription
+{
+ struct _AirpcapDeviceDescription *next; /* Next element in the list */
+ PCHAR Name; /* Device name */
+ PCHAR Description; /* Device description */
+} AirpcapDeviceDescription, *PAirpcapDeviceDescription;
+
+#define WEP_KEY_MAX_SIZE 32 /* Maximum size of a WEP key, in bytes. This is the size of an entry in the */
+ /* AirpcapWepKeysCollection structure */
+
+#ifndef __MINGW32__
+#pragma pack(push)
+#pragma pack(1)
+#endif /* __MINGW32__ */
+
+
+#define AIRPCAP_KEYTYPE_WEP 0 /* Key type: WEP. The key can have an arbitrary length smaller than 32 bytes. */
+#define AIRPCAP_KEYTYPE_TKIP 1 /* Key type: TKIP (WPA). NOT SUPPORTED YET. */
+#define AIRPCAP_KEYTYPE_CCMP 2 /* Key type: CCMP (WPA2). NOT SUPPORTED YET. */
+
+/*!
+ \brief WEP key container
+*/
+typedef struct _AirpcapKey
+{
+ UINT KeyType; /* Type of key, can be on of: \ref AIRPCAP_KEYTYPE_WEP, \ref AIRPCAP_KEYTYPE_TKIP, \ref AIRPCAP_KEYTYPE_CCMP. Only AIRPCAP_KEYTYPE_WEP is supported by the driver at the moment. */
+ UINT KeyLen; /* Length of the key, in bytes */
+ BYTE KeyData[WEP_KEY_MAX_SIZE]; /* Key Data */
+}
+#ifdef __MINGW32__
+__attribute__((__packed__))
+#endif /* __MINGW32__ */
+AirpcapKey, *PAirpcapKey;
+
+/*!
+ \brief Type of frame validation the adapter performs.
+ An adapter can be instructed to accept different kind of frames: correct frames only, frames with wrong Frame Check Sequence (FCS) only, all frames.
+*/
+typedef enum _AirpcapValidationType
+{
+ AIRPCAP_VT_ACCEPT_EVERYTHING = 1, /* Accept all the frames the device captures */
+ AIRPCAP_VT_ACCEPT_CORRECT_FRAMES = 2, /* Accept correct frames only, i.e. frames with correct Frame Check Sequence (FCS). */
+ AIRPCAP_VT_ACCEPT_CORRUPT_FRAMES = 3, /* Accept corrupt frames only, i.e. frames with worng Frame Check Sequence (FCS). */
+ AIRPCAP_VT_UNKNOWN = 4 /* Unknown validation type. You should see it only in case of error. */
+}AirpcapValidationType, *PAirpcapValidationType;
+
+/*!
+ \brief Type of decryption the adapter performs.
+ An adapter can be instructed to turn decryption (based on the device-configured keys configured
+ with \ref AirpcapSetDeviceKeys()) on or off.
+*/
+typedef enum _AirpcapDecryptionState
+{
+ AIRPCAP_DECRYPTION_ON = 1, /* This adapter performs decryption */
+ AIRPCAP_DECRYPTION_OFF = 2 /* This adapter does not perform decryption */
+}AirpcapDecryptionState, *PAirpcapDecryptionState;
+
+
+/*!
+ \brief Storage for a MAC address
+*/
+typedef struct _AirpcapMacAddress
+{
+ BYTE Address[6]; /* MAC address bytes */
+}
+#ifdef __MINGW32__
+__attribute__((__packed__))
+#endif /* __MINGW32__ */
+AirpcapMacAddress, *PAirpcapMacAddress;
+
+/*!
+ \brief This structure is used to store a collection of WEP keys.
+ Note that the definition of the structure doesn't contain any key, so be careful to allocate a buffer
+ with the size of the key, like in the following example:
+
+ \code
+ PAirpcapKeysCollection KeysCollection;
+ UINT KeysCollectionSize;
+
+ KeysCollectionSize = sizeof(AirpcapKeysCollection) + NumKeys * sizeof(AirpcapKey);
+
+ KeysCollection = (PAirpcapKeysCollection)malloc(KeysCollectionSize);
+ if(!KeysCollection)
+ {
+ // Error
+ }
+ \endcode
+*/
+typedef struct _AirpcapKeysCollection
+{
+ UINT nKeys; /* Number of keys in the collection */
+ AirpcapKey Keys[0]; /* Array of nKeys keys. */
+} AirpcapKeysCollection, *PAirpcapKeysCollection;
+
+/*!
+ \brief Packet header.
+
+ This structure defines the BPF that preceeds every packet delivered to the application.
+*/
+typedef struct _AirpcapBpfHeader
+{
+ UINT TsSec; /* Timestamp associated with the captured packet. SECONDS. */
+ UINT TsUsec; /* Timestamp associated with the captured packet. MICROSECONDS. */
+ UINT Caplen; /* Length of captured portion. The captured portion <b>can be different</b> from the original packet, because it is possible (with a proper filter) to instruct the driver to capture only a portion of the packets. */
+ UINT Originallen; /* Original length of packet */
+ USHORT Hdrlen; /* Length of bpf header (this struct plus alignment padding). In some cases, a padding could be added between the end of this structure and the packet data for performance reasons. This field can be used to retrieve the actual data of the packet. */
+}
+#ifdef __MINGW32__
+__attribute__((__packed__))
+#endif /* __MINGW32__ */
+AirpcapBpfHeader, *PAirpcapBpfHeader;
+
+/* Helper macros to extract packets coming from the driver. Rounds up to the next even multiple of AIRPCAP_ALIGNMENT. */
+#define AIRPCAP_ALIGNMENT sizeof(int)
+#define AIRPCAP_WORDALIGN(x) (((x)+(AIRPCAP_ALIGNMENT-1))&~(AIRPCAP_ALIGNMENT-1))
+
+#ifndef __MINGW32__
+#pragma pack(pop)
+#endif /* __MINGW32__ */
+
+#define AIRPCAP_ERRBUF_SIZE 512 /* Size of the error buffer, in bytes */
+
+#ifndef __AIRPCAP_DRIVER__
+
+/*!
+ \brief Link type.
+ AirPcap supports two kind of 802.11 linktypes: plain 802.11 and radiotap.
+*/
+typedef enum _AirpcapLinkType
+{
+ AIRPCAP_LT_802_11 = 1, /* plain 802.11 linktype. Every packet in the buffer contains the raw 802.11 frame, including MAC FCS. */
+ AIRPCAP_LT_802_11_PLUS_RADIO = 2, /* 802.11 plus radiotap linktype. Every packet in the buffer contains a radiotap header followed by the 802.11 frame. MAC FCS is included. */
+ AIRPCAP_LT_UNKNOWN = 3 /* Unknown linktype. You should see it only in case of error. */
+}AirpcapLinkType, *PAirpcapLinkType;
+
+#if !defined(AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_)
+#define AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_
+/*!
+ \brief Adapter handle.
+*/
+typedef struct _AirpcapHandle AirpcapHandle, *PAirpcapHandle;
+#endif
+
+/*!
+ \brief Capture statistics.
+ Returned by \ref AirpcapGetStats();
+*/
+typedef struct _AirpcapStats
+{
+ UINT Recvs; /* Number of packets that the driver received by the adapter */
+ /* from the beginning of the current capture. This value includes the packets */
+ /* dropped because of buffer full. */
+ UINT Drops; /* number of packets that the driver dropped from the beginning of a capture. */
+ /* A packet is lost when the the buffer of the driver is full. */
+ UINT IfDrops; /* Packets dropped by the card before going to the USB bus. */
+ /* Not supported at the moment. */
+ UINT Capt; /* number of packets that pass the BPF filter, find place in the kernel buffer and */
+ /* therefore reach the application. */
+}AirpcapStats, *PAirpcapStats;
+
+/*@}*/
+
+/** @defgroup airpcapfuncs AirPcap functions
+ * @{
+ */
+
+/*!
+ \brief Return a string with the API version
+ \param VersionMajor Pointer to a variable that will be filled with the major version number.
+ \param VersionMinor Pointer to a variable that will be filled with the minor version number.
+ \param VersionRev Pointer to a variable that will be filled with the revision number.
+ \param VersionBuild Pointer to a variable that will be filled with the build number.
+*/
+void AirpcapGetVersion(PUINT VersionMajor, PUINT VersionMinor, PUINT VersionRev, PUINT VersionBuild);
+
+/*!
+ \brief Return the last error related to the specified handle
+ \param AdapterHandle Handle to an open adapter.
+ \return The string with the last error.
+*/
+PCHAR AirpcapGetLastError(PAirpcapHandle AdapterHandle);
+
+/*!
+ \brief Return the list of available devices
+ \param PPAllDevs Address to a caller allocated pointer. On success this pointer will receive the head of a list of available devices.
+ \param Ebuf String that will contain error information if FALSE is returned. The size of the string must be AIRPCAP_ERRBUF_SIZE bytes.
+ \return TRUE on success. FALSE is returned on failure, in which case Ebuf is filled in with an appropriate error message.
+
+ Here's a snppet of code that shows how to use AirpcapGetDeviceList():
+
+ \code
+ CHAR Ebuf[AIRPCAP_ERRBUF_SIZE];
+ AirpcapDeviceDescription *Desc, *tDesc;
+
+ if(AirpcapGetDeviceList(&Desc, Ebuf) == -1)
+ {
+ printf("Unable to get the list of devices: %s\n", Ebuf);
+ return -1;
+ }
+
+ for(tDesc = Desc; tDesc; tDesc = tDesc->next)
+ {
+ printf("%u) %s (%s)\n",
+ ++i,
+ tDesc->Name,
+ tDesc->Description);
+ }
+ \endcode
+*/
+BOOL AirpcapGetDeviceList(PAirpcapDeviceDescription *PPAllDevs, PCHAR Ebuf);
+
+/*!
+ \brief Free a list of devices returned by AirpcapGetDeviceList()
+ \param PAllDevs Head of the list of devices returned by \ref AirpcapGetDeviceList().
+*/
+VOID AirpcapFreeDeviceList(PAirpcapDeviceDescription PAllDevs);
+
+/*!
+ \brief Open an adapter
+ \param DeviceName Name of the device to open. Use \ref AirpcapGetDeviceList() to get the list of devices.
+ \param Ebuf String that will contain error information in case of failure. The size of the string must be AIRPCAP_ERRBUF_SIZE bytes.
+ \return A PAirpcapHandle handle on success. NULL is returned on failure, in which case Ebuf is filled in with an appropriate error message.
+*/
+PAirpcapHandle AirpcapOpen(PCHAR DeviceName, PCHAR Ebuf);
+
+/*!
+ \brief Close an adapter
+ \param AdapterHandle Handle to the adapter to close.
+*/
+VOID AirpcapClose(PAirpcapHandle AdapterHandle);
+
+/*!
+ \brief Set the link type of an adapter
+ \param AdapterHandle Handle to the adapter.
+ \param NewLinkType the "link type", i.e. the format of the frames that will be received from the adapter.
+ \return TRUE on success.
+
+ the "link type" determines how the driver will encode the packets captured from the network.
+ Aircap supports two link types:
+ - AIRPCAP_LT_802_11, to capture 802.11 frames (including control frames) without any
+ power information. Look at the Capture_no_radio example application in the developer's pack
+ for a reference on how to decode 802.11 frames with this link type.
+ - AIRPCAP_LT_802_11_PLUS_RADIO, to capture 802.11 frames (including control frames) with a radiotap header
+ that contains power and channel information. More information about the radiotap header can be found int the
+ \ref radiotap section. Moreover, the "Capture_radio" example application in
+ the developer's pack can be used as a reference on how to decode 802.11 frames with radiotap headers.
+*/
+BOOL AirpcapSetLinkType(PAirpcapHandle AdapterHandle, AirpcapLinkType NewLinkType);
+
+/*!
+ \brief Get the link type of the specified adapter
+ \param AdapterHandle Handle to the adapter.
+ \param PLinkType Pointer to a caller allocated AirpcapLinkType variable that will contain the link type of the adapter.
+ \return TRUE on success.
+
+ the "link type" determines how the driver will encode the packets captured from the network.
+ Aircap supports two link types:
+ - AIRPCAP_LT_802_11, to capture 802.11 frames (including control frames) without any
+ power information. Look at the Capture_no_radio example application in the developer's pack
+ for a reference on how to decode 802.11 frames with this link type.
+ - AIRPCAP_LT_802_11_PLUS_RADIO, to capture 802.11 frames (including control frames) with a radiotap header
+ that contains power and channel information. More information about the radiotap header can be found int the
+ \ref radiotap section. Moreover, the "Capture_radio" example application in
+ the developer's pack can be used as a reference on how to decode 802.11 frames with radiotap headers.
+*/
+BOOL AirpcapGetLinkType(PAirpcapHandle AdapterHandle, PAirpcapLinkType PLinkType);
+
+/*!
+ \brief Configures the adapter on whether to include the MAC Frame Check Sequence in the captured packets.
+ \param AdapterHandle Handle to the adapter.
+ \param IsFcsPresent TRUE if the packets should include the FCS. FALSE otherwise
+ \return TRUE on success.
+
+ In the default configuration, the adapter includes the FCS in the captured packets. The MAC Frame Check Sequence
+ is 4 bytes and is located at the end of the 802.11 packet, with both AIRPCAP_LT_802_11 and AIRPCAP_LT_802_11_PLUS_RADIO
+ link types.
+ When the FCS inclusion is turned on, and if the link type is AIRPCAP_LT_802_11_PLUS_RADIO, the radiotap header
+ that precedes each frame has two additional fields at the end: Padding and FCS. These two fields are not present
+ when FCS inclusion is off.
+*/
+BOOL AirpcapSetFcsPresence(PAirpcapHandle AdapterHandle, BOOL IsFcsPresent);
+
+/*!
+ \brief Returns TRUE if the specified adapter includes the MAC Frame Check Sequence in the captured packets
+ \param AdapterHandle Handle to the adapter.
+ \param PIsFcsPresent User-provided variable that will be set to true if the adapter is including the FCS.
+ \return TRUE if the operation is successful. FALSE otherwise.
+
+ In the default configuration, the adatper has FCS inclusion turned on. The MAC Frame Check Sequence is 4 bytes
+ and is located at the end of the 802.11 packet, with both AIRPCAP_LT_802_11 and AIRPCAP_LT_802_11_PLUS_RADIO
+ link types.
+ When the FCS inclusion is turned on, and if the link type is AIRPCAP_LT_802_11_PLUS_RADIO, the radiotap header
+ that precedes each frame has two additional fields at the end: Padding and FCS. These two fields are not present
+ when FCS inclusion is off.
+*/
+BOOL AirpcapGetFcsPresence(PAirpcapHandle AdapterHandle, PBOOL PIsFcsPresent);
+
+/*!
+ \brief Configures the adapter to accept or drop frames with an incorrect Frame Check sequence (FCS).
+ \param AdapterHandle Handle to the adapter.
+ \param ValidationType The type of validation the driver will perform. See the documentation of \ref AirpcapValidationType for details.
+ \return TRUE on success.
+
+ \note By default, the driver is configured in \ref AIRPCAP_VT_ACCEPT_EVERYTHING mode.
+*/
+BOOL AirpcapSetFcsValidation(PAirpcapHandle AdapterHandle, AirpcapValidationType ValidationType);
+
+/*!
+ \brief Checks if the specified adapter is configured to capture frames with incorrect an incorrect Frame Check Sequence (FCS).
+ \param AdapterHandle Handle to the adapter.
+ \param ValidationType Pointer to a user supplied variable that will contain the type of validation the driver will perform. See the documentation of \ref AirpcapValidationType for details.
+ \return TRUE if the operation is succesful. FALSE otherwise.
+
+ \note By default, the driver is configured in \ref AIRPCAP_VT_ACCEPT_EVERYTHING mode.
+*/
+BOOL AirpcapGetFcsValidation(PAirpcapHandle AdapterHandle, PAirpcapValidationType ValidationType);
+
+/*!
+ \brief Set the list of decryption keys that the driver is going to use with the specified device.
+ \param AdapterHandle Handle an open adapter instance.
+ \param KeysCollection Pointer to a \ref PAirpcapKeysCollection structure that contains the keys to be set in the driver.
+ \return TRUE if the operation is successful. FALSE otherwise.
+
+ The AirPcap driver is able to use a set of decryption keys to decrypt the traffic transmitted on a specific SSID. If one of the
+ keys corresponds to the one the frame has been encrypted with, the driver will perform decryption and return the cleartext frames
+ to the application.
+ The driver supports, for every device, multiple keys at the same time.
+
+ At this time, the only supported decryption method is WEP.
+
+ The configured decryption keys are device-specific: they will not be used by other airpcap devices besides the specified one.
+
+ The keys are applied to the packets in the same order they appear in the KeysCollection structure until the packet is
+ correctly decrypted, therefore putting frequently used keys at the beginning of the structure improves performance.
+
+ \note: this is a Device-related function: when you change the channel from an open capture instance, the change will be
+ immediately reflected on all the other capture instances.
+*/
+BOOL AirpcapSetDeviceKeys(PAirpcapHandle AdapterHandle, PAirpcapKeysCollection KeysCollection);
+
+/*!
+ \brief Returns the list of decryption keys in the driver that are currently associated with the specified device
+ \param AdapterHandle Handle to an open adapter instance.
+ \param KeysCollection User-allocated PAirpcapKeysCollection structure that will be filled with the keys.
+ \param PKeysCollectionSize \b IN: pointer to a user-allocated variable that contains the length of the KeysCollection structure, in bytes.
+ \b OUT: amount of data moved by the driver in the buffer pointed by KeysBuffer, in bytes.
+ \return TRUE if the operation is succesful. If an error occurs, the return value is FALSE and KeysCollectionSize is zero.
+ If the provided buffer is too small to contain the keys, the return value is FALSE and KeysCollectionSize contains the
+ needed KeysCollection length, in bytes. If the device doesn't have any decryption key configured, the return value is TRUE, and
+ KeysCollectionSize will be zero.
+
+ This function returns the list of decryption keys in the driver that are associated with the specified device.
+ The AirPcap driver is able to use a set of decryption keys to decrypt the traffic transmitted on a specific SSID. If one of the
+ keys corresponds to the one the frame has been encrypted with, the driver will perform decryption and return the cleartext frames
+ to the application.
+ The driver supports, for every device, multiple keys at the same time.
+
+ The configured decryption keys are device-specific, therefore AirpcapGetDeviceKeys() will return a different set of keys
+ when called on different devices.
+
+ At this time, the only supported decryption method is WEP.
+
+ \note: this is a Device-related function: when you change the channel from an open capture instance, the change will be
+ immediately reflected on all the other capture instances.
+*/
+BOOL AirpcapGetDeviceKeys(PAirpcapHandle AdapterHandle, PAirpcapKeysCollection KeysCollection, PUINT PKeysCollectionSize);
+
+/*!
+ \brief Turns on or off the decryption of the incoming frames
+ \param AdapterHandle Handle to the adapter.
+ \param ValidationType Either \ref AIRPCAP_DECRYPTION_ON or \ref AIRPCAP_DECRYPTION_OFF
+ \return TRUE on success.
+
+ The decryption keys can be configured with the \ref AirpcapSetDeviceKeys() function.
+ \note By default, the driver is configured with \ref AIRPCAP_DECRYPTION_ON.
+*/
+BOOL AirpcapSetDecryptionState(PAirpcapHandle AdapterHandle, AirpcapDecryptionState Enable);
+
+/*!
+ \brief Tells if this open instance is configured to perform the decryption of the incoming frames
+ \param AdapterHandle Handle to the adapter.
+ \param ValidationType Pointer to a user supplied variable that will contain the decryption configuration. See \ref PAirpcapDecryptionState for details.
+ \return TRUE if the operation is succesful. FALSE otherwise.
+
+ The decryption keys can be configured with the \ref AirpcapSetDeviceKeys() function.
+ \note By default, the driver is configured with \ref AIRPCAP_DECRYPTION_ON.
+*/
+BOOL AirpcapGetDecryptionState(PAirpcapHandle AdapterHandle, PAirpcapDecryptionState PEnable);
+
+/*!
+ \brief Set the radio channel of a device
+ \param AdapterHandle Handle to the adapter.
+ \param Channel the new channel to set.
+ \return TRUE on success.
+
+ Valid channels are in the range 1-14. The default channel setting is 6.
+
+ \note: this is a Device-related function: when you change the channel from an open capture instance, the change will be
+ immediately reflected on all the other capture instances.
+*/
+BOOL AirpcapSetDeviceChannel(PAirpcapHandle AdapterHandle, UINT Channel);
+
+/*!
+ \brief Get the radio channel of a device
+ \param AdapterHandle Handle to the adapter.
+ \param PChannel Pointer to a user-supplied variable into which the function will copy the currently configured radio channel.
+ \return TRUE on success.
+
+ Valid channels are in the range 1-14. The default channel setting is 6.
+
+ \note: this is a Device-related function: when you change the channel from an open capture instance, the change will be
+ immediately reflected on all the other capture instances.
+*/
+BOOL AirpcapGetDeviceChannel(PAirpcapHandle AdapterHandle, PUINT PChannel);
+
+/*!
+ \brief Set the size of the kernel packet buffer for this adapter
+ \param AdapterHandle Handle to the adapter.
+ \param BufferSize New size, in bytes.
+ \return TRUE on success.
+
+ Every AirPcap open instance has an associated kernel buffer, whose default size is 1 Mbyte.
+ This function can be used to change the size of this buffer, and can be called at any time.
+ A bigger kernel buffer size decreases the risk of dropping packets during network bursts or when the
+ application is busy, at the cost of higher kernel memory usage.
+
+ \note: don't use this function unless you know what you are doing. Due to chaching issues and bigger non-paged
+ memory consumption, Bigger buffer sizes can decrease the capture performace instead of improving it.
+*/
+BOOL AirpcapSetKernelBuffer(PAirpcapHandle AdapterHandle, UINT BufferSize);
+
+/*!
+ \brief Get the size of the kernel packet buffer for this adapter
+ \param AdapterHandle Handle to the adapter.
+ \param PSizeBytes User-allocated variable that will be filled with the size of the kernel buffer.
+ \return TRUE on success.
+
+ Every AirPcap open instance has an associated kernel buffer, whose default size is 1 Mbyte.
+ This function can be used to get the size of this buffer.
+*/
+BOOL AirpcapGetKernelBufferSize(PAirpcapHandle AdapterHandle, PUINT PSizeBytes);
+
+/*!
+ \brief Saves the configuration of the specified adapter in the registry, so that it becomes the default for this adapter.
+ \param AdapterHandle Handle to the adapter.
+ \return TRUE on success. FALSE on failure.
+
+ Almost all the AirPcap calls that modify the configuration (\ref AirpcapSetLinkType(), \ref AirpcapSetFcsPresence(),
+ \ref AirpcapSetFcsValidation(), \ref AirpcapSetKernelBuffer(), \ref AirpcapSetMinToCopy())
+ affect only the referenced AirPcap open instance. This means that if you do another \ref AirpcapOpen() on the same
+ adapter, the configuration changes will not be remembered, and the new adapter handle will have default configuration
+ settings.
+
+ Exceptions to this rule are the \ref AirpcapSetDeviceChannel() and \ref AirpcapSetDeviceKeys() functions: a channel change is
+ reflected on all the open instances, and remembered until the next call to \ref AirpcapSetDeviceChannel(), until the adapter
+ is unplugged, or until the machine is powered off. Same thing for the configuration of the WEP keys.
+
+ AirpcapStoreCurConfigAsAdapterDefault() stores the configuration of the give open instance as the default for the adapter:
+ all the instances opened in the future will have the same configuration that this adapter currently has.
+ The configuration is stored in the registry, therefore it is remembered even when the adapter is unplugged or the
+ machine is turned off. However, an adapter doesn't bring its configuration with it from machine to machine.
+
+ the configuration information saved in the registry includes the following parameters:
+ - channel
+ - kernel buffer size
+ - mintocopy
+ - link type
+ - CRC presence
+ - Encryption keys
+ - Encryption Enabled/Disabled state
+
+ The configuration is adapter-specific. This means that changing the configuration of an adapter
+ doesn't modify the one of the other adapters that are currently used or that will be used in the future.
+
+ \note AirpcapStoreCurConfigAsAdapterDefault() must have exclusive access to the adapter -- it
+ will fail if more than one AirPcap handle is opened at the same time for this adapter.
+ AirpcapStoreCurConfigAsAdapterDefault() needs administrator privileges. It will fail if the calling user
+ is not a local machine administrator.
+*/
+BOOL AirpcapStoreCurConfigAsAdapterDefault(PAirpcapHandle AdapterHandle);
+
+/*!
+ \brief Set the BPF kernel filter for an adapter
+ \param AdapterHandle Handle to the adapter.
+ \param Instructions pointer to the first BPF instruction in the array. Corresponds to the bf_insns
+ in a bpf_program structure (see the WinPcap documentation at http://www.winpcap.org/devel.htm).
+ \param Len Number of instructions in the array pointed by the previous field. Corresponds to the bf_len in
+ a a bpf_program structure (see the WinPcap documentation at http://www.winpcap.org/devel.htm).
+ \return TRUE on success.
+
+ The AirPcap driver is able to perform kernel-level filtering using the standard BPF pseudo-machine format. You can read
+ the WinPcap documentation at http://www.winpcap.org/devel.htm for more details on the BPF filtering mechaism.
+
+ A filter can be automatically created by using the pcap_compile() function of the WinPcap API. This function
+ converts a human readable text expression with the tcpdump/libpcap syntax into a BPF program.
+ If your program doesn't link wpcap, but you need to generate the code for a particular filter, you can run WinDump
+ with the -d or -dd or -ddd flags to obtain the pseudocode.
+
+*/
+BOOL AirpcapSetFilter(PAirpcapHandle AdapterHandle, PVOID Instructions, UINT Len);
+
+/*!
+ \brief Return the MAC address of an adapter.
+ \param AdapterHandle Handle to the adapter.
+ \param PMacAddress Pointer to a user allocated MAC address.
+ The size of this buffer needs to be at least 6 bytes.
+ \return TRUE on success.
+*/
+BOOL AirpcapGetMacAddress(PAirpcapHandle AdapterHandle, PAirpcapMacAddress PMacAddress);
+
+/*!
+ \brief Set the mintocopy parameter for an open adapter
+ \param AdapterHandle Handle to the adapter.
+ \param MinToCopy is the mintocopy size in bytes.
+ \return TRUE on success.
+
+ When the number of bytes in the kernel buffer changes from less than mintocopy bytes to greater than or equal to mintocopy bytes,
+ the read event is signalled (see \ref AirpcapGetReadEvent()). A high value for mintocopy results in poor responsiveness since the
+ driver may signal the application "long" after the arrival of the packet. And a high value results in low CPU loading
+ by minimizing the number of user/kernel context switches.
+ A low MinToCopy results in good responsiveness since the driver will signal the application close to the arrival time of
+ the packet. This has higher CPU loading over the first approach.
+*/
+BOOL AirpcapSetMinToCopy(PAirpcapHandle AdapterHandle, UINT MinToCopy);
+
+/*!
+ \brief Gets an event that is signaled when that is signalled when packets are available in the kernel buffer (see \ref AirpcapSetMinToCopy()).
+ \param AdapterHandle Handle to the adapter.
+ \param PReadEvent Pointer to a user-supplied handle that in which the read event will be copied.
+ \return TRUE on success.
+
+ \note the event is signalled when at least mintocopy bytes are present in the kernel buffer (see \ref AirpcapSetMinToCopy()).
+ This event can be used by WaitForSingleObject() and WaitForMultipleObjects() to create blocking behavior when reading
+ packets from one or more adapters (see \ref AirpcapRead()).
+*/
+BOOL AirpcapGetReadEvent(PAirpcapHandle AdapterHandle, HANDLE* PReadEvent);
+
+/*!
+ \brief Fills a user-provided buffer with zero or more packets that have been captured on the referenced adapter.
+ \param AdapterHandle Handle to the adapter.
+ \param Buffer pointer to the buffer that will be filled with captured packets.
+ \param BufSize size of the input buffer that will contain the packets, in bytes.
+ \param PReceievedBytes Pointer to a user supplied variable that will receive the number of bytes copied by AirpcapRead.
+ Can be smaller than BufSize.
+ \return TRUE on success.
+
+ 802.11 frames are returned by the driver in buffers. Every 802.11 frame in the buffer is preceded by a \ref AirpcapBpfHeader structure.
+ The suggested way to use an AirPcap adapter is through the pcap API exported by wpcap.dll. If this is not
+ possible, the Capture_radio and Capture_no_radio examples in the AirPcap developer's pack show how to properly decode the
+ packets in the read buffer returned by AirpcapRead().
+
+ \note this function is NOT blocking. Blocking behavior can be obtained using the event returned
+ by \ref AirpcapGetReadEvent(). See also \ref AirpcapSetMinToCopy().
+*/
+BOOL AirpcapRead(PAirpcapHandle AdapterHandle, PBYTE Buffer, UINT BufSize, PUINT PReceievedBytes);
+
+/*!
+ \brief Get per-adapter WinPcap-compatible capture statistics.
+ \param AdapterHandle Handle to the adapter.
+ \param PStats pointer to a user-allocated AirpcapStats structure that will be filled with statistical information.
+ \return TRUE on success.
+*/
+BOOL AirpcapGetStats(PAirpcapHandle AdapterHandle, PAirpcapStats PStats);
+
+/*!
+ \brief Get the number of LEDs the referenced adapter has available.
+ \param AdapterHandle Handle to the adapter.
+ \param NumberOfLeds Number of LEDs available on this adapter.
+ \return TRUE on success.
+*/
+BOOL AirpcapGetLedsNumber(PAirpcapHandle AdapterHandle, PUINT NumberOfLeds);
+
+/*!
+ \brief Turn on one of the adapter's LEDs.
+ \param AdapterHandle Handle to the adapter.
+ \param LedNumber zero-based identifier of the LED to turn on.
+ \return TRUE on success.
+*/
+BOOL AirpcapTurnLedOn(PAirpcapHandle AdapterHandle, UINT LedNumber);
+
+/*!
+ \brief Turn off one of the adapter's LEDs.
+ \param AdapterHandle Handle to the adapter.
+ \param LedNumber zero-based identifier of the LED to turn off.
+ \return TRUE on success.
+*/
+BOOL AirpcapTurnLedOff(PAirpcapHandle AdapterHandle, UINT LedNumber);
+
+/*@}*/
+
+#endif /* __AIRPCAP_DRIVER__ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !defined(AIRPCAP_H__EAE405F5_0171_9592_B3C2_C19EC426AD34__INCLUDED_) */
--- /dev/null
+/* airpcap_loader.c
+ *
+ * $Id$
+ *
+ * Ulf Lamping <ulf.lamping@web.de>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 2000 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifdef _WIN32
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#ifdef HAVE_LIBPCAP
+#include <glib.h>
+#include <gmodule.h>
+
+
+#include <wtap.h>
+#include <pcap.h>
+#endif
+
+#include "capture_ui_utils.h"
+#include <epan/prefs.h>
+
+#include "simple_dialog.h"
+
+#include <airpcap.h>
+#include "airpcap_loader.h"
+
+/*
+ * We load dinamically the dag library in order link it only when
+ * it's present on the system
+ */
+static HMODULE AirpcapLib;
+
+static AirpcapGetLastErrorHandler g_PAirpcapGetLastError;
+static AirpcapGetDeviceListHandler g_PAirpcapGetDeviceList;
+static AirpcapFreeDeviceListHandler g_PAirpcapFreeDeviceList;
+static AirpcapOpenHandler g_PAirpcapOpen;
+static AirpcapCloseHandler g_PAirpcapClose;
+static AirpcapGetLinkTypeHandler g_PAirpcapGetLinkType;
+static AirpcapSetLinkTypeHandler g_PAirpcapSetLinkType;
+static AirpcapSetKernelBufferHandler g_PAirpcapSetKernelBuffer;
+static AirpcapSetFilterHandler g_PAirpcapSetFilter;
+static AirpcapGetMacAddressHandler g_PAirpcapGetMacAddress;
+static AirpcapSetMinToCopyHandler g_PAirpcapSetMinToCopy;
+static AirpcapGetReadEventHandler g_PAirpcapGetReadEvent;
+static AirpcapReadHandler g_PAirpcapRead;
+static AirpcapGetStatsHandler g_PAirpcapGetStats;
+static AirpcapTurnLedOnHandler g_PAirpcapTurnLedOn;
+static AirpcapTurnLedOffHandler g_PAirpcapTurnLedOff;
+static AirpcapGetDeviceChannelHandler g_PAirpcapGetDeviceChannel;
+static AirpcapSetDeviceChannelHandler g_PAirpcapSetDeviceChannel;
+static AirpcapGetFcsPresenceHandler g_PAirpcapGetFcsPresence;
+static AirpcapSetFcsPresenceHandler g_PAirpcapSetFcsPresence;
+static AirpcapGetFcsValidationHandler g_PAirpcapGetFcsValidation;
+static AirpcapSetFcsValidationHandler g_PAirpcapSetFcsValidation;
+static AirpcapGetDeviceKeysHandler g_PAirpcapGetDeviceKeys;
+static AirpcapSetDeviceKeysHandler g_PAirpcapSetDeviceKeys;
+static AirpcapGetDecryptionStateHandler g_PAirpcapGetDecryptionState;
+static AirpcapSetDecryptionStateHandler g_PAirpcapSetDecryptionState;
+static AirpcapStoreCurConfigAsAdapterDefaultHandler g_PAirpcapStoreCurConfigAsAdapterDefault;
+/* HAVE_AIRPCAP_API */
+
+/* Airpcap interface list */
+GList *airpcap_if_list = NULL;
+
+/* Airpcap current selected interface */
+airpcap_if_info_t *airpcap_if_selected = NULL;
+
+/* Airpcap current active interface */
+airpcap_if_info_t *airpcap_if_active = NULL;
+
+/*
+ * Get an error message string for a CANT_GET_INTERFACE_LIST error from
+ * "get_airpcap_interface_list()".
+ */
+gchar *
+cant_get_airpcap_if_list_error_message(const char *err_str)
+{
+ return g_strdup_printf("Can't get list of Wireless interfaces: %s", err_str);
+}
+
+/*
+ * Airpcap wrapper, used to store the current settings for the selected adapter
+ */
+BOOL
+airpcap_if_store_cur_config_as_adapter_default(PAirpcapHandle ah)
+{
+ return g_PAirpcapStoreCurConfigAsAdapterDefault(ah);
+}
+
+/*
+ * Airpcap wrapper, used to open an airpcap adapter
+ */
+PAirpcapHandle
+airpcap_if_open(PCHAR name, PCHAR err)
+{
+ return g_PAirpcapOpen(name,err);
+}
+
+/*
+ * Airpcap wrapper, used to close an airpcap adapter
+ */
+VOID
+airpcap_if_close(PAirpcapHandle handle)
+{
+g_PAirpcapClose(handle);
+
+}
+
+/*
+ * Airpcap wrapper, used to turn on the led of an airpcap adapter
+ */
+BOOL
+airpcap_if_turn_led_on(PAirpcapHandle AdapterHandle, UINT LedNumber)
+{
+ return g_PAirpcapTurnLedOn(AdapterHandle,LedNumber);
+}
+
+/*
+ * Airpcap wrapper, used to turn off the led of an airpcap adapter
+ */
+BOOL
+airpcap_if_turn_led_off(PAirpcapHandle AdapterHandle, UINT LedNumber)
+{
+ return g_PAirpcapTurnLedOff(AdapterHandle,LedNumber);
+}
+
+/*
+ * Airpcap wrapper, used to get the channel of an airpcap adapter
+ */
+BOOL
+airpcap_if_get_device_channel(PAirpcapHandle ah, PUINT ch)
+{
+ return g_PAirpcapGetDeviceChannel(ah,ch);
+}
+
+/*
+ * Airpcap wrapper, used to set the channel of an airpcap adapter
+ */
+BOOL
+airpcap_if_set_device_channel(PAirpcapHandle ah, UINT ch)
+{
+ return g_PAirpcapSetDeviceChannel(ah,ch);
+}
+
+/*
+ * Airpcap wrapper, used to get the link type of an airpcap adapter
+ */
+BOOL
+airpcap_if_get_link_type(PAirpcapHandle ah, PAirpcapLinkType lt)
+{
+ return g_PAirpcapGetLinkType(ah,lt);
+}
+
+/*
+ * Airpcap wrapper, used to set the link type of an airpcap adapter
+ */
+BOOL
+airpcap_if_set_link_type(PAirpcapHandle ah, AirpcapLinkType lt)
+{
+ return g_PAirpcapSetLinkType(ah,lt);
+}
+
+/*
+ * Airpcap wrapper, used to get the fcs presence of an airpcap adapter
+ */
+BOOL
+airpcap_if_get_fcs_presence(PAirpcapHandle ah, PBOOL fcs)
+{
+ return g_PAirpcapGetFcsPresence(ah,fcs);
+}
+
+/*
+ * Airpcap wrapper, used to set the fcs presence of an airpcap adapter
+ */
+BOOL
+airpcap_if_set_fcs_presence(PAirpcapHandle ah, BOOL fcs)
+{
+ return g_PAirpcapSetFcsPresence(ah,fcs);
+}
+
+/*
+ * Airpcap wrapper, used to get the decryption enabling of an airpcap adapter
+ */
+BOOL
+airpcap_if_get_decryption_state(PAirpcapHandle ah, PAirpcapDecryptionState PEnable)
+{
+ return g_PAirpcapGetDecryptionState(ah,PEnable);
+}
+
+/*
+ * Airpcap wrapper, used to set the decryption enabling of an airpcap adapter
+ */
+BOOL
+airpcap_if_set_decryption_state(PAirpcapHandle ah, AirpcapDecryptionState Enable)
+{
+ return g_PAirpcapSetDecryptionState(ah,Enable);
+}
+
+/*
+ * Airpcap wrapper, used to get the fcs validation of an airpcap adapter
+ */
+BOOL
+airpcap_if_get_fcs_validation(PAirpcapHandle ah, PAirpcapValidationType val)
+{
+ return g_PAirpcapGetFcsValidation(ah,val);
+}
+
+/*
+ * Airpcap wrapper, used to set the fcs validation of an airpcap adapter
+ */
+BOOL
+airpcap_if_set_fcs_validation(PAirpcapHandle ah, AirpcapValidationType val)
+{
+ return g_PAirpcapSetFcsValidation(ah,val);
+}
+
+/*
+ * Airpcap wrapper, used to save the settings for the selected_if
+ */
+BOOL
+airpcap_if_set_device_keys(PAirpcapHandle AdapterHandle, PAirpcapKeysCollection KeysCollection)
+{
+ return g_PAirpcapSetDeviceKeys(AdapterHandle,KeysCollection);
+}
+
+/*
+ * Airpcap wrapper, used to save the settings for the selected_if
+ */
+BOOL
+airpcap_if_get_device_keys(PAirpcapHandle AdapterHandle, PAirpcapKeysCollection KeysCollection, PUINT PKeysCollectionSize)
+{
+ return g_PAirpcapGetDeviceKeys(AdapterHandle,KeysCollection,PKeysCollectionSize);
+}
+
+/*
+ * This function will create a new airpcap_if_info_t using a name and a description
+ */
+airpcap_if_info_t *
+airpcap_if_info_new(char *name, char *description)
+{
+PAirpcapHandle ad;
+char* ebuf = NULL;
+
+ airpcap_if_info_t *if_info;
+
+ if_info = g_malloc(sizeof (airpcap_if_info_t));
+ if_info->name = g_strdup(name);
+ if (description == NULL)
+ if_info->description = NULL;
+ else
+ if_info->description = g_strdup(description);
+ if_info->ip_addr = NULL;
+ if_info->loopback = FALSE;
+
+ /* Probably I have to switch on the leds!!! */
+ ad = airpcap_if_open(if_info->name, ebuf);
+ if(ad)
+ {
+ airpcap_if_get_fcs_validation(ad,&(if_info->CrcValidationOn));
+ airpcap_if_get_fcs_presence(ad,&(if_info->IsFcsPresent));
+ airpcap_if_get_link_type(ad,&(if_info->linkType));
+ airpcap_if_get_device_channel(ad,&(if_info->channel));
+ airpcap_if_turn_led_on(ad, 0);
+ airpcap_if_get_decryption_state(ad, &(if_info->DecryptionOn));
+ if_info->led = TRUE;
+ if_info->blinking = FALSE;
+ if_info->saved = TRUE; /* NO NEED TO BE SAVED */
+
+ /* get the keys, if everything is ok, close the adapter */
+ if(airpcap_if_load_keys(ad,if_info))
+ airpcap_if_close(ad);
+ }
+ return if_info;
+}
+
+/*
+ * Function used to load the WEP keys for a selected interface
+ */
+BOOL
+airpcap_if_load_keys(PAirpcapHandle ad, airpcap_if_info_t *if_info)
+{
+if_info->keysCollectionSize = 0;
+if_info->keysCollection = NULL;
+
+if(!airpcap_if_get_device_keys(ad, NULL, &(if_info->keysCollectionSize)))
+ {
+ if(if_info->keysCollectionSize == 0)
+ {
+ if_info->keysCollection = NULL;
+ airpcap_if_close(ad);
+ return FALSE;
+ }
+
+ if_info->keysCollection = (PAirpcapKeysCollection)malloc(if_info->keysCollectionSize);
+ if(!if_info->keysCollection)
+ {
+ if_info->keysCollectionSize = 0;
+ if_info->keysCollection = NULL;
+ airpcap_if_close(ad);
+ return FALSE;
+ }
+
+ airpcap_if_get_device_keys(ad, if_info->keysCollection, &(if_info->keysCollectionSize));
+ return TRUE;
+ }
+airpcap_if_close(ad);
+return FALSE;
+}
+
+/*
+ * Function used to save the WEP keys for a selected interface
+ */
+void
+airpcap_if_save_keys(PAirpcapHandle ad, airpcap_if_info_t *if_info)
+{
+ if(if_info->keysCollection != NULL)
+ g_PAirpcapSetDeviceKeys(ad,if_info->keysCollection);
+}
+
+/*
+ * Callback used to free an instance of airpcap_if_info_t
+ */
+static void
+free_airpcap_if_cb(gpointer data, gpointer user_data _U_)
+{
+ airpcap_if_info_t *if_info = data;
+
+ if (if_info->name != NULL)
+ g_free(if_info->name);
+
+ if (if_info->description != NULL)
+ g_free(if_info->description);
+
+ /* XXX - FREE THE WEP KEY LIST HERE!!!*/
+ if(if_info->keysCollection != NULL)
+ g_free(if_info->keysCollection);
+
+ if(if_info->ip_addr != NULL)
+ g_slist_free(if_info->ip_addr);
+
+ if(if_info != NULL)
+ g_free(if_info);
+}
+
+/*
+ * Function used to free the airpcap interface list
+ */
+void
+free_airpcap_interface_list(GList *if_list)
+{
+ g_list_foreach(if_list, free_airpcap_if_cb, NULL);
+ g_list_free(if_list);
+ if_list = NULL;
+}
+
+/*
+ * This function will use the airpcap.dll to find all the airpcap devices.
+ * Will return null if no device is found.
+ */
+GList*
+get_airpcap_interface_list(int *err, char *err_str)
+{
+ GList *il = NULL;
+ airpcap_if_info_t *if_info;
+ int i, n_adapts;
+ AirpcapDeviceDescription *devsList, *adListEntry;
+
+ if(!g_PAirpcapGetDeviceList(&devsList, err_str))
+ {
+ /* No interfaces, return il = NULL; */
+ *err = NO_AIRPCAP_INTERFACES_FOUND;
+ return il;
+ }
+
+ /*
+ * Count the adapters
+ */
+ adListEntry = devsList;
+ n_adapts = 0;
+ while(adListEntry)
+ {
+ n_adapts++;
+ adListEntry = adListEntry->next;
+ }
+
+ if(n_adapts == 0)
+ {
+ /* No interfaces, return il= NULL */
+ g_PAirpcapFreeDeviceList(devsList);
+ *err = NO_AIRPCAP_INTERFACES_FOUND;
+ return il;
+ }
+
+ /*
+ * Insert the adapters in our list
+ */
+ adListEntry = devsList;
+ for(i = 0; i < n_adapts; i++)
+ {
+ if_info = airpcap_if_info_new(adListEntry->Name, adListEntry->Description);
+ il = g_list_append(il, if_info);
+
+ adListEntry = adListEntry->next;
+ }
+
+ g_PAirpcapFreeDeviceList(devsList);
+
+ return il;
+}
+
+/*
+ * Used to retrieve the name of the interface given the description
+ * (the name is used in AirpcapOpen, the description is put in the combo box)
+ */
+gchar* get_airpcap_name_from_description(GList* if_list, gchar* description)
+{
+unsigned int ifn;
+GList* curr;
+airpcap_if_info_t* if_info;
+
+ifn = 0;
+if(if_list != NULL)
+ {
+ while( ifn < g_list_length(if_list) )
+ {
+ curr = g_list_nth(if_list, ifn);
+
+ if_info = NULL;
+ if(curr != NULL)
+ if_info = curr->data;
+ if(if_info != NULL)
+ if ( g_ascii_strcasecmp(if_info->description,description) == 0)
+ {
+ return if_info->name;
+ }
+ ifn++;
+ }
+ }
+return NULL;
+}
+
+/*
+ * Used to retrieve the interface given the name
+ * (the name is used in AirpcapOpen)
+ */
+airpcap_if_info_t* get_airpcap_if_by_name(GList* if_list, const gchar* name)
+{
+unsigned int ifn;
+GList* curr;
+airpcap_if_info_t* if_info;
+
+ifn = 0;
+if(if_list != NULL)
+ {
+ while( ifn < g_list_length(if_list) )
+ {
+ curr = g_list_nth(if_list, ifn);
+
+ if_info = NULL;
+ if(curr != NULL)
+ if_info = curr->data;
+ if(if_info != NULL)
+ if ( g_ascii_strcasecmp(if_info->name,name) == 0)
+ {
+ return if_info;
+ }
+ ifn++;
+ }
+ }
+return NULL;
+}
+
+/*
+ * Returns the ASCII string of a key given the key bites
+ */
+gchar*
+airpcap_get_key_string(AirpcapKey key)
+{
+unsigned int j = 0;
+gchar *s,*s1;
+
+s = NULL;
+s1 = NULL;
+
+if(key.KeyType == AIRPCAP_KEYTYPE_WEP)
+ {
+ s = g_strdup_printf("");
+ for(j = 0; j < key.KeyLen != 0; j++)
+ {
+ s1 = g_strdup_printf("%.2x", key.KeyData[j]);
+ g_strlcat(s,s1,WEP_KEY_MAX_SIZE);
+ }
+ }
+return s;
+}
+
+/*
+ * Used to retrieve the airpcap_if_info_t of the selected interface given the
+ * description (that is the entry of the combo box).
+ */
+gpointer get_airpcap_if_from_description(GList* if_list, const gchar* description)
+{
+unsigned int ifn;
+GList* curr;
+airpcap_if_info_t* if_info;
+
+ifn = 0;
+if(if_list != NULL)
+ {
+ while( ifn < g_list_length(if_list) )
+ {
+ curr = g_list_nth(if_list, ifn);
+
+ if_info = NULL;
+ if(curr != NULL)
+ if_info = curr->data;
+ if(if_info != NULL)
+ if ( g_ascii_strcasecmp(if_info->description,description) == 0)
+ {
+ return if_info;
+ }
+ ifn++;
+ }
+ }
+return NULL;
+}
+
+/*
+ * Used to retrieve the two chars string from interface
+ */
+gchar*
+airpcap_get_if_string_number(airpcap_if_info_t* if_info)
+{
+ gchar* number;
+ guint n;
+ int a;
+
+ a = sscanf(if_info->name,AIRPCAP_DEVICE_NUMBER_EXTRACT_STRING,&n);
+
+ number = g_strdup_printf("%.2u\0",n);
+
+ return number;
+}
+
+/*
+ * Used to retrieve the two chars string from interface
+ */
+gchar*
+airpcap_get_if_string_number_from_description(gchar* description)
+{
+ gchar* number;
+ gchar* pointer;
+
+ number = (gchar*)g_malloc(sizeof(gchar)*3);
+
+ pointer = g_strrstr(description,"#\0");
+
+ number[0] = *(pointer+1);
+ number[1] = *(pointer+2);
+ number[2] = '\0';
+
+ return number;
+}
+
+/*
+ * Returns the default airpcap interface of a list, NULL if list is empty
+ */
+airpcap_if_info_t*
+airpcap_get_default_if(GList* airpcap_if_list)
+{
+int ifn = 0;
+GList* popdown_if_list = NULL;
+GList* curr = NULL;
+
+ gchar* s;
+ airpcap_if_info_t* if_info;
+
+ s = g_strdup(get_if_name(prefs.capture_device));
+ if_info = get_airpcap_if_by_name(airpcap_if_list,g_strdup(get_if_name(prefs.capture_device)));
+ g_free(s);
+ return if_info;
+}
+
+/*
+ * Load the configuration for the specified interface
+ */
+void
+airpcap_load_selected_if_configuration(airpcap_if_info_t* if_info)
+{
+gchar ebuf[AIRPCAP_ERRBUF_SIZE];
+PAirpcapHandle ad;
+
+if(if_info != NULL)
+ {
+ ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list, if_info->description), ebuf);
+
+ if(ad)
+ {
+ /* Stop blinking (if it was blinkig!)*/
+ if(if_info->blinking)
+ {
+ /* Turn on the light (if it was off) */
+ if(!(if_info->led)) airpcap_if_turn_led_on(ad, 0);
+ }
+
+ /* Apply settings... */
+ airpcap_if_get_device_channel(ad,&(if_info->channel));
+ airpcap_if_get_fcs_validation(ad,&(if_info->CrcValidationOn));
+ airpcap_if_get_fcs_presence(ad,&(if_info->IsFcsPresent));
+ airpcap_if_get_link_type(ad,&(if_info->linkType));
+ airpcap_if_get_decryption_state(ad, &(if_info->DecryptionOn));
+ /* get the keys, if everything is ok, close the adapter */
+ if(airpcap_if_load_keys(ad,if_info))
+ airpcap_if_close(ad);
+
+ if_info->saved = TRUE;
+ }
+ else
+ {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, " Error in opening adapter for %s",if_info->description);
+ }
+ }
+}
+
+/*
+ * Save the configuration for the specified interface
+ */
+void
+airpcap_save_selected_if_configuration(airpcap_if_info_t* if_info)
+{
+gchar ebuf[AIRPCAP_ERRBUF_SIZE];
+PAirpcapHandle ad;
+
+if(if_info != NULL)
+ {
+ ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list, if_info->description), ebuf);
+
+ if(ad)
+ {
+ /* Stop blinking (if it was blinkig!)*/
+ if(if_info->blinking)
+ {
+ /* Turn on the light (if it was off) */
+ if(!(if_info->led)) airpcap_if_turn_led_on(ad, 0);
+ }
+
+ /* Apply settings... */
+ airpcap_if_set_device_channel(ad,if_info->channel);
+ airpcap_if_set_fcs_validation(ad,if_info->CrcValidationOn);
+ airpcap_if_set_fcs_presence(ad,if_info->IsFcsPresent);
+ airpcap_if_set_link_type(ad,if_info->linkType);
+ airpcap_if_set_decryption_state(ad, if_info->DecryptionOn);
+ airpcap_if_save_keys(ad,if_info);
+
+ /* ... and save them */
+ if(!airpcap_if_store_cur_config_as_adapter_default(ad))
+ {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Cannot save Wireless configuration!!!\nRemember that in order to store the configuration in the registry you have to:\n\n- Close all the airpcap-based applications.\n- Be sure to have administrative privileges.");
+ if_info->saved = FALSE;
+ airpcap_if_close(ad);
+ return;
+ }
+
+ if_info->saved = TRUE;
+ airpcap_if_close(ad);
+ }
+ else
+ {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, " Error in opening adapter for %s",if_info->description);
+ }
+ }
+}
+
+/*
+ * Used to dinamically load the airpcap library in order link it only when
+ * it's present on the system
+ */
+BOOL load_airpcap(void)
+{
+ if((AirpcapLib = LoadLibrary(TEXT("airpcap.dll"))) == NULL)
+ {
+ /* Report the error but go on */
+ return FALSE;
+ }
+ else
+ {
+ if((g_PAirpcapGetLastError = (AirpcapGetLastErrorHandler) GetProcAddress(AirpcapLib, "AirpcapGetLastError")) == NULL) return FALSE;
+ if((g_PAirpcapGetDeviceList = (AirpcapGetDeviceListHandler) GetProcAddress(AirpcapLib, "AirpcapGetDeviceList")) == NULL) return FALSE;
+ if((g_PAirpcapFreeDeviceList = (AirpcapFreeDeviceListHandler) GetProcAddress(AirpcapLib, "AirpcapFreeDeviceList")) == NULL) return FALSE;
+ if((g_PAirpcapOpen = (AirpcapOpenHandler) GetProcAddress(AirpcapLib, "AirpcapOpen")) == NULL) return FALSE;
+ if((g_PAirpcapClose = (AirpcapCloseHandler) GetProcAddress(AirpcapLib, "AirpcapClose")) == NULL) return FALSE;
+ if((g_PAirpcapGetLinkType = (AirpcapGetLinkTypeHandler) GetProcAddress(AirpcapLib, "AirpcapGetLinkType")) == NULL) return FALSE;
+ if((g_PAirpcapSetLinkType = (AirpcapSetLinkTypeHandler) GetProcAddress(AirpcapLib, "AirpcapSetLinkType")) == NULL) return FALSE;
+ if((g_PAirpcapSetKernelBuffer = (AirpcapSetKernelBufferHandler) GetProcAddress(AirpcapLib, "AirpcapSetKernelBuffer")) == NULL) return FALSE;
+ if((g_PAirpcapSetFilter = (AirpcapSetFilterHandler) GetProcAddress(AirpcapLib, "AirpcapSetFilter")) == NULL) return FALSE;
+ if((g_PAirpcapGetMacAddress = (AirpcapGetMacAddressHandler) GetProcAddress(AirpcapLib, "AirpcapGetMacAddress")) == NULL) return FALSE;
+ if((g_PAirpcapSetMinToCopy = (AirpcapSetMinToCopyHandler) GetProcAddress(AirpcapLib, "AirpcapSetMinToCopy")) == NULL) return FALSE;
+ if((g_PAirpcapGetReadEvent = (AirpcapGetReadEventHandler) GetProcAddress(AirpcapLib, "AirpcapGetReadEvent")) == NULL) return FALSE;
+ if((g_PAirpcapRead = (AirpcapReadHandler) GetProcAddress(AirpcapLib, "AirpcapRead")) == NULL) return FALSE;
+ if((g_PAirpcapGetStats = (AirpcapGetStatsHandler) GetProcAddress(AirpcapLib, "AirpcapGetStats")) == NULL) return FALSE;
+ if((g_PAirpcapTurnLedOn = (AirpcapTurnLedOnHandler) GetProcAddress(AirpcapLib, "AirpcapTurnLedOn")) == NULL) return FALSE;
+ if((g_PAirpcapTurnLedOff = (AirpcapTurnLedOffHandler) GetProcAddress(AirpcapLib, "AirpcapTurnLedOff")) == NULL) return FALSE;
+ if((g_PAirpcapGetDeviceChannel = (AirpcapGetDeviceChannelHandler) GetProcAddress(AirpcapLib, "AirpcapGetDeviceChannel")) == NULL) return FALSE;
+ if((g_PAirpcapSetDeviceChannel = (AirpcapSetDeviceChannelHandler) GetProcAddress(AirpcapLib, "AirpcapSetDeviceChannel")) == NULL) return FALSE;
+ if((g_PAirpcapGetFcsPresence = (AirpcapGetFcsPresenceHandler) GetProcAddress(AirpcapLib, "AirpcapGetFcsPresence")) == NULL) return FALSE;
+ if((g_PAirpcapSetFcsPresence = (AirpcapSetFcsPresenceHandler) GetProcAddress(AirpcapLib, "AirpcapSetFcsPresence")) == NULL) return FALSE;
+ if((g_PAirpcapGetFcsValidation = (AirpcapGetFcsValidationHandler) GetProcAddress(AirpcapLib, "AirpcapGetFcsValidation")) == NULL) return FALSE;
+ if((g_PAirpcapSetFcsValidation = (AirpcapSetFcsValidationHandler) GetProcAddress(AirpcapLib, "AirpcapSetFcsValidation")) == NULL) return FALSE;
+ if((g_PAirpcapGetDeviceKeys = (AirpcapGetDeviceKeysHandler) GetProcAddress(AirpcapLib, "AirpcapGetDeviceKeys")) == NULL) return FALSE;
+ if((g_PAirpcapSetDeviceKeys = (AirpcapSetDeviceKeysHandler) GetProcAddress(AirpcapLib, "AirpcapSetDeviceKeys")) == NULL) return FALSE;
+ if((g_PAirpcapGetDecryptionState = (AirpcapGetDecryptionStateHandler) GetProcAddress(AirpcapLib, "AirpcapGetDecryptionState")) == NULL) return FALSE;
+ if((g_PAirpcapSetDecryptionState = (AirpcapSetDecryptionStateHandler) GetProcAddress(AirpcapLib, "AirpcapSetDecryptionState")) == NULL) return FALSE;
+ if((g_PAirpcapStoreCurConfigAsAdapterDefault = (AirpcapStoreCurConfigAsAdapterDefaultHandler) GetProcAddress(AirpcapLib, "AirpcapStoreCurConfigAsAdapterDefault")) == NULL) return FALSE;
+ return TRUE;
+ }
+}
+
+#endif /* _WIN32 */
--- /dev/null
+/* airpcap_loader.h
+ * Declarations of routines for the "About" dialog
+ *
+ * $Id$
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __AIRPCAP_LOADER_H__
+#define __AIRPCAP_LOADER_H__
+
+/* Error values from "get_airpcap_interface_list()". */
+#define CANT_GET_AIRPCAP_INTERFACE_LIST 0 /* error getting list */
+#define NO_AIRPCAP_INTERFACES_FOUND 1 /* list is empty */
+
+#define MAX_ENCRYPTION_KEYS 64
+
+typedef PCHAR (*AirpcapGetLastErrorHandler)(PAirpcapHandle AdapterHandle);
+typedef BOOL (*AirpcapGetDeviceListHandler)(PAirpcapDeviceDescription *PPAllDevs, PCHAR Ebuf);
+typedef VOID (*AirpcapFreeDeviceListHandler)(PAirpcapDeviceDescription PAllDevs);
+typedef PAirpcapHandle (*AirpcapOpenHandler)(PCHAR DeviceName, PCHAR Ebuf);
+typedef VOID (*AirpcapCloseHandler)(PAirpcapHandle AdapterHandle);
+typedef BOOL (*AirpcapGetLinkTypeHandler)(PAirpcapHandle AdapterHandle, PAirpcapLinkType PLinkType);
+typedef BOOL (*AirpcapSetLinkTypeHandler)(PAirpcapHandle AdapterHandle, AirpcapLinkType NewLinkType);
+typedef BOOL (*AirpcapSetKernelBufferHandler)(PAirpcapHandle AdapterHandle, UINT BufferSize);
+typedef BOOL (*AirpcapSetFilterHandler)(PAirpcapHandle AdapterHandle, PVOID Instructions, UINT Len);
+typedef BOOL (*AirpcapGetMacAddressHandler)(PAirpcapHandle AdapterHandle, PAirpcapMacAddress PMacAddress);
+typedef BOOL (*AirpcapSetMinToCopyHandler)(PAirpcapHandle AdapterHandle, UINT MinToCopy);
+typedef BOOL (*AirpcapGetReadEventHandler)(PAirpcapHandle AdapterHandle, HANDLE* PReadEvent);
+typedef BOOL (*AirpcapReadHandler)(PAirpcapHandle AdapterHandle, PBYTE Buffer, UINT BufSize, PUINT PReceievedBytes);
+typedef BOOL (*AirpcapGetStatsHandler)(PAirpcapHandle AdapterHandle, PAirpcapStats PStats);
+typedef BOOL (*AirpcapTurnLedOnHandler)(PAirpcapHandle AdapterHandle, UINT LedNumber);
+typedef BOOL (*AirpcapTurnLedOffHandler)(PAirpcapHandle AdapterHandle, UINT LedNumber);
+typedef BOOL (*AirpcapSetDeviceChannelHandler)(PAirpcapHandle AdapterHandle, UINT Channel);
+typedef BOOL (*AirpcapGetDeviceChannelHandler)(PAirpcapHandle AdapterHandle, PUINT PChannel);
+typedef BOOL (*AirpcapSetFcsPresenceHandler)(PAirpcapHandle AdapterHandle, BOOL IsFcsPresent);
+typedef BOOL (*AirpcapGetFcsPresenceHandler)(PAirpcapHandle AdapterHandle, PBOOL PIsFcsPresent);
+typedef BOOL (*AirpcapSetFcsValidationHandler)(PAirpcapHandle AdapterHandle, AirpcapValidationType ValidationType);
+typedef BOOL (*AirpcapGetFcsValidationHandler)(PAirpcapHandle AdapterHandle, PAirpcapValidationType PValidationType);
+typedef BOOL (*AirpcapSetDeviceKeysHandler)(PAirpcapHandle AdapterHandle, PAirpcapKeysCollection KeysCollection);
+typedef BOOL (*AirpcapGetDeviceKeysHandler)(PAirpcapHandle AdapterHandle, PAirpcapKeysCollection KeysCollection, PUINT PKeysCollectionSize);
+typedef BOOL (*AirpcapSetDecryptionStateHandler)(PAirpcapHandle AdapterHandle, AirpcapDecryptionState Enable);
+typedef BOOL (*AirpcapGetDecryptionStateHandler)(PAirpcapHandle AdapterHandle, PAirpcapDecryptionState PEnable);
+typedef BOOL (*AirpcapStoreCurConfigAsAdapterDefaultHandler)(PAirpcapHandle AdapterHandle);
+/*
+ * The list of interfaces returned by "get_airpcap_interface_list()" is
+ * a list of these structures.
+ */
+typedef struct {
+ char *name; /* e.g. "eth0" */
+ char *description; /* from OS, e.g. "Local Area Connection" or NULL */
+ GSList *ip_addr; /* containing address values of if_addr_t */
+ gboolean loopback; /* TRUE if loopback, FALSE otherwise */
+ AirpcapLinkType linkType; /* The link layer type*/
+ UINT channel; /* Channel (1-14)*/
+ BOOL IsFcsPresent; /* Include 802.11 CRC in frames */
+ AirpcapValidationType CrcValidationOn; /* Capture Frames with Wrong CRC */
+ AirpcapDecryptionState DecryptionOn; /* TRUE if decryption is on, FALSE otherwise*/
+ PAirpcapKeysCollection keysCollection; /* WEP Key collection for the adapter */
+ UINT keysCollectionSize; /* Size of the key collection */
+ gboolean blinking; /* TRUE if is blinkng, FALSE otherwise*/
+ gboolean led; /* TRUE if on, FALSE if off*/
+ gboolean saved; /* TRUE if current configuration has been saved, FALSE otherwise */
+ gint tag; /* int for the gtk blinking callback */
+} airpcap_if_info_t;
+
+/* Airpcap interface list */
+extern GList *airpcap_if_list;
+
+/* Airpcap current selected interface */
+extern airpcap_if_info_t *airpcap_if_selected;
+
+/* Airpcap current active interface */
+extern airpcap_if_info_t *airpcap_if_active;
+
+/*
+ * Callback used to free an instance of airpcap_if_info_t
+ */
+static void
+free_airpcap_if_cb(gpointer data, gpointer user_data _U_);
+
+/*
+ * Used to retrieve the two chars string from interface
+ */
+gchar*
+airpcap_get_if_string_number_from_description(gchar* description);
+
+/*
+ * Function used to free the airpcap interface list
+ */
+void
+free_airpcap_interface_list(GList *if_list);
+
+/*
+ * Used to retrieve the interface given the name
+ * (the name is used in AirpcapOpen)
+ */
+airpcap_if_info_t* get_airpcap_if_by_name(GList* if_list, const gchar* name);
+
+/*
+ * Airpcap wrapper, used to store the current settings for the selected adapter
+ */
+BOOL
+airpcap_if_store_cur_config_as_adapter_default(PAirpcapHandle ah);
+
+/*
+ * Function used to load the WEP keys for a selected interface
+ */
+BOOL
+airpcap_if_load_keys(PAirpcapHandle ad, airpcap_if_info_t *if_info);
+
+/*
+ * Function used to save the WEP keys for a selected interface
+ */
+void
+airpcap_if_save_keys(PAirpcapHandle ad, airpcap_if_info_t *if_info);
+
+/*
+ * Airpcap wrapper, used to get the fcs validation of an airpcap adapter
+ */
+BOOL
+airpcap_if_get_fcs_validation(PAirpcapHandle ah, PAirpcapValidationType val);
+
+/*
+ * Airpcap wrapper, used to set the fcs validation of an airpcap adapter
+ */
+BOOL
+airpcap_if_set_fcs_validation(PAirpcapHandle ah, AirpcapValidationType val);
+
+/*
+ * Airpcap wrapper, used to get the decryption enabling of an airpcap adapter
+ */
+BOOL
+airpcap_if_get_decryption_state(PAirpcapHandle ah, PAirpcapDecryptionState val);
+
+/*
+ * Airpcap wrapper, used to set the decryption enabling of an airpcap adapter
+ */
+BOOL
+airpcap_if_set_decryption_state(PAirpcapHandle ah, AirpcapDecryptionState val);
+
+/*
+ * Airpcap wrapper, used to get the fcs presence of an airpcap adapter
+ */
+BOOL
+airpcap_if_get_fcs_presence(PAirpcapHandle ah, PBOOL ch);
+
+/*
+ * Airpcap wrapper, used to set the fcs presence of an airpcap adapter
+ */
+BOOL
+airpcap_if_set_fcs_presence(PAirpcapHandle ah, BOOL ch);
+
+/*
+ * Airpcap wrapper, used to get the link type of an airpcap adapter
+ */
+BOOL
+airpcap_if_get_link_type(PAirpcapHandle ah, PAirpcapLinkType lt);
+
+/*
+ * Airpcap wrapper, used to set the link type of an airpcap adapter
+ */
+BOOL
+airpcap_if_set_link_type(PAirpcapHandle ah, AirpcapLinkType lt);
+
+/*
+ * Airpcap wrapper, used to get the channel of an airpcap adapter
+ */
+BOOL
+airpcap_if_get_device_channel(PAirpcapHandle ah, PUINT ch);
+
+/*
+ * Airpcap wrapper, used to set the channel of an airpcap adapter
+ */
+BOOL
+airpcap_if_set_device_channel(PAirpcapHandle ah, UINT ch);
+
+/*
+ * Airpcap wrapper, used to open an airpcap adapter
+ */
+PAirpcapHandle airpcap_if_open(PCHAR name, PCHAR err);
+
+/*
+ * Airpcap wrapper, used to close an airpcap adapter
+ */
+VOID airpcap_if_close(PAirpcapHandle handle);
+
+/*
+ * Airpcap wrapper, used to turn on the led of an airpcap adapter
+ */
+BOOL airpcap_if_turn_led_on(PAirpcapHandle AdapterHandle, UINT LedNumber);
+
+/*
+ * Airpcap wrapper, used to turn off the led of an airpcap adapter
+ */
+BOOL airpcap_if_turn_led_off(PAirpcapHandle AdapterHandle, UINT LedNumber);
+
+/*
+ * This function will create a new airpcap_if_info_t using a name and a description
+ */
+airpcap_if_info_t* airpcap_if_info_new(char *name, char *description);
+
+/* HAVE_AIRPCAP_API */
+
+/*
+ * Used to dinamically load the airpcap library in order link it only when
+ * it's present on the system.
+ */
+BOOL load_airpcap(void);
+
+/*
+ * Get an error message string for a CANT_GET_INTERFACE_LIST error from
+ * "get_airpcap_interface_list()".
+ */
+gchar*
+cant_get_airpcap_if_list_error_message(const char *err_str);
+
+/*
+ * This function will use the airpcap.dll to find all the airpcap devices.
+ * Will return null if no device is found.
+ */
+GList*
+get_airpcap_interface_list(int *err, char *err_str);
+
+/*
+ * Returns the ASCII string of a key given the key bites
+ */
+gchar*
+airpcap_get_key_string(AirpcapKey key);
+
+/*
+ * Load the configuration for the specified interface
+ */
+void
+airpcap_load_selected_if_configuration(airpcap_if_info_t* if_info);
+
+/*
+ * Save the configuration for the specified interface
+ */
+void
+airpcap_save_selected_if_configuration(airpcap_if_info_t* if_info);
+
+/*
+ * Used to retrieve the name of the interface given the description
+ * (the name is used in AirpcapOpen, the description is put in the combo box)
+ */
+gchar*
+get_airpcap_name_from_description(GList* if_list, gchar* description);
+
+/*
+ * Used to retrieve the airpcap_if_info_t of the selected interface given the
+ * description (that is the entry of the combo box).
+ */
+gpointer
+get_airpcap_if_from_description(GList* if_list, const gchar* description);
+
+/*
+ * Used to retrieve the two chars string from interface description
+ */
+gchar*
+airpcap_get_if_string_number(airpcap_if_info_t* if_info);
+
+/*
+ * Returns the default airpcap interface of a list, NULL if list is empty
+ */
+airpcap_if_info_t*
+airpcap_get_default_if(GList* airpcap_if_list);
+
+/*
+ * Airpcap wrapper, used to save the settings for the selected_if
+ */
+BOOL
+airpcap_if_set_device_keys(PAirpcapHandle AdapterHandle, PAirpcapKeysCollection KeysCollection);
+
+/*
+ * Airpcap wrapper, used to save the settings for the selected_if
+ */
+BOOL
+airpcap_if_get_device_keys(PAirpcapHandle AdapterHandle, PAirpcapKeysCollection KeysCollection, PUINT PKeysCollectionSize);
+#endif
@WPCAP_CONSTIFIED@
@HAVE_LIBWIRESHARKDLL@
+@HAVE_AIRPCAP@
+
/* availability of pcap_freecode() is handled at runtime */
#define HAVE_PCAP_FREECODE 1
# If you're not building with WinPcap at all, don't set it (comment
# out or remove the line that sets it).
#
-WINPCAP_VERSION=3.1
+WINPCAP_VERSION=4.0
#
# Directory, where your User's Guide reside, relative to the source dir.
PDB_FILE=vc*.pdb
# Set up the path to the cygwin binaries
-CYGWIN_PATH=c:\cygwin\bin
+CYGWIN_PATH=c:\Programmi\cygwin\bin
# Set up the path to some required DLLs
DLL_PATH=$(GLIB_DIR)\bin;$(GETTEXT_DIR)\bin;$(ICONV_DIR)\bin
POD2HTML=$(SH) pod2html
# command for python (native windows version)
-#PYTHON="C:/python23/python.exe"
+PYTHON="C:/Programmi/python24/python.exe"
# add native python to the path (not needed if cygwin's python is used)
-#PATH=c:\python23;$(PATH)
+PATH=c:\Programmi\python24;$(PATH)
# command for python (typically cygwin's python package)
PYTHON=env python
PANGO_LIB_DIR=1.2.0
!ENDIF
+# Enable / disable AirPcap support
+
+# AIRPCAP_CONFIG=^#define HAVE_AIRPCAP 1
+AIRPCAP_CONFIG=
!IFDEF WINPCAP_VERSION
# Nmake uses carets to escape special characters
IEEE80211_RADIOTAP_ANTENNA = 11,
IEEE80211_RADIOTAP_DB_ANTSIGNAL = 12,
IEEE80211_RADIOTAP_DB_ANTNOISE = 13,
+ IEEE80211_RADIOTAP_FCS = 14,
IEEE80211_RADIOTAP_EXT = 31
};
static int hf_radiotap_db_antnoise = -1;
static int hf_radiotap_txpower = -1;
static int hf_radiotap_preamble = -1;
-static int hf_radiotap_fcs = -1;
+static int hf_radiotap_flags_fcs = -1;
static int hf_radiotap_datapad = -1;
+static int hf_radiotap_quality = -1;
+static int hf_radiotap_fcs = -1;
static gint ett_radiotap = -1;
static gint ett_radiotap_present = -1;
FT_UINT32, BASE_DEC, VALS(preamble_type), 0x0, "", HFILL } },
/* XXX for debugging */
- { &hf_radiotap_fcs,
+ { &hf_radiotap_flags_fcs,
{ "FCS", "radiotap.flags.fcs",
FT_UINT32, BASE_DEC, VALS(truefalse_type), 0x0, "", HFILL } },
{ &hf_radiotap_datapad,
{ &hf_radiotap_mactime,
{ "MAC timestamp", "radiotap.mactime",
FT_UINT64, BASE_DEC, NULL, 0x0, "", HFILL } },
+ { &hf_radiotap_quality,
+ { "Signal Quality", "radiotap.quality",
+ FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL } },
+ { &hf_radiotap_fcs,
+ { "802.11 FCS", "radiotap.fcs",
+ FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL } },
{ &hf_radiotap_channel_frequency,
{ "Channel frequency", "radiotap.channel.freq",
FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL } },
guint8 db, rflags;
guint32 present, next_present;
int bit;
+ gboolean has_fcs = FALSE;
if(check_col(pinfo->cinfo, COL_PROTOCOL))
col_set_str(pinfo->cinfo, COL_PROTOCOL, "WLAN");
if (tree) {
proto_tree_add_uint(radiotap_tree, hf_radiotap_preamble,
tvb, 0, 0, (rflags&IEEE80211_RADIOTAP_F_SHORTPRE) != 0);
- proto_tree_add_uint(radiotap_tree, hf_radiotap_fcs,
+ proto_tree_add_uint(radiotap_tree, hf_radiotap_flags_fcs,
tvb, 0, 0, (rflags&IEEE80211_RADIOTAP_F_FCS) != 0);
proto_tree_add_uint(radiotap_tree, hf_radiotap_datapad,
tvb, 0, 0, (rflags&IEEE80211_RADIOTAP_F_DATAPAD) != 0);
length_remaining-=4;
break;
case IEEE80211_RADIOTAP_FHSS:
- case IEEE80211_RADIOTAP_LOCK_QUALITY:
case IEEE80211_RADIOTAP_TX_ATTENUATION:
case IEEE80211_RADIOTAP_DB_TX_ATTENUATION:
if (length_remaining < 2)
offset+=8;
length_remaining-=8;
break;
+ case IEEE80211_RADIOTAP_LOCK_QUALITY:
+ if (length_remaining < 2)
+ break;
+ if (tree) {
+ proto_tree_add_uint(radiotap_tree, hf_radiotap_quality,
+ tvb, offset, 2, tvb_get_letohs(tvb, offset));
+ }
+ offset+=2;
+ length_remaining-=2;
+ break;
+ case IEEE80211_RADIOTAP_FCS:
+ /*
+ * We don't show the FCS because, since it's already at the end of the frame,
+ * it would be redundant.
+ * However, we tell the 802.11 dissector that the packet does have fcs.
+ */
+ if (length_remaining < 2)
+ break;
+ has_fcs = TRUE;
+ offset+=2;
+ length_remaining-=2;
+ break;
default:
/*
* This indicates a field whose size we do not
}
}
- if (rflags & IEEE80211_RADIOTAP_F_FCS)
+ /* does the frame contain the FCS? */
+ if ((has_fcs == TRUE) || (rflags & IEEE80211_RADIOTAP_F_FCS))
pinfo->pseudo_header->ieee_802_11.fcs_len = 4;
+ else
+ pinfo->pseudo_header->ieee_802_11.fcs_len = 0;
+
/* dissect the 802.11 header next */
call_dissector((rflags & IEEE80211_RADIOTAP_F_DATAPAD) ?
ieee80211_datapad_handle : ieee80211_handle,
noinst_HEADERS = \
about_dlg.h \
+ airpcap_dlg.h \
+ airpcap_gui_utils.h \
capture_dlg.h \
capture_file_dlg.h \
capture_if_details_dlg.h \
libui_a_DEPENDENCIES =
EXTRA_DIST = \
+ airpcap_dlg.c \
+ airpcap_gui_utils.c \
capture_if_details_dlg.c \
doxygen.cfg.in \
ethclist.c \
#
WIRESHARK_GTK_SRC = \
about_dlg.c \
+ airpcap_dlg.c \
+ airpcap_gui_utils.c \
capture_dlg.c \
capture_file_dlg.c \
capture_if_dlg.c \
--- /dev/null
+/* airpcap_dlg.c
+ *
+ * $Id$
+ *
+ * Ulf Lamping <ulf.lamping@web.de>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 2000 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#ifdef HAVE_AIRPCAP
+
+#include <gtk/gtk.h>
+#include <glib.h>
+
+#include <string.h>
+
+#include <epan/filesystem.h>
+
+#include "gtk/main.h"
+#include "dlg_utils.h"
+#include "gui_utils.h"
+#include "simple_dialog.h"
+#include "dfilter_expr_dlg.h"
+#include "compat_macros.h"
+#include "gtkglobals.h"
+#include "help_dlg.h"
+
+#include <airpcap.h>
+#include "airpcap_loader.h"
+#include "airpcap_gui_utils.h"
+#include "airpcap_dlg.h"
+
+#include "keys.h"
+
+/* temporary block signals to widgets */
+BOOL block_advanced_signals;
+
+/*
+ * This struct will contain useful data for the selected (actual) airpcap device
+ */
+void
+airpcap_fill_if_combo(GtkWidget *combo, GList* if_list)
+{
+int ifn = 0;
+GList* popdown_if_list = NULL;
+GList* curr = NULL;
+airpcap_if_info_t* if_info = NULL;
+
+ curr = g_list_nth(if_list, ifn);
+ if_info = NULL;
+ if(curr != NULL) if_info = curr->data;
+
+ popdown_if_list = NULL;
+ ifn = g_list_length(if_list) - 1;
+ while(ifn >= 0) /* reverse order */
+ {
+ curr = g_list_nth(if_list, ifn);
+ if_info = NULL;
+ if(curr != NULL)
+ if_info = curr->data;
+ if(if_info != NULL)
+ popdown_if_list = g_list_append( popdown_if_list , if_info->description) ;
+ ifn--;
+ }
+ gtk_combo_set_popdown_strings( GTK_COMBO(combo), popdown_if_list) ;
+
+ if(airpcap_if_selected != NULL)
+ {
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), airpcap_if_selected->description);
+ }
+ else
+ {
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), "No Wireless Interfaces Found");
+ }
+}
+
+/*
+ * Callback for the crc chackbox
+ */
+static void
+crc_check_cb(GtkWidget *w, gpointer user_data)
+{
+if( !block_advanced_signals && (airpcap_if_selected != NULL))
+ {
+ if(airpcap_if_selected->IsFcsPresent)
+ {
+ airpcap_if_selected->IsFcsPresent = FALSE;
+ airpcap_if_selected->saved = FALSE;
+ }
+ else
+ {
+ airpcap_if_selected->IsFcsPresent = TRUE;
+ airpcap_if_selected->saved = FALSE;
+ }
+ }
+}
+
+/*
+ * Callback for the wrong crc combo
+ */
+static void
+wrong_crc_combo_cb(GtkWidget *w, gpointer data)
+{
+const gchar *s;
+
+s = gtk_entry_get_text(GTK_ENTRY(data));
+
+if( !block_advanced_signals && (data != NULL) && (w != NULL) )
+ {
+ if((g_strcasecmp("",s)))
+ {
+ airpcap_if_selected->CrcValidationOn = airpcap_get_validation_type(s);
+ airpcap_if_selected->saved = FALSE;
+ }
+ }
+}
+
+/*
+ * Changed callback for the channel combobox
+ */
+static void
+channel_changed_cb(GtkWidget *w _U_, gpointer data)
+{
+const gchar *s;
+
+ s = gtk_entry_get_text(GTK_ENTRY(data));
+
+if( !block_advanced_signals && (data != NULL) && (w != NULL) )
+ {
+ s = gtk_entry_get_text(GTK_ENTRY(data));
+ if((g_strcasecmp("",s)))
+ {
+ if(airpcap_if_selected != NULL)
+ {
+ airpcap_if_selected->channel = airpcap_get_channel_number(s);
+ airpcap_if_selected->saved = FALSE;
+ }
+ }
+ }
+}
+
+/*
+ * Changed callback for the link layer combobox
+ */
+static void
+link_type_changed_cb(GtkWidget *w _U_, gpointer data)
+{
+const gchar *s;
+
+s = gtk_entry_get_text(GTK_ENTRY(data));
+
+if( !block_advanced_signals && (data != NULL) && (w != NULL) )
+ {
+ if((g_strcasecmp("",s)))
+ {
+ airpcap_if_selected->linkType = airpcap_get_link_type(s);
+ airpcap_if_selected->saved = FALSE;
+ }
+ }
+}
+
+/*
+ * Activate callback for the adapter combobox
+ */
+static void
+combo_if_activate_cb(GtkWidget *entry _U_, gpointer data)
+{
+}
+
+/*
+ * Changed callback for the adapter combobox
+ */
+static void
+airpcap_advanced_combo_if_changed_cb(GtkWidget *w _U_, gpointer data)
+{
+const gchar* s = NULL;
+
+s = gtk_entry_get_text(GTK_ENTRY(w));
+
+if((g_strcasecmp("",s)))
+ {
+ /* We are trying to change the interface to set up...*/
+ /* Check if the current interface settings need to be SAVED! */
+ if( (airpcap_if_selected != NULL) && !block_advanced_signals)
+ {
+ if( (airpcap_if_selected->saved) ) /* Just change interface */
+ {
+ /* No changes for this interface, no need to save anything */
+ airpcap_change_if(w,data);
+ }
+ else
+ {
+ /* Popup a dialog to ask if user wants to save settings for selected
+ * interface before changing it...
+ */
+ airpcap_ask_for_save(w,data);
+ }
+ }
+ }
+}
+
+/*
+ * Takes the keys from the GtkList widget, and add them to the interface list
+ */
+void
+airpcap_add_keys_from_list(GtkWidget *keylist, airpcap_if_info_t *if_info)
+{
+GtkWidget *key_ls;
+
+GString *new_key;
+
+gchar *text_entered = NULL;
+
+GtkWidget *nl_item,*nl_lb;
+
+GList *list,
+ *children;
+
+/* airpcap stuff */
+UINT i, j;
+gchar s[3];
+PAirpcapKeysCollection KeysCollection;
+ULONG KeysCollectionSize;
+UCHAR KeyByte;
+
+UINT keys_in_list = 0;
+
+key_ls = keylist;
+
+keys_in_list = (UINT)g_list_length(GTK_LIST(key_ls)->children);
+
+if(keys_in_list > 0)
+{
+ /*
+ * Save the encryption keys, if we have any of them
+ */
+ KeysCollectionSize = 0;
+
+ /*
+ * Calculate the size of the keys collection
+ */
+ KeysCollectionSize = sizeof(AirpcapKeysCollection) + keys_in_list * sizeof(AirpcapKey);
+
+ /*
+ * Allocate the collection
+ * We use malloc so it's easier to reuse the code in C programs
+ */
+ KeysCollection = (PAirpcapKeysCollection)malloc(KeysCollectionSize);
+ if(!KeysCollection)
+ {
+ /* Simple dialog ERROR */
+ simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","Failed mamory allocation for KeysCollection!");
+ return;
+ }
+
+ /*
+ * Populate the key collection
+ */
+ list = GTK_LIST(key_ls)->children;
+ KeysCollection->nKeys = keys_in_list;
+
+ for(i = 0; i < keys_in_list; i++)
+ {
+ KeysCollection->Keys[i].KeyType = AIRPCAP_KEYTYPE_WEP;
+
+ /* Retrieve the Item corresponding to the i-th key */
+ nl_item = g_list_nth_data(list, i);
+ children = gtk_container_children(GTK_CONTAINER(nl_item));
+ nl_lb = g_list_nth_data(children,0);
+ new_key = g_string_new(GTK_LABEL(nl_lb)->label);
+
+ KeysCollection->Keys[i].KeyLen = new_key->len / 2;
+ memset(&KeysCollection->Keys[i].KeyData, 0, sizeof(KeysCollection->Keys[i].KeyData));
+
+ for(j = 0 ; j < new_key->len; j += 2)
+ {
+ s[0] = new_key->str[j];
+ s[1] = new_key->str[j+1];
+ s[2] = '\0';
+ KeyByte = (UCHAR)strtol(s, NULL, 16);
+ KeysCollection->Keys[i].KeyData[j / 2] = KeyByte;
+ }
+ }
+
+ /*
+ * XXX - Free the old adapter key collection!
+ */
+ if(airpcap_if_selected->keysCollection != NULL)
+ g_free(airpcap_if_selected->keysCollection);
+
+ /*
+ * Set this collection ad the new one
+ */
+ airpcap_if_selected->keysCollection = KeysCollection;
+ airpcap_if_selected->keysCollectionSize = KeysCollectionSize;
+}
+}
+
+
+/*
+ * Pop-up window, used to ask the user if he wants to save the selected interface settings
+ * when closing the window.
+ */
+void
+airpcap_ask_for_save_before_closing(GtkWidget *w _U_, gpointer data)
+{
+ GtkWidget* dialog;
+
+ dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_SAVE_DONTSAVE_CANCEL,
+ PRIMARY_TEXT_START "Save settings before closing?" PRIMARY_TEXT_END "\n\n"
+ "If you close the window without saving, changes you made will\nbe discarded.");
+ simple_dialog_set_cb(dialog, airpcap_dialog_save_before_closing_cb, data);
+}
+
+/* user confirmed the "Save settings..." dialog */
+void
+airpcap_dialog_save_before_closing_cb(gpointer dialog _U_, gint btn, gpointer data)
+{
+GtkWidget* interface_combo;
+GtkWidget* key_ls;
+
+/* I need the combo box entry */
+interface_combo = GTK_WIDGET(OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_INTERFACE_KEY));
+key_ls = GTK_WIDGET(OBJECT_GET_DATA(data,AIRPCAP_ADVANCED_KEYLIST_KEY));
+
+ switch(btn) {
+ case(ESD_BTN_SAVE):
+ /* save interface and exit */
+ airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
+ airpcap_save_selected_if_configuration(airpcap_if_selected);
+ /* Remove gtk timeout */
+ gtk_timeout_remove(airpcap_if_selected->tag);
+ break;
+ case(ESD_BTN_DONT_SAVE):
+ /* exit without saving */
+ break;
+
+ default:
+ break;
+ }
+}
+
+/*
+ * Pop-up window, used to ask the user if he wants to save the selected interface settings
+ * when changing the interface in the advanced dialog box
+ */
+void
+airpcap_ask_for_save(GtkWidget *entry _U_, gpointer data)
+{
+ GtkWidget* dialog;
+
+ dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_SAVE_DONTSAVE_CANCEL,
+ PRIMARY_TEXT_START "Save settings before changing interface?" PRIMARY_TEXT_END "\n\n"
+ "If you change interface without saving, changes you made will\nbe discarded.");
+ simple_dialog_set_cb(dialog, airpcap_dialog_save_cb, data);
+
+}
+
+/* user confirmed the "Save settings..." dialog */
+void
+airpcap_dialog_save_cb(GtkWidget* dialog _U_, gint btn, gpointer data)
+{
+GtkWidget* interface_combo;
+GtkWidget* key_ls;
+
+/* I need the combo box entry */
+interface_combo = GTK_WIDGET(OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_INTERFACE_KEY));
+key_ls = GTK_WIDGET(OBJECT_GET_DATA(data,AIRPCAP_ADVANCED_KEYLIST_KEY));
+
+ switch(btn) {
+ case(ESD_BTN_SAVE):
+ /* save interface and change */
+ airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
+ airpcap_save_selected_if_configuration(airpcap_if_selected);
+ /* Remove gtk timeout */
+ gtk_timeout_remove(airpcap_if_selected->tag);
+ airpcap_change_if(GTK_COMBO(interface_combo)->entry,data);
+ break;
+ case(ESD_BTN_DONT_SAVE):
+ /* change interface without saving */
+ airpcap_change_if(GTK_COMBO(interface_combo)->entry,data);
+ break;
+ case(ESD_BTN_CANCEL):
+ /* don't change interface and don't save */
+ break;
+ default:
+ break;
+ }
+}
+
+/*
+ * Function used to change the selected interface and advanced dialog box
+ */
+void
+airpcap_change_if(GtkWidget *entry _U_, gpointer data)
+{
+ const gchar *s;
+ gchar *channel_s;
+ gchar *capture_s;
+ GtkWidget *main_w;
+
+ GtkWidget *interface_combo;
+ GtkWidget *channel_combo;
+ GtkWidget *capture_combo;
+ GtkWidget *crc_check;
+ GtkWidget *wrong_crc_combo;
+ GtkWidget *blink_bt;
+ GtkWidget *key_ls;
+
+ airpcap_if_info_t *new_if;
+
+ /* Retrieve the GUI object pointers */
+ main_w = GTK_WIDGET(data);
+ interface_combo = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_INTERFACE_KEY));
+ channel_combo = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CHANNEL_KEY));
+ capture_combo = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_LINK_TYPE_KEY));
+ crc_check = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CRC_KEY));
+ wrong_crc_combo = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_WRONG_CRC_KEY));
+ blink_bt = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_BLINK_KEY));
+ key_ls = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
+
+ s = gtk_entry_get_text(GTK_ENTRY(entry));
+
+ /* Select actual interface*/
+ new_if = get_airpcap_if_from_description(airpcap_if_list, s);
+
+ /* And change the GUI according to it... */
+ /* This should always happen, but it seems that the callback is
+ * called twice, the first time with an 'empty' text... so it
+ * will return NULL!
+ */
+ if(new_if != NULL)
+ {
+ airpcap_if_selected = new_if;
+
+ new_if = NULL;
+ /* I need to 'block' signals to widgets or they will receive a signal now
+ and will change twice */
+ block_advanced_signals = TRUE;
+
+ /* Blink button */
+ if(airpcap_if_selected->blinking)
+ {
+ #if GTK_MAJOR_VERSION >= 2
+ gtk_button_set_label(GTK_BUTTON(blink_bt),"Stop Blinking");
+ #else
+ gtk_label_set_text(GTK_LABEL(GTK_BIN(blink_bt)->child),"Stop Blinking");
+ #endif
+ }
+ else
+ {
+ #if GTK_MAJOR_VERSION >= 2
+ gtk_button_set_label(GTK_BUTTON(blink_bt)," Blink Led ");
+ #else
+ gtk_label_set_text(GTK_LABEL(GTK_BIN(blink_bt)->child)," Blink Led ");
+ #endif
+ }
+
+ /* Channel combo */
+ channel_s = g_strdup_printf("%d",airpcap_if_selected->channel);
+ if(channel_combo != NULL) /* this event seems to happen when combo is still NULL */
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_combo)->entry), channel_s);
+
+ /* Link Layer combo */
+ capture_s = NULL;
+ if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11)
+ {
+ capture_s = g_strdup_printf(AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
+ if(capture_combo != NULL) /* this event seems to happen when combo is still NULL */
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(capture_combo)->entry), capture_s);
+ }
+ else if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_RADIO)
+ {
+ capture_s = g_strdup_printf(AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
+ if(capture_combo != NULL) /* this event seems to happen when combo is still NULL */
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(capture_combo)->entry), capture_s);
+ }
+
+ /* Fcs Presence check box */
+ if(airpcap_if_selected->IsFcsPresent)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(crc_check),TRUE);
+ else
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(crc_check),FALSE);
+
+ /* Wrong Crc combo box */
+ if(airpcap_if_selected->CrcValidationOn == AIRPCAP_VT_ACCEPT_EVERYTHING)
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_combo)->entry),AIRPCAP_VALIDATION_TYPE_NAME_ALL);
+ else if(airpcap_if_selected->CrcValidationOn == AIRPCAP_VT_ACCEPT_CORRECT_FRAMES)
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_combo)->entry),AIRPCAP_VALIDATION_TYPE_NAME_CORRECT);
+ else if(airpcap_if_selected->CrcValidationOn == AIRPCAP_VT_ACCEPT_CORRUPT_FRAMES)
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_combo)->entry),AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT);
+
+ /* Remove old keys */
+ gtk_list_remove_items(GTK_LIST(key_ls),GTK_LIST(key_ls)->children);
+ /* Add new keys */
+ airpcap_fill_key_list(key_ls,airpcap_if_selected);
+
+ /* Enable the signals again */
+ block_advanced_signals = FALSE;
+ }
+}
+
+/*
+ * Thread function used to blink the led
+ */
+void update_blink(gpointer data _U_)
+{
+airpcap_if_info_t* sel;
+PAirpcapHandle ad;
+char* ebuf = NULL;
+
+sel = (airpcap_if_info_t*)data;
+
+ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list, sel->description), ebuf);
+if(ad)
+ {
+ if(sel->led)
+ {
+ airpcap_if_turn_led_off(ad, 0);
+ sel->led = FALSE;
+ }
+ else
+ {
+ airpcap_if_turn_led_on(ad, 0);
+ sel->led = TRUE;
+ }
+ airpcap_if_close(ad);
+ }
+}
+
+/*
+ * Blink button callback
+ */
+void
+blink_cb( GtkWidget *blink_bt _U_, gpointer if_data )
+{
+PAirpcapHandle ad = NULL;
+char* ebuf = NULL;
+
+if(airpcap_if_selected != NULL)
+ if(!(airpcap_if_selected->blinking))
+ {
+ #if GTK_MAJOR_VERSION >= 2
+ gtk_button_set_label(GTK_BUTTON(blink_bt),"Stop Blinking");
+ #else
+ gtk_label_set_text(GTK_LABEL(GTK_BIN(blink_bt)->child),"Stop Blinking");
+ #endif
+ airpcap_if_selected->tag = gtk_timeout_add(500, (GtkFunction)update_blink,airpcap_if_selected);
+ airpcap_if_selected->blinking = TRUE;
+ }
+ else
+ {
+ #if GTK_MAJOR_VERSION >= 2
+ gtk_button_set_label(GTK_BUTTON(blink_bt)," Blink Led ");
+ #else
+ gtk_label_set_text(GTK_LABEL(GTK_BIN(blink_bt)->child)," Blink Led ");
+ #endif
+ gtk_timeout_remove(airpcap_if_selected->tag);
+ airpcap_if_selected->blinking = FALSE;
+ /* Switch on the led! */
+ ad = airpcap_if_open(airpcap_if_selected->name, ebuf);
+ if(ad)
+ {
+ gtk_timeout_remove(airpcap_if_selected->tag);
+ airpcap_if_turn_led_on(ad, 0);
+ airpcap_if_selected->blinking = FALSE;
+ airpcap_if_selected->led = TRUE;
+ airpcap_if_close(ad);
+ }
+ }
+}
+
+/* the window was closed, cleanup things */
+static void
+airpcap_if_destroy_cb(GtkWidget *w _U_, gpointer user_data _U_)
+{
+ PAirpcapHandle ad = NULL;
+ char* ebuf = NULL;
+
+ /* Retrieve object data */
+ GtkWidget *main_w;
+ GtkWidget *channel_combo;
+ GtkWidget *capture_combo;
+ GtkWidget *crc_check;
+ GtkWidget *wrong_crc_combo;
+ GtkWidget *blink_bt;
+ GtkWidget *interface_combo;
+ GtkWidget *cancel_bt;
+ GtkWidget *ok_bt;
+ GtkWidget *key_ls;
+
+ /* widgets in the toolbar */
+ GtkWidget *toolbar,
+ *toolbar_if_lb,
+ *toolbar_channel_cm,
+ *toolbar_wrong_crc_cm,
+ *toolbar_decryption_ck,
+ *advanced_bt;
+
+ gint *from_widget = NULL;
+
+ /* Retrieve the GUI object pointers */
+ main_w = GTK_WIDGET(user_data);
+ interface_combo = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_INTERFACE_KEY));
+ channel_combo = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CHANNEL_KEY));
+ capture_combo = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_LINK_TYPE_KEY));
+ crc_check = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CRC_KEY));
+ wrong_crc_combo = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_WRONG_CRC_KEY));
+ blink_bt = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_BLINK_KEY));
+ cancel_bt = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_CANCEL_KEY));
+ ok_bt = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_OK_KEY));
+ key_ls = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
+ advanced_bt = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEY));
+
+ toolbar = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_TOOLBAR_KEY));
+
+ /* retrieve toolbar info */
+ toolbar_if_lb = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
+ toolbar_channel_cm = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
+ toolbar_wrong_crc_cm = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_WRONG_CRC_KEY));
+ toolbar_decryption_ck = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
+
+ from_widget = (gint*)OBJECT_GET_DATA(toolbar,AIRPCAP_ADVANCED_FROM_KEY);
+
+ /* ... */
+ /* gray out the toolbar (if we came here from the toolbar advanced button)*/
+ if( *from_widget == AIRPCAP_ADVANCED_FROM_TOOLBAR)
+ gtk_widget_set_sensitive(toolbar,TRUE);
+
+ /* Stop blinking ALL leds (go through the airpcap_if_list) */
+ if(airpcap_if_selected != NULL)
+ {
+ ad = airpcap_if_open(airpcap_if_selected->name, ebuf);
+ if(ad)
+ {
+ gtk_timeout_remove(airpcap_if_selected->tag);
+ airpcap_if_turn_led_on(ad, 0);
+ airpcap_if_selected->blinking = FALSE;
+ airpcap_if_selected->led = TRUE;
+ airpcap_if_close(ad);
+ }
+ }
+
+ /* See if the 'Cancel' button was pressed or not
+ * if button is pressed, don't save configuration!
+ */
+ if(GTK_BUTTON(cancel_bt)->in_button)
+ {
+ /* reload the configuration!!! Configuration has not been saved but
+ the corresponding structure has been modified probably...*/
+ if(!airpcap_if_selected->saved)
+ {
+ airpcap_load_selected_if_configuration(airpcap_if_selected);
+ }
+
+ /* NULL to everything */
+ main_w = NULL;
+ blink_bt = NULL;
+ channel_combo = NULL;
+ interface_combo = NULL;
+ capture_combo = NULL;
+ crc_check = NULL;
+ wrong_crc_combo = NULL;
+
+ /* ... */
+ /* gray out the toolbar (if we came here from the toolbar advanced button)*/
+ if( *from_widget == AIRPCAP_ADVANCED_FROM_TOOLBAR)
+ gtk_widget_set_sensitive(toolbar,TRUE);
+
+ g_free(from_widget);
+ return;
+ }
+ else if(GTK_BUTTON(ok_bt)->in_button)
+ {
+
+ /* ??? - Ask if want to save configuration */
+
+ /* Save the configuration */
+ airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
+ airpcap_save_selected_if_configuration(airpcap_if_selected);
+ /* Remove gtk timeout */
+ gtk_timeout_remove(airpcap_if_selected->tag);
+
+ /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
+ if( g_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)
+ {
+ gtk_label_set_text(GTK_LABEL(toolbar_if_lb), g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(airpcap_if_selected)));
+ airpcap_channel_combo_set_by_number(toolbar_channel_cm,airpcap_if_selected->channel);
+ airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
+
+ gtk_signal_handler_block_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
+ if(airpcap_if_active->DecryptionOn == AIRPCAP_DECRYPTION_ON)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),TRUE);
+ else
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),FALSE);
+ gtk_signal_handler_unblock_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
+ }
+
+ /* If interface active is airpcap, set sensitive TRUE for airpcap toolbar */
+ if( get_airpcap_if_by_name(airpcap_if_list,airpcap_if_active->description) != NULL)
+ {
+ airpcap_set_toolbar_start_capture(airpcap_if_active);
+ }
+ else
+ {
+ airpcap_set_toolbar_stop_capture(airpcap_if_active);
+ }
+
+ /* NULL to everything */
+ main_w = NULL;
+ blink_bt = NULL;
+ channel_combo = NULL;
+ interface_combo = NULL;
+ capture_combo = NULL;
+ crc_check = NULL;
+ wrong_crc_combo = NULL;
+
+ /* ... */
+ /* gray out the toolbar (if we came here from the toolbar advanced button)*/
+ if( *from_widget == AIRPCAP_ADVANCED_FROM_OPTIONS)
+ gtk_widget_set_sensitive(toolbar,FALSE);
+
+ g_free(from_widget);
+ return;
+ }
+
+ /* reload the configuration!!! Configuration has not been saved but
+ the corresponding structure has been modified probably...*/
+ if(!airpcap_if_selected->saved)
+ {
+ airpcap_load_selected_if_configuration(airpcap_if_selected);
+ }
+}
+
+/*
+ * Callback for the 'Apply' button.
+ */
+static void
+airpcap_advanced_apply_cb(GtkWidget *button, gpointer data _U_)
+{
+ /* advenced window */
+ GtkWidget *main_w;
+
+ /* widgets in the toolbar */
+ GtkWidget *toolbar,
+ *toolbar_if_lb,
+ *toolbar_channel_cm,
+ *toolbar_wrong_crc_cm,
+ *toolbar_decryption_ck;
+
+ GtkWidget *key_ls;
+
+ /* retrieve main window */
+ main_w = GTK_WIDGET(data);
+ key_ls = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
+
+ toolbar = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_TOOLBAR_KEY));
+
+ /* retrieve toolbar info */
+ toolbar_if_lb = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
+ toolbar_channel_cm = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
+ toolbar_wrong_crc_cm = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_WRONG_CRC_KEY));
+ toolbar_decryption_ck = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
+
+ /* Save the configuration */
+ airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
+ airpcap_save_selected_if_configuration(airpcap_if_selected);
+
+ /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
+ if( g_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)
+ {
+ gtk_label_set_text(GTK_LABEL(toolbar_if_lb), g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(airpcap_if_selected)));
+ airpcap_channel_combo_set_by_number(toolbar_channel_cm,airpcap_if_selected->channel);
+ airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
+
+ gtk_signal_handler_block_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
+ if(airpcap_if_active->DecryptionOn == AIRPCAP_DECRYPTION_ON)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),TRUE);
+ else
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),FALSE);
+ gtk_signal_handler_unblock_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
+ }
+}
+
+/*
+ * Callback for the 'Ok' button.
+ */
+static void
+airpcap_advanced_ok_cb(GtkWidget *w, gpointer data _U_)
+{
+ /* advenced window */
+ GtkWidget *main_w;
+
+ /* widgets in the toolbar */
+ GtkWidget *toolbar,
+ *toolbar_if_lb,
+ *toolbar_channel_cm,
+ *toolbar_wrong_crc_cm,
+ *toolbar_decryption_ck;
+
+ GtkWidget *key_ls;
+
+ /* retrieve main window */
+ main_w = GTK_WIDGET(data);
+
+ toolbar = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_TOOLBAR_KEY));
+
+ key_ls = GTK_WIDGET(OBJECT_GET_DATA(main_w,AIRPCAP_ADVANCED_KEYLIST_KEY));
+
+ /* retrieve toolbar info */
+ toolbar_if_lb = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
+ toolbar_channel_cm = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
+ toolbar_wrong_crc_cm = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_WRONG_CRC_KEY));
+ toolbar_decryption_ck = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_DECRYPTION_KEY));
+
+ /* Save the configuration */
+ airpcap_add_keys_from_list(key_ls,airpcap_if_selected);
+ airpcap_save_selected_if_configuration(airpcap_if_selected);
+ /* Remove gtk timeout */
+ gtk_timeout_remove(airpcap_if_selected->tag);
+
+ /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/
+ if( g_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)
+ {
+ gtk_label_set_text(GTK_LABEL(toolbar_if_lb), g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(airpcap_if_selected)));
+ airpcap_channel_combo_set_by_number(toolbar_channel_cm,airpcap_if_selected->channel);
+ airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);
+
+ gtk_signal_handler_block_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
+ if(airpcap_if_active->DecryptionOn == AIRPCAP_DECRYPTION_ON)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),TRUE);
+ else
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar_decryption_ck),FALSE);
+ gtk_signal_handler_unblock_by_func (GTK_OBJECT(toolbar_decryption_ck),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), toolbar);
+ }
+}
+
+/*
+ * Callback for the 'Reset Configuration' button.
+ */
+static void
+airpcap_advanced_reset_configuration_cb(GtkWidget *button, gpointer data _U_)
+{
+
+}
+
+/*
+ * Callback for the 'About' button.
+ */
+static void
+airpcap_advanced_about_cb(GtkWidget *button, gpointer data _U_)
+{
+ /* retrieve toolbar info */
+}
+
+/*
+ * Callback used to add a WEP key in the add new key box;
+ */
+static void
+add_key(GtkWidget *widget, gpointer data _U_)
+{
+GtkWidget *text,
+ *key_ls,
+ *ok_bt;
+
+GString *new_key;
+
+gchar *text_entered = NULL;
+
+int keys_in_list = 0;
+unsigned int i;
+
+text = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_ADD_KEY_TEXT_KEY);
+ok_bt = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_ADD_KEY_OK_KEY);
+key_ls = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_KEYLIST_KEY);
+
+keys_in_list = g_list_length(GTK_LIST(key_ls)->children);
+text_entered = g_strdup(gtk_entry_get_text(GTK_ENTRY(text)));
+
+/* Too many keys? */
+if(keys_in_list == MAX_ENCRYPTION_KEYS)
+ {
+ simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","Reached the Wep Keys Limit for this Interface.");
+ return;
+ }
+
+/* Check if key is correct */
+new_key = g_string_new(text_entered);
+
+g_strchug(new_key->str);
+g_strchomp(new_key->str);
+
+if((new_key->len % 2) != 0)
+ {
+ simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","1) A Wep key must is an arbitrary length hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.\nThe number of characters must be even.");
+ return;
+ }
+
+for(i = 0; i < new_key->len; i++)
+ {
+ if(!g_ascii_isxdigit(new_key->str[i]))
+ {
+ simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","2) A Wep key must is an arbitrary length hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.\nThe number of characters must be even.");
+ return;
+ }
+ }
+
+/* If so... Add key */
+airpcap_add_key_to_list(key_ls,new_key->str);
+
+airpcap_if_selected->saved = FALSE;
+
+g_string_free(new_key,TRUE);
+g_free(text_entered);
+
+window_destroy(GTK_WIDGET(data));
+return;
+}
+
+/*
+ * Callback used to add a WEP key in the edit key box;
+ */
+static void
+edit_key(GtkWidget *widget, gpointer data _U_)
+{
+GtkWidget *text,
+ *key_ls,
+ *ok_bt;
+
+GString *new_key;
+
+gchar *text_entered = NULL;
+
+GtkWidget *label;
+
+
+int keys_in_list = 0;
+unsigned int i;
+
+text = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_TEXT_KEY);
+ok_bt = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_OK_KEY);
+key_ls = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_KEYLIST_KEY);
+label = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_EDIT_KEY_LABEL_KEY);
+
+keys_in_list = g_list_length(GTK_LIST(key_ls)->children);
+text_entered = g_strdup(gtk_entry_get_text(GTK_ENTRY(text)));
+
+/* Check if key is correct */
+new_key = g_string_new(text_entered);
+
+g_strchug(new_key->str);
+g_strchomp(new_key->str);
+
+if((new_key->len % 2) != 0)
+ {
+ simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","1) A Wep key must is an arbitrary length hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.\nThe number of characters must be even.");
+ return;
+ }
+
+for(i = 0; i < new_key->len; i++)
+ {
+ if(!g_ascii_isxdigit(new_key->str[i]))
+ {
+ simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","2) A Wep key must is an arbitrary length hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.\nThe number of characters must be even.");
+ return;
+ }
+ }
+
+/* If so... modify key */
+gtk_label_set_text(GTK_LABEL(label),new_key->str);
+
+airpcap_if_selected->saved = FALSE;
+
+g_string_free(new_key,TRUE);
+g_free(text_entered);
+
+window_destroy(GTK_WIDGET(data));
+return;
+}
+
+/*
+ * Callback for the 'Add Key' button.
+ */
+static void
+airpcap_advanced_add_key_cb(GtkWidget *button, gpointer data _U_)
+{
+/* Window */
+GtkWidget *add_key_w;
+
+/* Frame */
+GtkWidget *add_key_frame;
+
+/* Boxes */
+GtkWidget *main_box, /* vertical */
+ *key_box, /* orizontal */
+ *text_box, /* orizontal */
+ *button_box;/* orizontal (packed to end)*/
+
+/* Text Entry */
+GtkWidget *key_text_entry;
+
+/* Buttons */
+GtkWidget *key_ok_bt,
+ *key_cancel_bt;
+
+/* Key List Widget */
+GtkWidget *key_ls;
+
+ /* Pop-up a new window */
+ add_key_w = window_new (GTK_WINDOW_TOPLEVEL,"Add a WEP Key");
+
+ /* Connect events */
+ SIGNAL_CONNECT(add_key_w, "delete_event",window_delete_event_cb, add_key_w);
+ SIGNAL_CONNECT(add_key_w, "destroy",add_key_w_destroy_cb, add_key_w);
+
+ /* Sets the border width of the window. */
+ gtk_container_set_border_width (GTK_CONTAINER (add_key_w), 5);
+
+ /* Retrieve the key list widget pointer, and add it to the add_key_w */
+ key_ls = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_KEYLIST_KEY);
+ OBJECT_SET_DATA(GTK_WIDGET(add_key_w),AIRPCAP_ADVANCED_KEYLIST_KEY,key_ls);
+ OBJECT_SET_DATA(GTK_WIDGET(add_key_w),AIRPCAP_ADVANCED_KEY,data);
+
+ /* Create boxes */
+ main_box = gtk_vbox_new(FALSE,1);
+ key_box = gtk_hbox_new(FALSE,1);
+ button_box = gtk_hbox_new(FALSE,1);
+ text_box = gtk_hbox_new(TRUE,1);
+
+ /* Add the two sub boxes to the main box */
+ gtk_box_pack_start(GTK_BOX(main_box), key_box, FALSE, FALSE, 1);
+ gtk_box_pack_start(GTK_BOX(main_box), button_box, FALSE, FALSE, 1);
+
+ /* Add the main box to the main window */
+ gtk_container_add(GTK_CONTAINER(add_key_w),main_box);
+
+ /* Crete key frame */
+ add_key_frame = gtk_frame_new("");
+ gtk_frame_set_label(GTK_FRAME(add_key_frame),"Key");
+ #if GTK_MAJOR_VERSION < 2
+ gtk_widget_set_usize( GTK_WIDGET(add_key_frame),
+ 200,
+ -1 );
+ #else
+ gtk_widget_set_size_request( GTK_WIDGET(add_key_frame),
+ 200,
+ -1 );
+ #endif
+
+ gtk_box_pack_start(GTK_BOX(key_box), add_key_frame, FALSE, FALSE, 1);
+
+ /* Create and Add text entry*/
+ key_text_entry = gtk_entry_new();
+ OBJECT_SET_DATA(add_key_w, AIRPCAP_ADVANCED_ADD_KEY_TEXT_KEY, key_text_entry);
+ SIGNAL_CONNECT(key_text_entry, "activate", add_key, add_key_w );
+ gtk_box_pack_start(GTK_BOX(text_box), key_text_entry, FALSE, FALSE, 1);
+ gtk_container_add(GTK_CONTAINER(add_key_frame),text_box);
+ gtk_container_set_border_width (GTK_CONTAINER (text_box), 5);
+
+ /* Create and add buttons */
+ key_ok_bt = gtk_button_new_with_label("OK");
+ SIGNAL_CONNECT(key_ok_bt, "clicked", add_key, add_key_w );
+ OBJECT_SET_DATA(add_key_w, AIRPCAP_ADVANCED_ADD_KEY_OK_KEY, key_ok_bt);
+ #if GTK_MAJOR_VERSION < 2
+ gtk_widget_set_usize( GTK_WIDGET(key_ok_bt),
+ 50,
+ -1 );
+ #else
+ gtk_widget_set_size_request( GTK_WIDGET(key_ok_bt),
+ 50,
+ -1 );
+ #endif
+ key_cancel_bt = gtk_button_new_with_label("Cancel");
+ SIGNAL_CONNECT(key_cancel_bt, "clicked", window_cancel_button_cb, add_key_w );
+ #if GTK_MAJOR_VERSION < 2
+ gtk_widget_set_usize( GTK_WIDGET(key_cancel_bt),
+ 50,
+ -1 );
+ #else
+ gtk_widget_set_size_request( GTK_WIDGET(key_cancel_bt),
+ 50,
+ -1 );
+ #endif
+
+ gtk_box_pack_end(GTK_BOX(button_box), key_cancel_bt, FALSE, FALSE, 1);
+ gtk_box_pack_end(GTK_BOX(button_box), key_ok_bt, FALSE, FALSE, 1);
+
+ /* Show all */
+ gtk_widget_show(key_ok_bt);
+ gtk_widget_show(key_cancel_bt);
+ gtk_widget_show(key_text_entry);
+ gtk_widget_show(add_key_frame);
+ gtk_widget_show(text_box);
+ gtk_widget_show(button_box);
+ gtk_widget_show(key_box);
+ gtk_widget_show(main_box);
+ gtk_widget_show(add_key_w);
+}
+
+/*
+ * Add key window destroy callback
+ */
+static void
+add_key_w_destroy_cb(GtkWidget *button, gpointer data _U_)
+{
+return;
+}
+
+/*
+ * Edit key window destroy callback
+ */
+static void
+edit_key_w_destroy_cb(GtkWidget *button, gpointer data _U_)
+{
+return;
+}
+
+/*
+ * Callback for the 'Remove Key' button.
+ */
+static void
+airpcap_advanced_remove_key_cb(GtkWidget *button, gpointer data _U_)
+{
+GtkList *key_ls;
+GtkWidget *label;
+GList *item = NULL;
+gint n;
+
+/* retrieve key list */
+key_ls = GTK_LIST(data);
+
+/* Remove selected keys*/
+if(key_ls->selection != NULL)
+ {
+ item = g_list_nth(key_ls->selection,0);
+ if(item != NULL)
+ {
+ n = gtk_list_child_position(key_ls,item->data);
+ label = GTK_BIN(item->data)->child;
+ gtk_list_clear_items(key_ls,n,n+1);
+ }
+ }
+
+/* Need to save config... */
+airpcap_if_selected->saved = FALSE;
+}
+
+/*
+ * Callback for the 'Edit Key' button.
+ */
+static void
+airpcap_advanced_edit_key_cb(GtkWidget *button, gpointer data _U_)
+{
+/* Window */
+GtkWidget *edit_key_w;
+
+/* Frame */
+GtkWidget *edit_key_frame;
+
+/* Boxes */
+GtkWidget *main_box, /* vertical */
+ *key_box, /* orizontal */
+ *text_box, /* orizontal */
+ *button_box;/* orizontal (packed to end)*/
+
+/* Text Entry */
+GtkWidget *key_text_entry;
+
+/* Buttons */
+GtkWidget *key_ok_bt,
+ *key_cancel_bt;
+
+/* Key List Widget */
+GtkWidget *key_ls;
+
+GtkWidget *label;
+GList *item = NULL;
+gint n;
+
+/* Retrieve the key list widget pointer, and add it to the edit_key_w */
+key_ls = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_KEYLIST_KEY);
+
+/*
+ * Check if a key has been selected. If not, just do nothing.
+ */
+if(GTK_LIST(key_ls)->selection != NULL)
+ {
+ item = g_list_nth(GTK_LIST(key_ls)->selection,0);
+ if(item != NULL)
+ {
+ /* Pop-up a new window */
+ edit_key_w = window_new (GTK_WINDOW_TOPLEVEL,"Edit a WEP Key");
+
+ /* Connect events */
+ SIGNAL_CONNECT(edit_key_w, "delete_event",window_delete_event_cb, edit_key_w);
+ SIGNAL_CONNECT(edit_key_w, "destroy",edit_key_w_destroy_cb, edit_key_w);
+
+ /* Sets the border width of the window. */
+ gtk_container_set_border_width (GTK_CONTAINER (edit_key_w), 5);
+
+ OBJECT_SET_DATA(GTK_WIDGET(edit_key_w),AIRPCAP_ADVANCED_KEYLIST_KEY,key_ls);
+ OBJECT_SET_DATA(GTK_WIDGET(edit_key_w),AIRPCAP_ADVANCED_KEY,data);
+
+ /* Create boxes */
+ main_box = gtk_vbox_new(FALSE,1);
+ key_box = gtk_hbox_new(FALSE,1);
+ button_box = gtk_hbox_new(FALSE,1);
+ text_box = gtk_hbox_new(TRUE,1);
+
+ /* Add the two sub boxes to the main box */
+ gtk_box_pack_start(GTK_BOX(main_box), key_box, FALSE, FALSE, 1);
+ gtk_box_pack_start(GTK_BOX(main_box), button_box, FALSE, FALSE, 1);
+
+ /* Add the main box to the main window */
+ gtk_container_add(GTK_CONTAINER(edit_key_w),main_box);
+
+ /* Crete key frame */
+ edit_key_frame = gtk_frame_new("");
+ gtk_frame_set_label(GTK_FRAME(edit_key_frame),"Key");
+ #if GTK_MAJOR_VERSION < 2
+ gtk_widget_set_usize( GTK_WIDGET(edit_key_frame),
+ 200,
+ -1 );
+ #else
+ gtk_widget_set_size_request( GTK_WIDGET(edit_key_frame),
+ 200,
+ -1 );
+ #endif
+
+ gtk_box_pack_start(GTK_BOX(key_box), edit_key_frame, FALSE, FALSE, 1);
+
+ /* Create and Add text entry*/
+ key_text_entry = gtk_entry_new();
+ /* Retrieve the currently selected entry */
+ if(GTK_LIST(key_ls)->selection != NULL)
+ {
+ item = g_list_nth(GTK_LIST(key_ls)->selection,0);
+ if(item != NULL)
+ {
+ n = gtk_list_child_position(GTK_LIST(key_ls),item->data);
+ label = GTK_BIN(item->data)->child;
+ /* Pass the pointer as data */
+ OBJECT_SET_DATA(edit_key_w,AIRPCAP_ADVANCED_EDIT_KEY_LABEL_KEY,label);
+ }
+ }
+ gtk_entry_set_text(GTK_ENTRY(key_text_entry),GTK_LABEL(label)->label);
+ OBJECT_SET_DATA(edit_key_w, AIRPCAP_ADVANCED_EDIT_KEY_TEXT_KEY, key_text_entry);
+ SIGNAL_CONNECT(key_text_entry, "activate", edit_key, edit_key_w );
+ gtk_box_pack_start(GTK_BOX(text_box), key_text_entry, FALSE, FALSE, 1);
+ gtk_container_add(GTK_CONTAINER(edit_key_frame),text_box);
+ gtk_container_set_border_width (GTK_CONTAINER (text_box), 5);
+
+ /* Create and add buttons */
+ key_ok_bt = gtk_button_new_with_label("OK");
+ SIGNAL_CONNECT(key_ok_bt, "clicked", edit_key, edit_key_w );
+ OBJECT_SET_DATA(edit_key_w, AIRPCAP_ADVANCED_EDIT_KEY_OK_KEY, key_ok_bt);
+ #if GTK_MAJOR_VERSION < 2
+ gtk_widget_set_usize( GTK_WIDGET(key_ok_bt),
+ 50,
+ -1 );
+ #else
+ gtk_widget_set_size_request( GTK_WIDGET(key_ok_bt),
+ 50,
+ -1 );
+ #endif
+ key_cancel_bt = gtk_button_new_with_label("Cancel");
+ SIGNAL_CONNECT(key_cancel_bt, "clicked", window_cancel_button_cb, edit_key_w );
+ #if GTK_MAJOR_VERSION < 2
+ gtk_widget_set_usize( GTK_WIDGET(key_cancel_bt),
+ 50,
+ -1 );
+ #else
+ gtk_widget_set_size_request( GTK_WIDGET(key_cancel_bt),
+ 50,
+ -1 );
+ #endif
+
+ gtk_box_pack_end(GTK_BOX(button_box), key_cancel_bt, FALSE, FALSE, 1);
+ gtk_box_pack_end(GTK_BOX(button_box), key_ok_bt, FALSE, FALSE, 1);
+
+ /* Show all */
+ gtk_widget_show(key_ok_bt);
+ gtk_widget_show(key_cancel_bt);
+ gtk_widget_show(key_text_entry);
+ gtk_widget_show(edit_key_frame);
+ gtk_widget_show(text_box);
+ gtk_widget_show(button_box);
+ gtk_widget_show(key_box);
+ gtk_widget_show(main_box);
+ gtk_widget_show(edit_key_w);
+ }
+ }
+}
+
+/*
+ * Callback for the 'Move Key Up' button.
+ */
+static void
+airpcap_advanced_move_key_up_cb(GtkWidget *button, gpointer data _U_)
+{
+GtkList *key_ls;
+GtkWidget *label,*nl_lb,*nl_item;
+GList *new_list = NULL;
+GList *item = NULL;
+gint n;
+
+/* retrieve key list */
+key_ls = GTK_LIST(data);
+
+/* Remove selected keys*/
+if(key_ls->selection != NULL)
+ {
+ item = g_list_nth(key_ls->selection,0);
+ if(item != NULL)
+ {
+ n = gtk_list_child_position(key_ls,item->data);
+ if(n>0)
+ {
+ label = GTK_BIN(item->data)->child;
+ nl_lb = gtk_label_new(GTK_LABEL(label)->label);
+ gtk_list_clear_items(key_ls,n,n+1);
+ nl_item = gtk_list_item_new();
+ gtk_misc_set_alignment (GTK_MISC (nl_lb), 0.0, 0.5);
+ gtk_container_add(GTK_CONTAINER(nl_item), nl_lb);
+ gtk_widget_show(nl_lb);
+ gtk_widget_show(nl_item);
+ new_list = g_list_append(new_list,nl_item);
+ gtk_list_insert_items(key_ls,new_list,n-1);
+ gtk_list_select_item(key_ls,n-1);
+ }
+ }
+ }
+
+/* Need to save config... */
+airpcap_if_selected->saved = FALSE;
+}
+
+/*
+ * Callback for the 'Move Key Down' button.
+ */
+static void
+airpcap_advanced_move_key_down_cb(GtkWidget *button, gpointer data _U_)
+{
+GtkList *key_ls;
+GtkWidget *label,*nl_lb,*nl_item;
+GList *new_list = NULL;
+GList *item = NULL;
+unsigned int n;
+
+/* retrieve key list */
+key_ls = GTK_LIST(data);
+
+/* Remove selected keys*/
+if(key_ls->selection != NULL)
+ {
+ item = g_list_nth(key_ls->selection,0);
+ if(item != NULL)
+ {
+ n = gtk_list_child_position(key_ls,item->data);
+ if(n< (g_list_length(key_ls->children)-1))
+ {
+ label = GTK_BIN(item->data)->child;
+ nl_lb = gtk_label_new(GTK_LABEL(label)->label);
+ gtk_list_clear_items(key_ls,n,n+1);
+
+ nl_item = gtk_list_item_new();
+ gtk_misc_set_alignment (GTK_MISC (nl_lb), 0.0, 0.5);
+ gtk_container_add(GTK_CONTAINER(nl_item), nl_lb);
+ gtk_widget_show(nl_lb);
+ gtk_widget_show(nl_item);
+
+ new_list = g_list_append(new_list,nl_item);
+ gtk_list_insert_items(key_ls,new_list,n+1);
+ gtk_list_select_item(key_ls,n+1);
+ }
+ }
+ }
+
+/* Need to save config... */
+airpcap_if_selected->saved = FALSE;
+}
+
+/* Turns the decryption on or off */
+static void
+encryption_check_cb(GtkWidget *w, gpointer data)
+{
+if( !block_advanced_signals && (airpcap_if_selected != NULL))
+ {
+ if(airpcap_if_selected->DecryptionOn == AIRPCAP_DECRYPTION_ON)
+ {
+ airpcap_if_selected->DecryptionOn = AIRPCAP_DECRYPTION_OFF;
+ airpcap_if_selected->saved = FALSE;
+ }
+ else
+ {
+ airpcap_if_selected->DecryptionOn = AIRPCAP_DECRYPTION_ON;
+ airpcap_if_selected->saved = FALSE;
+ }
+ }
+}
+
+
+/* Called to create the airpcap settings' window */
+void
+display_airpcap_advanced_cb(GtkWidget *w, gpointer data)
+{
+ /* Main window */
+ GtkWidget *airpcap_advanced_w;
+
+ /* Blink button */
+ GtkWidget *blink_bt,
+ *channel_combo;
+ /* Combos */
+ GtkWidget *interface_combo,
+ *capture_combo;
+
+ /* check */
+ GtkWidget *wrong_crc_combo;
+
+ /* key list*/
+ GtkWidget *key_ls;
+
+ /* frames */
+ GtkWidget *interface_frame,
+ *basic_frame,
+ *wep_frame;
+ /* boxes */
+ GtkWidget *main_box,
+ *buttons_box_1,
+ *buttons_box_2,
+ *interface_box,
+ *basic_box,
+ *basic_combo_box,
+ *basic_check_box,
+ *basic_label_box,
+ *basic_wrong_box,
+ *wep_box,
+ *wep_sub_box,
+ *encryption_box,
+ *wep_buttons_box;
+ /* buttons */
+ /* blink button is global */
+ GtkWidget *add_new_key_bt,
+ *remove_key_bt,
+ *edit_key_bt,
+ *move_key_up_bt,
+ *move_key_down_bt,
+ *reset_configuration_bt,
+ *about_bt,
+ *apply_bt,
+ *ok_bt,
+ *cancel_bt;
+ /* combo */
+
+ /* shortcut to combo entry */
+ GtkWidget *link_type_te,
+ *wrong_crc_te,
+ *channel_te;
+ /* check */
+ /* global check buttons */
+ GtkWidget *crc_check,
+ *encryption_check;
+ /* label */
+ GtkWidget *channel_lb,
+ *wrong_lb,
+ *capture_lb;
+ /* text field */
+ GtkWidget *key_text;
+
+ /* widgets in the toolbar */
+ GtkWidget *toolbar,
+ *toolbar_if_lb,
+ *toolbar_channel_cm,
+ *toolbar_wrong_crc_cm;
+
+ /* other stuff */
+ GList *channel_list,*capture_list;
+ GList *linktype_list = NULL;
+ gchar *channel_s,*capture_s;
+
+
+ /* user data - RETRIEVE pointers of toolbar widgets */
+ toolbar = GTK_WIDGET(data);
+ toolbar_if_lb = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_INTERFACE_KEY));
+ toolbar_channel_cm = GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_CHANNEL_KEY));
+ toolbar_wrong_crc_cm= GTK_WIDGET(OBJECT_GET_DATA(toolbar,AIRPCAP_TOOLBAR_WRONG_CRC_KEY));
+
+ /* gray out the toolbar */
+ gtk_widget_set_sensitive(toolbar,FALSE);
+
+ /* main window */
+ /* global */
+
+ /* NULL to global widgets */
+ blink_bt = NULL;
+ channel_combo = NULL;
+ block_advanced_signals = FALSE;
+
+ /* the selected is the active, for now */
+ airpcap_if_selected = airpcap_if_active;
+
+ /* Create the new window */
+ airpcap_advanced_w = window_new(GTK_WINDOW_TOPLEVEL, "Advanced Wireless Settings");
+
+ /*
+ * I will need the toolbar and the main widget in some callback,
+ * so I will add the toolbar pointer to the airpcap_advanced_w
+ */
+ OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_TOOLBAR_KEY,toolbar);
+
+ /* Connect the callbacks */
+ SIGNAL_CONNECT(airpcap_advanced_w, "delete_event", window_delete_event_cb, airpcap_advanced_w);
+ SIGNAL_CONNECT(airpcap_advanced_w, "destroy", airpcap_if_destroy_cb, airpcap_advanced_w);
+
+ /* Set the size */
+ /* Sets the border width of the window. */
+ gtk_container_set_border_width (GTK_CONTAINER (airpcap_advanced_w), 10);
+
+ /* Create the main box */
+ main_box = gtk_vbox_new(FALSE,0);
+
+ /* Create the button boxes */
+ buttons_box_1 = gtk_hbox_new(FALSE,0);
+ buttons_box_2 = gtk_hbox_new(FALSE,0);
+
+ /* Create the buttons for box 1 */
+ reset_configuration_bt = gtk_button_new_with_label("Reset Configuration");
+ SIGNAL_CONNECT(reset_configuration_bt, "clicked", airpcap_advanced_reset_configuration_cb, toolbar);
+ gtk_widget_show(reset_configuration_bt);
+
+ about_bt = gtk_button_new_with_label("About");
+ SIGNAL_CONNECT(about_bt, "clicked", airpcap_advanced_about_cb, toolbar);
+ gtk_widget_show(about_bt);
+
+ /* Add them to box 1 */
+ gtk_box_pack_start (GTK_BOX (buttons_box_1), reset_configuration_bt, FALSE, FALSE, 1);
+ gtk_box_pack_start (GTK_BOX (buttons_box_1), about_bt, FALSE, FALSE, 1);
+
+ /* Create the buttons for box 2 */
+ apply_bt = gtk_button_new_with_label("Apply");
+ SIGNAL_CONNECT(apply_bt, "clicked", airpcap_advanced_apply_cb, airpcap_advanced_w);
+ gtk_widget_show(apply_bt);
+
+ ok_bt = gtk_button_new_with_label("Ok");
+ OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_OK_KEY,ok_bt);
+ window_set_cancel_button(airpcap_advanced_w, ok_bt, window_cancel_button_cb);
+ gtk_widget_show(ok_bt);
+
+ cancel_bt = gtk_button_new_with_label("Cancel");
+ OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_CANCEL_KEY,cancel_bt);
+ window_set_cancel_button(airpcap_advanced_w, cancel_bt, window_cancel_button_cb);
+ gtk_widget_show(cancel_bt);
+
+ /* Add them to box 2 */
+ gtk_box_pack_end (GTK_BOX (buttons_box_2), cancel_bt, FALSE, FALSE, 1);
+ gtk_box_pack_end (GTK_BOX (buttons_box_2), apply_bt, FALSE, FALSE, 1);
+ gtk_box_pack_end (GTK_BOX (buttons_box_2), ok_bt, FALSE, FALSE, 1);
+
+ /* Create the three main frames */
+ interface_frame = gtk_frame_new("");
+ gtk_frame_set_label(GTK_FRAME(interface_frame),"Interface");
+
+ basic_frame = gtk_frame_new("");
+ gtk_frame_set_label(GTK_FRAME(basic_frame),"Basic Parameters");
+
+ wep_frame = gtk_frame_new("");
+ gtk_frame_set_label(GTK_FRAME(wep_frame),"WEP Keys");
+
+ /* Create the three sub boxes */
+ interface_box = gtk_hbox_new(FALSE,0);
+ basic_box = gtk_hbox_new(FALSE,0);
+ wep_box = gtk_vbox_new(FALSE,0);
+
+ /* Fill the interface_box */
+ if(airpcap_if_active != NULL)
+ {
+ interface_combo = gtk_label_new(airpcap_if_active->description);
+ }
+ else
+ {
+ interface_combo = gtk_label_new("No airpcap interface found!");
+ gtk_widget_set_sensitive(main_box,FALSE);
+ }
+
+ OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_INTERFACE_KEY,interface_combo);
+ gtk_box_pack_start (GTK_BOX (interface_box), interface_combo, TRUE, TRUE, 0);
+ gtk_widget_show(interface_combo);
+
+ /* blink led button (BEFORE interface_combo, 'cause its callback will need blink_bt)*/
+ blink_bt = gtk_button_new_with_label(" Blink Led ");
+ OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_BLINK_KEY,blink_bt);
+ gtk_box_pack_end (GTK_BOX (interface_box), blink_bt, FALSE, FALSE, 0);
+ SIGNAL_CONNECT(blink_bt, "clicked", blink_cb, NULL);
+ gtk_widget_show(blink_bt);
+
+ gtk_container_set_border_width (GTK_CONTAINER (interface_box), 10);
+
+ /* Fill the basic_box */
+ /* Create the two vertical boxes for combo and check */
+ basic_combo_box = gtk_vbox_new(TRUE,0);
+ basic_check_box = gtk_vbox_new(TRUE,0);
+ basic_label_box = gtk_vbox_new(TRUE,0);
+
+ /* Create the Wrong CRC horiziontal box */
+ basic_wrong_box = gtk_hbox_new(FALSE,0);
+
+ /* Fill the label vbox */
+ channel_lb = gtk_label_new("Channel: ");
+ gtk_label_set_justify(GTK_LABEL(channel_lb),GTK_JUSTIFY_LEFT);
+ gtk_box_pack_start (GTK_BOX (basic_label_box), channel_lb, TRUE, TRUE, 0);
+ gtk_widget_show(channel_lb);
+ capture_lb = gtk_label_new("Capture Type:");
+ gtk_label_set_justify(GTK_LABEL(capture_lb),GTK_JUSTIFY_LEFT);
+ gtk_box_pack_start (GTK_BOX (basic_label_box), capture_lb, TRUE, TRUE, 0);
+ gtk_widget_show(capture_lb);
+
+ /* Create the two combo boxes */
+ channel_combo = gtk_combo_new();
+ OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_CHANNEL_KEY,channel_combo);
+
+ channel_list = NULL;
+ channel_list = g_list_append(channel_list, "1");
+ channel_list = g_list_append(channel_list, "2");
+ channel_list = g_list_append(channel_list, "3");
+ channel_list = g_list_append(channel_list, "4");
+ channel_list = g_list_append(channel_list, "5");
+ channel_list = g_list_append(channel_list, "6");
+ channel_list = g_list_append(channel_list, "7");
+ channel_list = g_list_append(channel_list, "8");
+ channel_list = g_list_append(channel_list, "9");
+ channel_list = g_list_append(channel_list, "10");
+ channel_list = g_list_append(channel_list, "11");
+ channel_list = g_list_append(channel_list, "12");
+ channel_list = g_list_append(channel_list, "13");
+ channel_list = g_list_append(channel_list, "14");
+ gtk_combo_set_popdown_strings( GTK_COMBO(channel_combo), channel_list) ;
+
+ /* Select the first entry */
+ if(airpcap_if_selected != NULL)
+ {
+ channel_s = g_strdup_printf("%d",airpcap_if_selected->channel);
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_combo)->entry), channel_s);
+ }
+
+ channel_te = GTK_COMBO(channel_combo)->entry;
+ gtk_editable_set_editable(GTK_EDITABLE(channel_te),FALSE);
+ SIGNAL_CONNECT(channel_te, "changed", channel_changed_cb, channel_te);
+ gtk_box_pack_start (GTK_BOX (basic_combo_box), channel_combo, FALSE, FALSE, 0);
+ gtk_widget_show(channel_combo);
+
+ capture_combo = gtk_combo_new();
+ OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_LINK_TYPE_KEY,capture_combo);
+ capture_list = NULL;
+ capture_list = g_list_append(capture_list, AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
+ capture_list = g_list_append(capture_list, AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
+ gtk_combo_set_popdown_strings( GTK_COMBO(capture_combo), capture_list) ;
+
+ capture_s = NULL;
+ if(airpcap_if_selected != NULL)
+ {
+ if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11)
+ capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);
+ else if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_RADIO)
+ capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);
+ if(capture_s != NULL) gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(capture_combo)->entry), capture_s);
+ }
+ g_free(capture_s);
+
+ link_type_te = GTK_COMBO(capture_combo)->entry;
+ gtk_editable_set_editable(GTK_EDITABLE(link_type_te),FALSE);
+ SIGNAL_CONNECT(link_type_te, "changed", link_type_changed_cb, link_type_te);
+ gtk_box_pack_start (GTK_BOX (basic_combo_box), capture_combo, FALSE, FALSE, 1);
+ gtk_widget_show(capture_combo);
+
+ /* Create the two check boxes */
+ crc_check = gtk_check_button_new_with_label("Include 802.11 FCS in Frames");
+ OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_CRC_KEY,crc_check);
+
+ /* Fcs Presence check box */
+ if(airpcap_if_selected != NULL)
+ {
+ if(airpcap_if_selected->IsFcsPresent)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(crc_check),TRUE);
+ else
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(crc_check),FALSE);
+ }
+
+ SIGNAL_CONNECT(crc_check,"toggled",crc_check_cb,NULL);
+ gtk_box_pack_start (GTK_BOX (basic_check_box), crc_check, FALSE, FALSE, 0);
+ gtk_widget_show(crc_check);
+
+ /* CRC Filter label */
+ wrong_lb = gtk_label_new("FCS Filter:");
+ gtk_box_pack_start (GTK_BOX (basic_wrong_box), wrong_lb, FALSE, FALSE, 0);
+ gtk_widget_show(wrong_lb);
+
+ /* CRC Filter combo */
+ wrong_crc_combo = gtk_combo_new();
+ OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_WRONG_CRC_KEY,wrong_crc_combo);
+
+ linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_ALL);
+ linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_CORRECT);
+ linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT);
+
+ gtk_combo_set_popdown_strings( GTK_COMBO(wrong_crc_combo), linktype_list) ;
+
+ wrong_crc_te = GTK_COMBO(wrong_crc_combo)->entry;
+
+ if(airpcap_if_selected != NULL)
+ {
+ airpcap_validation_type_combo_set_by_type(wrong_crc_combo,airpcap_if_selected->CrcValidationOn);
+ }
+
+ gtk_editable_set_editable(GTK_EDITABLE(wrong_crc_te),FALSE);
+ SIGNAL_CONNECT(wrong_crc_te,"changed",wrong_crc_combo_cb,wrong_crc_te);
+ gtk_box_pack_start (GTK_BOX (basic_wrong_box), wrong_crc_combo, FALSE, FALSE, 0);
+ gtk_widget_show(wrong_crc_combo);
+
+ gtk_box_pack_start(GTK_BOX(basic_check_box), basic_wrong_box, FALSE, FALSE, 0);
+ gtk_widget_show(basic_wrong_box);
+
+ /* Add the vertical inner boxes to the basic_box */
+ gtk_box_pack_start (GTK_BOX (basic_box), basic_label_box, FALSE, FALSE, 10);
+ gtk_box_pack_start (GTK_BOX (basic_box), basic_combo_box, FALSE, FALSE, 10);
+ gtk_box_pack_start (GTK_BOX (basic_box), basic_check_box, FALSE, FALSE, 10);
+
+ gtk_container_set_border_width (GTK_CONTAINER (basic_box), 10);
+
+ /* Fill the wep_box */
+ wep_sub_box = gtk_hbox_new(FALSE,1);
+ gtk_widget_show(wep_sub_box);
+ encryption_box = gtk_hbox_new(FALSE,1);
+ gtk_widget_show(encryption_box);
+
+ /* encryption enabled box */
+ encryption_check = gtk_check_button_new_with_label("Enable WEP Decryption");
+ OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_DECRYPTION_KEY,encryption_check);
+
+ /* Fcs Presence check box */
+ if(airpcap_if_selected != NULL)
+ {
+ if(airpcap_if_selected->DecryptionOn == AIRPCAP_DECRYPTION_ON)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(encryption_check),TRUE);
+ else
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(encryption_check),FALSE);
+ }
+
+ SIGNAL_CONNECT(encryption_check,"toggled",encryption_check_cb,NULL);
+ gtk_box_pack_start (GTK_BOX (encryption_box), encryption_check, FALSE, FALSE, 0);
+ gtk_widget_show(encryption_check);
+
+ /* WEP text box */
+ key_text = scrolled_window_new(NULL, NULL);
+ /* never use a scrollbar in x direction, show the complete relation string */
+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(key_text),
+ GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ #if GTK_MAJOR_VERSION >= 2
+ gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(key_text),
+ GTK_SHADOW_IN);
+ #endif
+
+ /* add WEP keys if present... */
+ key_ls = gtk_list_new();
+ gtk_list_set_selection_mode(GTK_LIST(key_ls), GTK_SELECTION_SINGLE);
+ OBJECT_SET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY,key_ls);
+
+ airpcap_fill_key_list(key_ls,airpcap_if_selected);
+ gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(key_text),key_ls);
+ gtk_widget_show(key_ls);
+ gtk_box_pack_start (GTK_BOX (wep_sub_box), key_text, TRUE, TRUE, 0);
+ gtk_widget_show(key_text);
+
+ /* WEP buttons */
+ wep_buttons_box = gtk_vbox_new(FALSE,0);
+
+ /* Create and add buttons */
+ add_new_key_bt = gtk_button_new_with_label("Add New Key");
+ SIGNAL_CONNECT(add_new_key_bt, "clicked", airpcap_advanced_add_key_cb, airpcap_advanced_w);
+ gtk_box_pack_start (GTK_BOX (wep_buttons_box), add_new_key_bt, FALSE, FALSE, 0);
+ gtk_widget_show(add_new_key_bt);
+ remove_key_bt = gtk_button_new_with_label("Remove Key");
+ SIGNAL_CONNECT(remove_key_bt, "clicked", airpcap_advanced_remove_key_cb, key_ls);
+ gtk_box_pack_start (GTK_BOX (wep_buttons_box), remove_key_bt, FALSE, FALSE, 0);
+ gtk_widget_show(remove_key_bt);
+ edit_key_bt = gtk_button_new_with_label("Edit Key");
+ SIGNAL_CONNECT(edit_key_bt, "clicked", airpcap_advanced_edit_key_cb, airpcap_advanced_w);
+ gtk_box_pack_start (GTK_BOX (wep_buttons_box), edit_key_bt, FALSE, FALSE, 0);
+ gtk_widget_show(edit_key_bt);
+ move_key_up_bt = gtk_button_new_with_label("Move Key Up");
+ SIGNAL_CONNECT(move_key_up_bt, "clicked", airpcap_advanced_move_key_up_cb, key_ls);
+ gtk_box_pack_start (GTK_BOX (wep_buttons_box), move_key_up_bt, FALSE, FALSE, 0);
+ gtk_widget_show(move_key_up_bt);
+ move_key_down_bt = gtk_button_new_with_label("Move Key Down");
+ SIGNAL_CONNECT(move_key_down_bt, "clicked", airpcap_advanced_move_key_down_cb, key_ls);
+ gtk_box_pack_start (GTK_BOX (wep_buttons_box), move_key_down_bt, FALSE, FALSE, 0);
+ gtk_widget_show(move_key_down_bt);
+
+ gtk_box_pack_end (GTK_BOX (wep_sub_box), wep_buttons_box, FALSE, FALSE, 0);
+
+ gtk_container_set_border_width (GTK_CONTAINER (wep_sub_box), 10);
+
+ gtk_box_pack_start (GTK_BOX (wep_box), encryption_box, FALSE, FALSE,0);
+ gtk_box_pack_start (GTK_BOX (wep_box), wep_sub_box, FALSE, FALSE,0);
+ gtk_widget_show(wep_sub_box);
+
+ /* Add them to the frames */
+ gtk_container_add(GTK_CONTAINER(interface_frame),interface_box);
+ gtk_container_add(GTK_CONTAINER(basic_frame),basic_box);
+ gtk_container_add(GTK_CONTAINER(wep_frame),wep_box);
+
+ /* Add frames to the main box */
+ gtk_box_pack_start (GTK_BOX (main_box), interface_frame, FALSE, FALSE, 1);
+ gtk_box_pack_start (GTK_BOX (main_box), basic_frame, FALSE, FALSE, 1);
+ gtk_box_pack_start (GTK_BOX (main_box), wep_frame, FALSE, FALSE, 1);
+
+ /* Add buttons' boxes to the main box */
+ gtk_box_pack_start (GTK_BOX (main_box), buttons_box_2, FALSE, FALSE, 1);
+
+ /* Add the main box to the main window */
+ gtk_container_add(GTK_CONTAINER(airpcap_advanced_w),main_box);
+
+ /* SHOW EVERYTHING */
+ /* Show the WEP key buttons */
+ gtk_widget_show (wep_buttons_box);
+
+ /* Show the combo and check boxes */
+ gtk_widget_show (basic_label_box);
+ gtk_widget_show (basic_combo_box);
+ gtk_widget_show (basic_check_box);
+
+ /* Show the button boxes */
+ gtk_widget_show (buttons_box_1);
+ gtk_widget_show (buttons_box_2);
+
+ /* Show the frames */
+ gtk_widget_show (interface_frame);
+ gtk_widget_show (basic_frame);
+ gtk_widget_show (wep_frame);
+
+ /* Show the sub main boxes */
+ gtk_widget_show (interface_box);
+ gtk_widget_show (basic_box);
+ gtk_widget_show (wep_box);
+
+ /* Show the main box */
+ gtk_widget_show (main_box);
+
+ /* Show the window */
+ gtk_widget_show (airpcap_advanced_w);
+}
+
+#endif /* HAVE_AIRPCAP */
--- /dev/null
+/* airpcap_dlg.h
+ * Declarations of routines for the "Airpcap" dialog
+ *
+ * $Id$
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __AIRPCAP_DLG_H__
+#define __AIRPCAP_DLG_H__
+
+#define AIRPCAP_ADVANCED_FROM_TOOLBAR 0
+#define AIRPCAP_ADVANCED_FROM_OPTIONS 1
+
+/*
+ * Takes the keys from the GtkList widget, and add them to the interface list
+ */
+void airpcap_add_keys_from_list(GtkWidget *w, airpcap_if_info_t *if_info);
+
+/*
+ * Pop-up window, used to ask the user if he wants to save the selected interface settings
+ * when closing the window.
+ */
+void
+airpcap_ask_for_save_before_closing(GtkWidget *w _U_, gpointer data);
+
+/* user confirmed the "Save settings..." dialog */
+void
+airpcap_dialog_save_before_closing_cb(gpointer dialog _U_, gint btn, gpointer data);
+
+/*
+ * Pop-up window, used to ask the user if he wants to save the selected interface settings
+ */
+void
+airpcap_ask_for_save(GtkWidget *entry _U_, gpointer data);
+
+/*
+ * Function used to change the selected interface and advanced dialog box
+ */
+void
+airpcap_change_if(GtkWidget *entry _U_, gpointer data);
+
+/*
+ * Fill the interface combo box specified
+ */
+void
+airpcap_fill_if_combo(GtkWidget *combo, GList* if_list);
+
+/*
+ * Add key window destroy callback
+ */
+static void
+add_key_w_destroy_cb(GtkWidget *button, gpointer data _U_);
+
+/*
+ * Changed callback for the channel combobox
+ */
+static void
+channel_changed_cb(GtkWidget *w _U_, gpointer data);
+
+/*
+ * Activate callback for the link layer combobox
+ */
+static void
+link_layer_activate_cb(GtkWidget *w _U_, gpointer data);
+
+/*
+ * Changed callback for the link layer combobox
+ */
+static void
+link_layer_changed_cb(GtkWidget *w _U_, gpointer data);
+
+/*
+ * Callback for the crc chackbox
+ */
+static void
+crc_check_cb(GtkWidget *w, gpointer user_data);
+
+/*
+ * Callback for the wrong crc chackbox
+ */
+static void
+wrong_crc_check_cb(GtkWidget *w, gpointer user_data);
+
+/*
+ * Callbackfunction for WEP key list
+ */
+static void
+key_sel_list_cb(GtkWidget *l, gpointer data _U_);
+
+/*
+ * Callback function for WEP key list
+ */
+static gint
+key_sel_list_button_cb(GtkWidget *widget, GdkEventButton *event,gpointer func_data);
+
+/*
+ * Activate callback for the adapter combobox
+ */
+static void
+combo_if_activate_cb(GtkWidget *w _U_, gpointer data);
+
+/*
+ * Changed callback for the adapter combobox
+ */
+static void
+airpcap_advanced_combo_if_changed_cb(GtkWidget *w _U_, gpointer data);
+
+/*
+ * Pop-up window that appears when user confirms the "Save settings..." dialog
+ */
+static void
+airpcap_dialog_save_cb(GtkWidget* dialog _U_, gint btn, gpointer data);
+
+/*
+ * Thread function used to blink the led
+ */
+void update_blink(gpointer data _U_);
+
+/*
+ * Blink button callback
+ */
+void blink_cb(GtkWidget *blink_bt _U_, gpointer if_data);
+
+/** Create a "Airpcap" dialog box caused by a button click.
+ *
+ * @param widget parent widget
+ * @param construct_args_ptr parameters to construct the dialog (construct_args_t)
+ */
+void display_airpcap_advanced_cb(GtkWidget *widget, gpointer construct_args_ptr);
+
+#endif
--- /dev/null
+/* airpcap_gui_utils.c
+ *
+ * $Id$
+ *
+ * Ulf Lamping <ulf.lamping@web.de>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 2000 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#ifdef HAVE_AIRPCAP
+
+#include <gtk/gtk.h>
+#include <glib.h>
+
+#include <string.h>
+
+#include <epan/filesystem.h>
+
+#include "gtk/main.h"
+#include "dlg_utils.h"
+#include "gui_utils.h"
+#include "simple_dialog.h"
+#include "dfilter_expr_dlg.h"
+#include "compat_macros.h"
+#include "gtkglobals.h"
+#include "help_dlg.h"
+
+#include <airpcap.h>
+#include "airpcap_loader.h"
+#include "airpcap_gui_utils.h"
+
+#include "keys.h"
+
+/*
+ * Set up the airpcap toolbar for the new capture interface
+ */
+void
+airpcap_set_toolbar_start_capture(airpcap_if_info_t* if_info)
+{
+GtkWidget *airpcap_toolbar_crc_filter_combo;
+GtkWidget *airpcap_toolbar_label;
+GtkWidget *airpcap_toolbar_channel;
+GtkWidget *airpcap_toolbar_button;
+GtkWidget *airpcap_toolbar_decryption;
+
+gchar *if_label_text;
+
+airpcap_toolbar_crc_filter_combo = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_WRONG_CRC_KEY);
+airpcap_toolbar_label = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_INTERFACE_KEY);
+airpcap_toolbar_channel = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_CHANNEL_KEY);
+airpcap_toolbar_button = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_ADVANCED_KEY);
+airpcap_toolbar_decryption = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_DECRYPTION_KEY);
+
+/* The current interface is an airpcap interface */
+if(if_info != NULL)
+ {
+ gtk_widget_set_sensitive(airpcap_tb,TRUE);
+ gtk_widget_set_sensitive(airpcap_toolbar_channel,TRUE);
+ gtk_widget_set_sensitive(airpcap_toolbar_button,FALSE);
+ gtk_widget_set_sensitive(airpcap_toolbar_crc_filter_combo,FALSE);
+ gtk_widget_set_sensitive(airpcap_toolbar_button,FALSE);
+ gtk_widget_set_sensitive(airpcap_toolbar_decryption,FALSE);
+ airpcap_validation_type_combo_set_by_type(GTK_WIDGET(airpcap_toolbar_crc_filter_combo),if_info->CrcValidationOn);
+ airpcap_channel_combo_set_by_number(GTK_WIDGET(airpcap_toolbar_channel),if_info->channel);
+
+ /*decription check box*/
+ gtk_signal_handler_block_by_func (GTK_OBJECT(airpcap_toolbar_decryption),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), airpcap_tb);
+ if(if_info->DecryptionOn == AIRPCAP_DECRYPTION_ON)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(airpcap_toolbar_decryption),TRUE);
+ else
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(airpcap_toolbar_decryption),FALSE);
+ gtk_signal_handler_unblock_by_func (GTK_OBJECT(airpcap_toolbar_decryption),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), airpcap_tb);
+
+ if_label_text = g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(if_info));
+ gtk_label_set_text(GTK_LABEL(airpcap_toolbar_label),if_label_text);
+ g_free(if_label_text);
+ }
+else
+ {
+ if(airpcap_if_list != NULL)
+ {
+ gtk_widget_set_sensitive(airpcap_tb,FALSE);
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_crc_filter_combo)->entry),"");
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_channel)->entry),"");
+ gtk_label_set_text(GTK_LABEL(airpcap_toolbar_label),"Not a valid Wireless Interface");
+ }
+ else
+ {
+ gtk_widget_set_sensitive(airpcap_tb,FALSE);
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_crc_filter_combo)->entry),"");
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_channel)->entry),"");
+ gtk_label_set_text(GTK_LABEL(airpcap_toolbar_label),"No Wireless Interface Found");
+ }
+ }
+}
+
+/*
+ * Set up the airpcap toolbar for the new capture interface
+ */
+void
+airpcap_set_toolbar_stop_capture(airpcap_if_info_t* if_info)
+{
+GtkWidget *airpcap_toolbar_crc_filter_combo;
+GtkWidget *airpcap_toolbar_label;
+GtkWidget *airpcap_toolbar_channel;
+GtkWidget *airpcap_toolbar_button;
+GtkWidget *airpcap_toolbar_decryption;
+
+gchar *if_label_text;
+
+airpcap_toolbar_crc_filter_combo = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_WRONG_CRC_KEY);
+airpcap_toolbar_label = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_INTERFACE_KEY);
+airpcap_toolbar_channel = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_CHANNEL_KEY);
+airpcap_toolbar_button = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_ADVANCED_KEY);
+airpcap_toolbar_decryption = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_DECRYPTION_KEY);
+
+/* The current interface is an airpcap interface */
+if(if_info != NULL)
+ {
+ gtk_widget_set_sensitive(airpcap_tb,TRUE);
+ gtk_widget_set_sensitive(airpcap_toolbar_channel,TRUE);
+ gtk_widget_set_sensitive(airpcap_toolbar_button,TRUE);
+ gtk_widget_set_sensitive(airpcap_toolbar_crc_filter_combo,TRUE);
+ gtk_widget_set_sensitive(airpcap_toolbar_button,TRUE);
+ gtk_widget_set_sensitive(airpcap_toolbar_decryption,TRUE);
+ airpcap_validation_type_combo_set_by_type(GTK_WIDGET(airpcap_toolbar_crc_filter_combo),if_info->CrcValidationOn);
+ airpcap_channel_combo_set_by_number(GTK_WIDGET(airpcap_toolbar_channel),if_info->channel);
+
+ /*decription check box*/
+ gtk_signal_handler_block_by_func (GTK_OBJECT(airpcap_toolbar_decryption),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), airpcap_tb);
+ if(if_info->DecryptionOn == AIRPCAP_DECRYPTION_ON)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(airpcap_toolbar_decryption),TRUE);
+ else
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(airpcap_toolbar_decryption),FALSE);
+ gtk_signal_handler_unblock_by_func (GTK_OBJECT(airpcap_toolbar_decryption),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), airpcap_tb);
+
+
+ if_label_text = g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(if_info));
+ gtk_label_set_text(GTK_LABEL(airpcap_toolbar_label),if_label_text);
+ g_free(if_label_text);
+ }
+else
+ {
+ if(airpcap_if_list != NULL)
+ {
+ gtk_widget_set_sensitive(airpcap_tb,FALSE);
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_crc_filter_combo)->entry),"");
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_channel)->entry),"");
+ gtk_label_set_text(GTK_LABEL(airpcap_toolbar_label),"Not a valid Wireless Interface");
+ }
+ else
+ {
+ gtk_widget_set_sensitive(airpcap_tb,FALSE);
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_crc_filter_combo)->entry),"");
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_channel)->entry),"");
+ gtk_label_set_text(GTK_LABEL(airpcap_toolbar_label),"No Wireless Interface Found");
+ }
+ }
+}
+
+/*
+ * Add a key (string) to the given list
+ */
+void
+airpcap_add_key_to_list(GtkWidget *keylist, gchar* s)
+{
+GtkWidget *nl_item,*nl_lb;
+
+nl_lb = gtk_label_new(s);
+nl_item = gtk_list_item_new();
+
+gtk_misc_set_alignment (GTK_MISC (nl_lb), 0.0, 0.5);
+gtk_container_add(GTK_CONTAINER(nl_item), nl_lb);
+gtk_widget_show(nl_lb);
+gtk_container_add(GTK_CONTAINER(keylist), nl_item);
+gtk_widget_show(nl_item);
+}
+
+/*
+ * Fill the list with the keys
+ */
+void
+airpcap_fill_key_list(GtkWidget *keylist,airpcap_if_info_t* if_info)
+{
+GtkWidget *nl_item,*nl_lb;
+gchar* s;
+unsigned int i;
+
+ if( (if_info != NULL) && (if_info->keysCollection != NULL))
+ {
+ for(i = 0; i < if_info->keysCollection->nKeys; i++)
+ {
+ s = airpcap_get_key_string(if_info->keysCollection->Keys[i]);
+ nl_lb = gtk_label_new(s);
+ nl_item = gtk_list_item_new();
+ gtk_misc_set_alignment (GTK_MISC (nl_lb), 0.0, 0.5);
+ gtk_container_add(GTK_CONTAINER(nl_item), nl_lb);
+ gtk_widget_show(nl_lb);
+ gtk_container_add(GTK_CONTAINER(keylist), nl_item);
+ gtk_widget_show(nl_item);
+ }
+ }
+}
+
+/*
+ * Function used to retrieve the AirpcapValidationType given the string name.
+ */
+AirpcapValidationType
+airpcap_get_validation_type(const gchar* name)
+{
+ if(!(g_strcasecmp(AIRPCAP_VALIDATION_TYPE_NAME_ALL,name)))
+ {
+ return AIRPCAP_VT_ACCEPT_EVERYTHING;
+ }
+ else if(!(g_strcasecmp(AIRPCAP_VALIDATION_TYPE_NAME_CORRECT,name)))
+ {
+ return AIRPCAP_VT_ACCEPT_CORRECT_FRAMES;
+ }
+ else if(!(g_strcasecmp(AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT,name)))
+ {
+ return AIRPCAP_VT_ACCEPT_CORRUPT_FRAMES;
+ }
+ else
+ {
+ return AIRPCAP_VT_UNKNOWN;
+ }
+}
+
+/*
+ * Function used to retrieve the string name given an AirpcapValidationType,
+ * or NULL in case of error
+ */
+gchar*
+airpcap_get_validation_name(AirpcapValidationType vt)
+{
+ if(vt == AIRPCAP_VT_ACCEPT_EVERYTHING)
+ {
+ return AIRPCAP_VALIDATION_TYPE_NAME_ALL;
+ }
+ else if(vt == AIRPCAP_VT_ACCEPT_CORRECT_FRAMES)
+ {
+ return AIRPCAP_VALIDATION_TYPE_NAME_CORRECT;
+ }
+ else if(vt == AIRPCAP_VT_ACCEPT_CORRUPT_FRAMES)
+ {
+ return AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT;
+ }
+ else if(vt == AIRPCAP_VT_UNKNOWN)
+ {
+ return AIRPCAP_VALIDATION_TYPE_NAME_UNKNOWN;
+ }
+ return NULL;
+}
+
+/*
+ * Returns the AirpcapLinkType corresponding to the given string name.
+ */
+AirpcapLinkType
+airpcap_get_link_type(const gchar* name)
+{
+ if(!(g_strcasecmp(AIRPCAP_LINK_TYPE_NAME_802_11_ONLY,name)))
+ {
+ return AIRPCAP_LT_802_11;
+ }
+ else if(!(g_strcasecmp(AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO,name)))
+ {
+ return AIRPCAP_LT_802_11_PLUS_RADIO;
+ }
+ else
+ {
+ return AIRPCAP_LT_UNKNOWN;
+ }
+}
+
+/*
+ * Returns the string name corresponding to the given AirpcapLinkType, or
+ * NULL in case of error.
+ */
+gchar*
+airpcap_get_link_name(AirpcapLinkType lt)
+{
+ if(lt == AIRPCAP_LT_802_11)
+ {
+ return AIRPCAP_LINK_TYPE_NAME_802_11_ONLY;
+ }
+ else if(lt == AIRPCAP_LT_802_11_PLUS_RADIO)
+ {
+ return AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO;
+ }
+ else if(lt == AIRPCAP_LT_UNKNOWN)
+ {
+ return AIRPCAP_LINK_TYPE_NAME_UNKNOWN;
+ }
+ return NULL;
+}
+
+/*
+ * Sets the entry of the link type combo using the AirpcapLinkType.
+ */
+void
+airpcap_link_type_combo_set_by_type(GtkWidget* c, AirpcapLinkType type)
+{
+gchar* s;
+
+s = airpcap_get_link_name(type);
+gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(c)->entry),s);
+}
+
+/*
+ * Retrieves the name in link type the combo entry.
+ */
+AirpcapLinkType
+airpcap_link_type_combo_get_type(GtkWidget* c)
+{
+const gchar* s;
+
+s = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(c)->entry));
+
+return airpcap_get_link_type(s);
+}
+
+/*
+ * Sets the entry of the validation combo using the AirpcapValidationType.
+ */
+void
+airpcap_validation_type_combo_set_by_type(GtkWidget* c, AirpcapValidationType type)
+{
+const gchar* s;
+
+s = airpcap_get_validation_name(type);
+gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(c)->entry),s);
+}
+
+/*
+ * Retrieves the name in the validation combo entry.
+ */
+AirpcapValidationType
+airpcap_validation_type_combo_get_type(GtkWidget* c)
+{
+const gchar* s;
+
+s = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(c)->entry));
+
+return airpcap_get_validation_type(s);
+}
+
+/*
+ * Retrieve the UINT corresponding to the given string (channel only, handle with care!)
+ */
+UINT
+airpcap_get_channel_number(const gchar* s)
+{
+int ch_num;
+
+sscanf(s,"%d",&ch_num);
+
+/* XXX - check for ch_num btween 1-14, and return -1 otherwise??? */
+
+return ch_num;
+}
+
+/*
+ * Returns the string corresponding to the given UINT (1-14, for channel only)
+ */
+gchar*
+airpcap_get_channel_name(UINT n)
+{
+return g_strdup_printf("%d",n);
+}
+
+/*
+ * Set the combo box entry string given an UINT channel number
+ */
+void
+airpcap_channel_combo_set_by_number(GtkWidget* w,UINT channel)
+{
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),airpcap_get_channel_name(channel));
+}
+
+#endif /* HAVE_AIRPCAP */
--- /dev/null
+/* airpcap_utils.h
+ * Declarations of utility routines for the "Airpcap" dialog widgets
+ *
+ * $Id$
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __AIRPCAP_GUI_UTILS_H__
+#define __AIRPCAP_GUI_UTILS_H__
+
+#define AIRPCAP_VALIDATION_TYPE_NAME_ALL "All Frames"
+#define AIRPCAP_VALIDATION_TYPE_NAME_CORRECT "Valid Frames"
+#define AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT "Invalid Frames"
+#define AIRPCAP_VALIDATION_TYPE_NAME_UNKNOWN "Unknown"
+
+#define AIRPCAP_LINK_TYPE_NAME_802_11_ONLY "802.11 Only"
+#define AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO "802.11 + Radio"
+#define AIRPCAP_LINK_TYPE_NAME_UNKNOWN "Unknown"
+
+/*
+ * set up the airpcap toolbar for the new capture interface
+ */
+void
+airpcap_set_toolbar_start_capture(airpcap_if_info_t* if_info);
+
+/*
+ * Set up the airpcap toolbar for the new capture interface
+ */
+void
+airpcap_set_toolbar_stop_capture(airpcap_if_info_t* if_info);
+
+/*
+ * Add a key (string) to the given list
+ */
+void
+airpcap_add_key_to_list(GtkWidget *keylist, gchar* s);
+
+/*
+ * Fill the list with the keys
+ */
+void
+airpcap_fill_key_list(GtkWidget *keylist,airpcap_if_info_t* if_info);
+
+/*
+ * Function used to retrieve the AirpcapValidationType given the string name.
+ */
+AirpcapValidationType
+airpcap_get_validation_type(const gchar* name);
+
+/*
+ * Function used to retrieve the string name given an AirpcapValidationType.
+ */
+gchar*
+airpcap_get_validation_name(AirpcapValidationType vt);
+
+/*
+ * Returns the AirpcapLinkType corresponding to the given string name.
+ */
+AirpcapLinkType
+airpcap_get_link_type(const gchar* name);
+
+/*
+ * Returns the string name corresponding to the given AirpcapLinkType.
+ */
+gchar*
+airpcap_get_link_name(AirpcapLinkType lt);
+
+/*
+ * Sets the entry of the link type combo using the AirpcapLinkType.
+ */
+void
+airpcap_link_type_combo_set_by_type(GtkWidget* c, AirpcapLinkType type);
+
+/*
+ * Retrieves the name in link type the combo entry.
+ */
+AirpcapLinkType
+airpcap_link_type_combo_get_type(GtkWidget* c);
+
+/*
+ * Sets the entry of the validation combo using the AirpcapValidationType.
+ */
+void
+airpcap_validation_type_combo_set_by_type(GtkWidget* c,AirpcapValidationType type);
+
+/*
+ * Retrieves the name in the validation combo entry.
+ */
+AirpcapValidationType
+airpcap_validation_type_combo_get_type(GtkWidget* c);
+
+/*
+ * Returns the string corresponding to the given UINT (1-14, for channel only)
+ */
+UINT
+airpcap_get_channel_number(const gchar* s);
+
+/*
+ * Retrieve the UINT corresponding to the given string (channel only, handle with care!)
+ */
+gchar*
+airpcap_get_channel_name(UINT n);
+
+/*
+ * Set the combo box entry string given an UINT channel number
+ */
+void
+airpcap_channel_combo_set_by_number(GtkWidget* w,UINT channel);
+
+#endif
#include "capture-wpcap.h"
#endif
+#include "keys.h"
+
+#ifdef HAVE_AIRPCAP
+#include <airpcap.h>
+#include "airpcap_loader.h"
+#include "airpcap_gui_utils.h"
+#include "airpcap_dlg.h"
+#endif
+
/* Capture callback data keys */
#define E_CAP_IFACE_KEY "cap_iface"
#define E_CAP_IFACE_IP_KEY "cap_iface_ip"
*/
static GtkWidget *cap_open_w;
-
static void
capture_prep_file_cb(GtkWidget *file_bt, GtkWidget *file_te);
void
capture_stop_cb(GtkWidget *w _U_, gpointer d _U_)
{
+#ifdef HAVE_AIRPCAP
+ airpcap_set_toolbar_stop_capture(airpcap_if_active);
+#endif
+
capture_stop(capture_opts);
}
void
capture_restart_cb(GtkWidget *w _U_, gpointer d _U_)
{
+#ifdef HAVE_AIRPCAP
+ airpcap_set_toolbar_start_capture(airpcap_if_active);
+#endif
+
capture_restart(capture_opts);
}
int ips = 0;
GSList *curr_ip;
if_addr_t *ip_addr;
+#ifdef HAVE_AIRPCAP
+ GtkWidget *advanced_bt;
+#endif
lt_menu = gtk_menu_new();
entry_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
if_text = g_strstrip(entry_text);
if_name = get_if_name(if_text);
+#ifdef HAVE_AIRPCAP
+ /* is it an airpcap interface??? */
+ /* retrieve the advanced button pointer */
+ advanced_bt = OBJECT_GET_DATA(entry,AIRPCAP_OPTIONS_ADVANCED_KEY);
+ airpcap_if_selected = get_airpcap_if_by_name(airpcap_if_list,if_name);
+ gtk_widget_set_sensitive(airpcap_tb,FALSE);
+ if( airpcap_if_selected != NULL)
+ {
+ gtk_widget_set_sensitive(advanced_bt,TRUE);
+ }
+ else
+ {
+ gtk_widget_set_sensitive(advanced_bt,FALSE);
+ }
+#endif
+
/*
* If the interface name is in the list of known interfaces, get
* its list of link-layer types and set the option menu to display it.
}
}
+#ifdef HAVE_AIRPCAP
+/*
+ * Sets the toolbar before calling the advanced dialog with for the right interface
+ */
+void
+options_airpcap_advanced_cb(GtkWidget *w _U_, gpointer d _U_)
+{
+int *from_widget;
+
+from_widget = (gint*)g_malloc(sizeof(gint));
+*from_widget = AIRPCAP_ADVANCED_FROM_OPTIONS;
+OBJECT_SET_DATA(airpcap_tb,AIRPCAP_ADVANCED_FROM_KEY,from_widget);
+
+airpcap_if_active = airpcap_if_selected;
+gtk_widget_set_sensitive(airpcap_tb,FALSE);
+display_airpcap_advanced_cb(w,d);
+}
+#endif
/* show capture prepare (options) dialog */
void
*snap_hb, *snap_cb, *snap_sb, *snap_lb,
*promisc_cb,
*filter_hb, *filter_bt, *filter_te, *filter_cm,
+ *advanced_hb,
*file_fr, *file_vb,
*file_hb, *file_bt, *file_lb, *file_te,
*resolv_fr, *resolv_vb,
*m_resolv_cb, *n_resolv_cb, *t_resolv_cb,
*bbox, *ok_bt, *cancel_bt,
- *help_bt;
+ *help_bt,
+ *advanced_bt;
#if GTK_MAJOR_VERSION < 2
GtkAccelGroup *accel_group;
#endif
gchar *cap_title;
gchar *if_device;
+ gint *from_widget = NULL;
+
if (cap_open_w != NULL) {
/* There's already a "Capture Options" dialog box; reactivate it. */
g_free(cant_get_if_list_errstr);
}
+#ifdef HAVE_AIRPCAP
+ /* update airpcap interface list */
+ /* load the airpcap interfaces */
+ airpcap_if_list = get_airpcap_interface_list(&err, err_str);
+
+ if (airpcap_if_list == NULL && err == CANT_GET_AIRPCAP_INTERFACE_LIST) {
+ cant_get_if_list_errstr = cant_get_airpcap_if_list_error_message(err_str);
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s",
+ cant_get_if_list_errstr);
+ g_free(cant_get_if_list_errstr);
+ }
+
+ /* select the first ad default (THIS SHOULD BE CHANGED) */
+ airpcap_if_active = airpcap_get_default_if(airpcap_if_list);
+#endif
+
/* use user-defined title if preference is set */
cap_title = create_user_window_title("Wireshark: Capture Options");
capture_opts->iface = g_strdup(get_if_name(if_device));
g_free(if_device);
}
+
+#ifdef HAVE_AIRPCAP
+ /* get the airpcap interface (if it IS an airpcap interface, and update the
+ toolbar... and of course enable the advanced button...)*/
+ airpcap_if_selected = get_airpcap_if_by_name(airpcap_if_list,capture_opts->iface);
+#endif
+
if (capture_opts->iface != NULL) {
if_device = build_capture_combo_name(if_list, capture_opts->iface);
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(if_cb)->entry), if_device);
gtk_box_pack_start (GTK_BOX(linktype_hb), buffer_size_sb, FALSE, FALSE, 0);
buffer_size_lb = gtk_label_new("megabyte(s)");
- gtk_box_pack_start (GTK_BOX(linktype_hb), buffer_size_lb, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX(linktype_hb), buffer_size_lb, FALSE, FALSE, 6);
#endif
/* Promiscuous mode row */
/* let an eventually capture filters dialog know the text entry to fill in */
OBJECT_SET_DATA(filter_bt, E_FILT_TE_PTR_KEY, filter_te);
+ /* advanced row */
+ advanced_hb = gtk_hbox_new(FALSE,5);
+ gtk_box_pack_start(GTK_BOX(capture_vb), advanced_hb, FALSE, FALSE, 0);
+ advanced_bt = gtk_button_new();
+
+ /* set the text */
+ #if GTK_MAJOR_VERSION >= 2
+ /* XXX - find a way to set the GtkButton label in GTK 1.x */
+ gtk_button_set_label(GTK_BUTTON(advanced_bt), "Wireless Settings");
+ #else
+ /* Set the GtkButton label in GTK 1.x */
+ gtk_label_set_text(GTK_LABEL(GTK_BIN(advanced_bt)->child), "Wireless Settings");
+ #endif
+
+#ifdef HAVE_AIRPCAP
+ /* Both the callback and the data are global */
+ SIGNAL_CONNECT(advanced_bt,"clicked",options_airpcap_advanced_cb,airpcap_tb);
+ OBJECT_SET_DATA(GTK_ENTRY(GTK_COMBO(if_cb)->entry),AIRPCAP_OPTIONS_ADVANCED_KEY,advanced_bt);
+
+ if(airpcap_if_selected != NULL)
+ {
+ /* It is an airpcap interface */
+ gtk_widget_set_sensitive(advanced_bt,TRUE);
+ }
+ else
+ {
+ gtk_widget_set_sensitive(advanced_bt,FALSE);
+ }
+#endif
+
+ gtk_box_pack_start(GTK_BOX(linktype_hb),advanced_bt,FALSE,FALSE,0);
+ gtk_widget_show(advanced_bt);
+ gtk_widget_show(advanced_hb);
+
/* Capture file-related options frame */
file_fr = gtk_frame_new("Capture File(s)");
gtk_container_add(GTK_CONTAINER(left_vb), file_fr);
{
gpointer dialog;
+#ifdef HAVE_AIRPCAP
+ airpcap_if_active = airpcap_if_selected;
+ airpcap_set_toolbar_start_capture(airpcap_if_active);
+#endif
+
#ifdef _WIN32
/* Is WPcap loaded? */
if (!has_wpcap) {
/* Note that we no longer have a "Capture Options" dialog box. */
cap_open_w = NULL;
+
+#ifdef HAVE_AIRPCAP
+ /* update airpcap toolbar */
+ airpcap_set_toolbar_stop_capture(airpcap_if_active);
+#endif
}
/* user changed the interface entry */
capture_prep_interface_changed_cb(GtkWidget *entry, gpointer argp)
{
GtkWidget *linktype_om = argp;
-
set_link_type_list(linktype_om, entry);
}
#ifndef __CAPTURE_DLG_H__
#define __CAPTURE_DLG_H__
+extern GtkWidget* airpcap_tb;
+
/** @file
* "Capture Options" dialog box.
* @ingroup dialog_group
void
capture_if_cb(GtkWidget *widget, gpointer data);
+/** User requested the "Capture Airpcap" dialog box by menu or toolbar.
+ *
+ * @param widget parent widget (unused)
+ * @param data unused
+ */
+void
+capture_air_cb(GtkWidget *widget, gpointer data);
+
/** User requested the "Capture Interfaces" dialog box by menu or toolbar.
*
* @param capture_in_progress capture is in progress
#include "capture_dlg.h"
#include "capture_if_details_dlg.h"
#include "capture_errs.h"
+#include "recent.h"
+#include <epan/prefs.h>
#include "gui_utils.h"
#include "dlg_utils.h"
-#include "wtap.h"
#include "main.h"
+#include "wtap.h"
#include "help_dlg.h"
#include "toolbar.h"
+#include "keys.h"
+
+#include "webbrowser.h"
+
+#ifdef HAVE_AIRPCAP
+#include "../image/toolbar/capture_airpcap_16.xpm"
+#endif
+#include "../image/toolbar/capture_ethernet_16.xpm"
+
+/* new buttons to be used instead of labels for 'Capture','Prepare',' */
+#include "../image/toolbar/capture_capture_16.xpm"
+#include "../image/toolbar/capture_prepare_16.xpm"
+#include "../image/toolbar/capture_details_16.xpm"
+
+
+#ifdef HAVE_AIRPCAP
+#include <airpcap.h>
+#include "airpcap_loader.h"
+#include "airpcap_gui_utils.h"
+#include "airpcap_dlg.h"
+#endif
/*
* Keep a static pointer to the current "Capture Interfaces" window, if
* already a "Capture Interfaces" window up, we just pop up the existing
* one, rather than creating a new one.
*/
-static GtkWidget *cap_if_w;
+static GtkWidget *cap_if_w, *cap_air_w;
GList *if_data = NULL;
static void
capture_do_cb(GtkWidget *capture_bt _U_, gpointer if_data)
{
- if_dlg_data_t *if_dlg_data = if_data;
+if_dlg_data_t *if_dlg_data = if_data;
+
+#ifdef HAVE_AIRPCAP
+airpcap_if_active = get_airpcap_if_from_description(airpcap_if_list, GTK_LABEL(if_dlg_data->descr_lb)->label);
+airpcap_if_selected = airpcap_if_active;
+#endif
if (capture_opts->iface)
g_free(capture_opts->iface);
#else
diff = stats.ps_recv;
if_dlg_data->last_packets = stats.ps_recv + if_dlg_data->last_packets;
-#endif
+#endif
str = g_strdup_printf("%u", if_dlg_data->last_packets);
gtk_label_set_text(GTK_LABEL(if_dlg_data->curr_lb), str);
if(cap_if_w) {
gtk_widget_set_sensitive(stop_bt, capture_in_progress);
-
+
for(ifs = 0; (curr = g_list_nth(if_data, ifs)); ifs++) {
if_dlg_data_t *if_dlg_data = curr->data;
gtk_widget_set_sensitive(if_dlg_data->capture_bt, !capture_in_progress);
gtk_widget_set_sensitive(if_dlg_data->prepare_bt, !capture_in_progress);
- }
+ }
}
}
/* Note that we no longer have a "Capture Options" dialog box. */
cap_if_w = NULL;
+
+#ifdef HAVE_AIRPCAP
+ airpcap_set_toolbar_stop_capture(airpcap_if_active);
+#endif
}
+GtkWidget*
+combo_channel_new(void)
+{
+ GtkWidget* channel_cb;
+ GList* popdown;
+
+
+ channel_cb = gtk_combo_new();
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_cb)->entry), "1");
+
+ popdown = NULL;
+
+ popdown = g_list_append(popdown, "1");
+ popdown = g_list_append(popdown, "2");
+ popdown = g_list_append(popdown, "3");
+ popdown = g_list_append(popdown, "4");
+ popdown = g_list_append(popdown, "5");
+ popdown = g_list_append(popdown, "6");
+ popdown = g_list_append(popdown, "7");
+ popdown = g_list_append(popdown, "8");
+ popdown = g_list_append(popdown, "9");
+ popdown = g_list_append(popdown, "10");
+ popdown = g_list_append(popdown, "11");
+ popdown = g_list_append(popdown, "12");
+ popdown = g_list_append(popdown, "13");
+ popdown = g_list_append(popdown, "14");
+
+ gtk_combo_set_popdown_strings( GTK_COMBO(channel_cb), popdown) ;
+
+ #if GTK_MAJOR_VERSION < 2
+ gtk_widget_set_usize( GTK_WIDGET(channel_cb),
+ 45,
+ 10 );
+ #else
+ gtk_widget_set_size_request( GTK_WIDGET(channel_cb),
+ 45,
+ 10 );
+ #endif
+
+
+ return channel_cb;
+}
/* start getting capture stats from all interfaces */
void
capture_if_cb(GtkWidget *w _U_, gpointer d _U_)
{
- GtkWidget *main_vb, *main_sw, *bbox, *close_bt, *help_bt;
+ GtkWidget *main_vb,
+ *main_sw,
+ *bbox,
+ *close_bt,
+ *help_bt,
+ *icon;
GtkWidget *if_tb;
GtkWidget *if_lb;
}
#endif
+ /* LOAD THE INTERFACES */
if_list = get_interface_list(&err, err_str);
if (if_list == NULL && err == CANT_GET_INTERFACE_LIST) {
cant_get_if_list_errstr = cant_get_if_list_error_message(err_str);
return;
}
+#ifdef HAVE_AIRPCAP
+ /* LOAD AIRPCAP INTERFACES */
+ /* load the airpcap interfaces */
+ airpcap_if_list = get_airpcap_interface_list(&err, err_str);
+
+ if (airpcap_if_list == NULL && err == CANT_GET_AIRPCAP_INTERFACE_LIST) {
+ cant_get_if_list_errstr = cant_get_airpcap_if_list_error_message(err_str);
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s",
+ cant_get_if_list_errstr);
+ g_free(cant_get_if_list_errstr);
+ }
+
+ /* If no airpcap interface is present, gray everything */
+ if(airpcap_if_active == NULL)
+ {
+ if(airpcap_if_list == NULL)
+ {
+ /*No airpcap device found */
+ gtk_widget_set_sensitive(airpcap_tb,FALSE);
+ }
+ else
+ {
+ /* default adapter is not airpcap... or is airpcap but is not found*/
+ airpcap_set_toolbar_stop_capture(airpcap_if_active);
+ gtk_widget_set_sensitive(airpcap_tb,FALSE);
+ }
+ }
+
+ airpcap_set_toolbar_start_capture(airpcap_if_active);
+#endif
+
cap_if_w = window_new(GTK_WINDOW_TOPLEVEL, "Wireshark: Capture Interfaces");
tooltips = gtk_tooltips_new();
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(main_sw), main_vb);
- if_tb = gtk_table_new(6,1, FALSE);
+ if_tb = gtk_table_new(1,9, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(if_tb), 3);
gtk_table_set_col_spacings(GTK_TABLE(if_tb), 3);
gtk_box_pack_start(GTK_BOX(main_vb), if_tb, FALSE, FALSE, 0);
row = 0;
height = 0;
+ /* This is the icon column, used to display which kind of interface we have */
+ if_lb = gtk_label_new("");
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), if_lb, 0, 1, row, row+1);
+
#ifndef _WIN32
/*
* On Windows, device names are generally not meaningful - NT 5
* bother showing them.
*/
if_lb = gtk_label_new("Device");
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_lb, 0, 1, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), if_lb, 1, 2, row, row+1);
#endif
if_lb = gtk_label_new("Description");
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_lb, 1, 2, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), if_lb, 2, 3, row, row+1);
if_lb = gtk_label_new(" IP ");
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_lb, 2, 3, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), if_lb, 3, 4, row, row+1);
if_lb = gtk_label_new("Packets");
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_lb, 3, 4, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), if_lb, 4, 5, row, row+1);
if_lb = gtk_label_new(" Packets/s ");
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_lb, 4, 5, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), if_lb, 5, 6, row, row+1);
stop_bt = BUTTON_NEW_FROM_STOCK(GTK_STOCK_STOP);
- gtk_tooltips_set_tip(tooltips, stop_bt,
+ gtk_tooltips_set_tip(tooltips, stop_bt,
"Stop a running capture.", NULL);
#ifdef _WIN32
- gtk_table_attach_defaults(GTK_TABLE(if_tb), stop_bt, 5, 8, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), stop_bt, 6, 9, row, row+1);
#else
- gtk_table_attach_defaults(GTK_TABLE(if_tb), stop_bt, 5, 7, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), stop_bt, 6, 8, row, row+1);
#endif
SIGNAL_CONNECT(stop_bt, "clicked", capture_stop_cb, NULL);
if_info = curr->data;
if_dlg_data = g_malloc0(sizeof(if_dlg_data_t));
+
+ /* Kind of adaptor (icon) */
+#ifdef HAVE_AIRPCAP
+ if(get_airpcap_if_from_description(airpcap_if_list,if_info->description) != NULL)
+ icon = xpm_to_widget(capture_airpcap_16_xpm);
+ else
+ icon = xpm_to_widget(capture_ethernet_16_xpm);
+#else
+ icon = xpm_to_widget(capture_ethernet_16_xpm);
+#endif
+
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), icon, 0, 1, row, row+1);
+
/* device name */
if_dlg_data->device_lb = gtk_label_new(if_info->name);
if_dlg_data->device = if_info->name;
#ifndef _WIN32
gtk_misc_set_alignment(GTK_MISC(if_dlg_data->device_lb), 0.0, 0.5);
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->device_lb, 0, 1, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->device_lb, 1, 2, row, row+1);
#endif
g_string_append(if_tool_str, "Device: ");
g_string_append(if_tool_str, if_info->name);
else
if_dlg_data->descr_lb = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(if_dlg_data->descr_lb), 0.0, 0.5);
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->descr_lb, 1, 2, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->descr_lb, 2, 3, row, row+1);
if (if_info->description) {
g_string_append(if_tool_str, "Description: ");
gtk_widget_set_sensitive(if_dlg_data->ip_lb, FALSE);
g_string_append(if_tool_str, "unknown");
}
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->ip_lb, 2, 3, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->ip_lb, 3, 4, row, row+1);
g_string_append(if_tool_str, "\n");
/* packets */
if_dlg_data->curr_lb = gtk_label_new("-");
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->curr_lb, 3, 4, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->curr_lb, 4, 5, row, row+1);
/* packets/s */
if_dlg_data->last_lb = gtk_label_new("-");
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->last_lb, 4, 5, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->last_lb, 5, 6, row, row+1);
/* capture button */
if_dlg_data->capture_bt = gtk_button_new_with_label("Capture");
- SIGNAL_CONNECT(if_dlg_data->capture_bt, "clicked", capture_do_cb, if_dlg_data);
+ SIGNAL_CONNECT(if_dlg_data->capture_bt, "clicked", capture_do_cb, if_dlg_data);
tmp_str = g_strdup_printf("Immediately start a capture from this interface:\n\n%s", if_tool_str->str);
- gtk_tooltips_set_tip(tooltips, if_dlg_data->capture_bt,
+ gtk_tooltips_set_tip(tooltips, if_dlg_data->capture_bt,
tmp_str, NULL);
g_free(tmp_str);
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->capture_bt, 5, 6, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->capture_bt, 6, 7, row, row+1);
/* prepare button */
if_dlg_data->prepare_bt = gtk_button_new_with_label("Prepare");
SIGNAL_CONNECT(if_dlg_data->prepare_bt, "clicked", capture_prepare_cb, if_dlg_data);
- gtk_tooltips_set_tip(tooltips, if_dlg_data->prepare_bt,
+ gtk_tooltips_set_tip(tooltips, if_dlg_data->prepare_bt,
"Open the capture options dialog with this interface selected.", NULL);
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->prepare_bt, 6, 7, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->prepare_bt, 7, 8, row, row+1);
/* details button */
#ifdef _WIN32
if_dlg_data->details_bt = gtk_button_new_with_label("Details");
- SIGNAL_CONNECT(if_dlg_data->details_bt, "clicked", capture_details_cb, if_dlg_data);
- gtk_tooltips_set_tip(tooltips, if_dlg_data->details_bt,
+ gtk_container_add (GTK_CONTAINER (if_dlg_data->details_bt), xpm_box(capture_details_16_xpm));
+ SIGNAL_CONNECT(if_dlg_data->details_bt, "clicked", capture_details_cb, if_dlg_data);
+ gtk_tooltips_set_tip(tooltips, if_dlg_data->details_bt,
"Open the capture details dialog of this interface.", NULL);
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->details_bt, 7, 8, row, row+1);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->details_bt, 8, 9, row, row+1);
#endif
open_if(if_info->name, if_dlg_data);
gtk_widget_size_request(GTK_WIDGET(close_bt), &requisition);
/* height + static offset + what GTK-Wimp needs in addition per interface */
- height += requisition.height + 26 + ifs;
+ /* XXX - Modify or the window will become huge with many interfaces! */
+ height += requisition.height + 26 + 16;
gtk_window_set_default_size(GTK_WINDOW(cap_if_w), -1, height);
gtk_widget_grab_default(close_bt);
#include "main.h"
#include "capture-pcap-util.h"
+#ifdef HAVE_AIRPCAP
+#include <airpcap.h>
+#include "airpcap_loader.h"
+#include "airpcap_gui_utils.h"
+#include "airpcap_dlg.h"
+#endif
+
/* a single capture counter value (with title, pointer to value and GtkWidgets) */
/* as the packet_counts is a struct, not an array, keep a pointer to the */
static gboolean
capture_info_delete_cb(GtkWidget *w _U_, GdkEvent *event _U_, gpointer data _U_) {
+#ifdef HAVE_AIRPCAP
+ airpcap_set_toolbar_stop_capture(airpcap_if_active);
+#endif
+
capture_stop(capture_opts);
return TRUE;
}
#ifdef HAVE_LIBPCAP
#define WIRESHARK_STOCK_CAPTURE_INTERFACES "Interfaces"
+#define WIRESHARK_STOCK_CAPTURE_AIRPCAP "Airpcap"
#define WIRESHARK_STOCK_CAPTURE_OPTIONS "Options"
#define WIRESHARK_STOCK_CAPTURE_START "Start"
#define WIRESHARK_STOCK_CAPTURE_STOP "Stop"
#ifdef HAVE_LIBPCAP
#define WIRESHARK_STOCK_LABEL_CAPTURE_INTERFACES "_Interfaces"
+#define WIRESHARK_STOCK_LABEL_CAPTURE_AIRPCAP "_Wireless"
#define WIRESHARK_STOCK_LABEL_CAPTURE_OPTIONS "_Options"
#define WIRESHARK_STOCK_LABEL_CAPTURE_START "_Start"
#define WIRESHARK_STOCK_LABEL_CAPTURE_STOP "S_top"
#ifdef HAVE_LIBPCAP
#define WIRESHARK_STOCK_CAPTURE_INTERFACES "Wireshark_Stock_CaptureInterfaces"
+#define WIRESHARK_STOCK_CAPTURE_AIRPCAP "Wireshark_Stock_CaptureAirpcap"
#define WIRESHARK_STOCK_CAPTURE_OPTIONS "Wireshark_Stock_CaptureOptionss"
#define WIRESHARK_STOCK_CAPTURE_START "Wireshark_Stock_CaptureStart"
#define WIRESHARK_STOCK_CAPTURE_STOP "Wireshark_Stock_CaptureStop"
return xpm_to_widget_from_parent(top_level, xpm);
}
+/* Create a new hbox with an image packed into it
+ * and return the box. */
+GtkWidget *xpm_box( gchar **xpm )
+{
+ GtkWidget *box;
+ GtkWidget *image;
+
+ /* Create box for image */
+ box = gtk_hbox_new (FALSE, 0);
+ gtk_container_set_border_width (GTK_CONTAINER (box), 3);
+
+ /* Now on to the image stuff */
+ image = xpm_to_widget (xpm);
+
+ /* Pack the image into the box */
+ gtk_box_pack_start (GTK_BOX (box), image, FALSE, FALSE, 3);
+
+ return box;
+}
+
/* Set the name of the top-level window and its icon to the specified
string. */
*/
extern GtkWidget *xpm_to_widget_from_parent(GtkWidget *parent, const char ** xpm);
+/** Create a new hbox with an image packed into it
+ * and return the box.
+ *
+ * @param xpm the character array containing the picture
+ * @return a newly created GtkHBox containing the picture
+ */
+GtkWidget *xpm_box( gchar **xpm );
+
/** Copy a GString to the clipboard.
*
* @param str GString that is to be copied to the clipboard.
* Various keys for OBJECT_SET_DATA().
*/
-#define E_DFILTER_TE_KEY "display_filter_entry"
-#define E_RFILTER_TE_KEY "read_filter_te"
-#define E_MPACKET_LIST_KEY "menu_packet_list"
-#define E_MPACKET_LIST_ROW_KEY "menu_packet_list_row"
-#define E_MPACKET_LIST_COL_KEY "menu_packet_list_col"
-
-#define PRINT_CMD_LB_KEY "printer_command_label"
-#define PRINT_CMD_TE_KEY "printer_command_entry"
-#define PRINT_FILE_BT_KEY "printer_file_button"
-#define PRINT_FILE_TE_KEY "printer_file_entry"
-
-#define PLUGINS_DFILTER_TE "plugins_dfilter_te"
-
-#define PM_MENU_LIST_KEY "popup_menu_menu_list"
-#define PM_PACKET_LIST_KEY "popup_menu_packet_list"
-#define PM_TREE_VIEW_KEY "popup_menu_tree_view"
-#define PM_HEXDUMP_KEY "popup_menu_hexdump"
+#define E_DFILTER_TE_KEY "display_filter_entry"
+#define E_RFILTER_TE_KEY "read_filter_te"
+#define E_MPACKET_LIST_KEY "menu_packet_list"
+#define E_MPACKET_LIST_ROW_KEY "menu_packet_list_row"
+#define E_MPACKET_LIST_COL_KEY "menu_packet_list_col"
+
+#define PRINT_CMD_LB_KEY "printer_command_label"
+#define PRINT_CMD_TE_KEY "printer_command_entry"
+#define PRINT_FILE_BT_KEY "printer_file_button"
+#define PRINT_FILE_TE_KEY "printer_file_entry"
+
+#define PLUGINS_DFILTER_TE "plugins_dfilter_te"
+
+#define PM_MENU_LIST_KEY "popup_menu_menu_list"
+#define PM_PACKET_LIST_KEY "popup_menu_packet_list"
+#define PM_TREE_VIEW_KEY "popup_menu_tree_view"
+#define PM_HEXDUMP_KEY "popup_menu_hexdump"
+
+#ifdef HAVE_AIRPCAP
+#define AIRPCAP_TOOLBAR_KEY "airpcap_toolbar_key"
+#define AIRPCAP_TOOLBAR_INTERFACE_KEY "airpcap_toolbar_if_key"
+#define AIRPCAP_TOOLBAR_LINK_TYPE_KEY "airpcap_toolbar_lt_key"
+#define AIRPCAP_TOOLBAR_CHANNEL_KEY "airpcap_toolbar_ch_key"
+#define AIRPCAP_TOOLBAR_CRC_KEY "airpcap_toolbar_crc_key"
+#define AIRPCAP_TOOLBAR_WRONG_CRC_KEY "airpcap_toolbar_wcrc_key"
+#define AIRPCAP_TOOLBAR_ADVANCED_KEY "airpcap_toolbar_advanced_key"
+#define AIRPCAP_TOOLBAR_DECRYPTION_KEY "airpcap_toolbar_decryption_key"
+
+#define AIRPCAP_ADVANCED_KEY "airpcap_advanced_key"
+#define AIRPCAP_ADVANCED_INTERFACE_KEY "airpcap_advanced_if_key"
+#define AIRPCAP_ADVANCED_LINK_TYPE_KEY "airpcap_advanced_lt_key"
+#define AIRPCAP_ADVANCED_CHANNEL_KEY "airpcap_advanced_ch_key"
+#define AIRPCAP_ADVANCED_CRC_KEY "airpcap_advanced_crc_key"
+#define AIRPCAP_ADVANCED_WRONG_CRC_KEY "airpcap_advanced_wcrc_key"
+#define AIRPCAP_ADVANCED_BLINK_KEY "airpcap_advanced_blink_key"
+#define AIRPCAP_ADVANCED_CANCEL_KEY "airpcap_advanced_cancel_key"
+#define AIRPCAP_ADVANCED_OK_KEY "airpcap_advanced_ok_key"
+#define AIRPCAP_ADVANCED_KEYLIST_KEY "airpcap_advanced_keylist_key"
+#define AIRPCAP_ADVANCED_ADD_KEY_TEXT_KEY "airpcap_advanced_add_key_text_key"
+#define AIRPCAP_ADVANCED_ADD_KEY_OK_KEY "airpcap_advanced_add_key_ok_key"
+#define AIRPCAP_ADVANCED_EDIT_KEY_TEXT_KEY "airpcap_advanced_edit_key_text_key"
+#define AIRPCAP_ADVANCED_EDIT_KEY_OK_KEY "airpcap_advanced_edit_key_ok_key"
+#define AIRPCAP_ADVANCED_EDIT_KEY_LABEL_KEY "airpcap_advanced_edit_key_label_key"
+#define AIRPCAP_ADVANCED_DECRYPTION_KEY "airpcap_advanced_decryption_key"
+
+#define AIRPCAP_OPTIONS_ADVANCED_KEY "airpcap_options_advanced_key"
+
+#define AIRPCAP_ADVANCED_FROM_KEY "airpcap_advanced_name_key"
+#endif
#endif
#include "../image/wsiconcap32.xpm"
#include "../image/wsiconcap48.xpm"
+#ifdef HAVE_AIRPCAP
+#include <airpcap.h>
+#include "airpcap_loader.h"
+#include "airpcap_dlg.h"
+#include "airpcap_gui_utils.h"
+
+#include "./gtk/toolbar.h"
+
+#include "./image/toolbar/wep_closed_24.xpm"
+#endif
/*
* Files under personal and global preferences directories in which
static GtkWidget *main_first_pane, *main_second_pane;
static GtkWidget *status_pane;
static GtkWidget *menubar, *main_vbox, *main_tb, *pkt_scrollw, *stat_hbox, *filter_tb;
+
+#ifdef HAVE_AIRPCAP
+GtkWidget *airpcap_tb;
+#endif
+
static GtkWidget *info_bar;
static GtkWidget *packets_bar = NULL;
static GtkWidget *welcome_pane;
capture_options *capture_opts = &global_capture_opts;
#endif
+gboolean block_toolbar_signals = FALSE;
static void create_main_window(gint, gint, gint, e_prefs*);
static void show_main_window(gboolean);
#define E_DFILTER_CM_KEY "display_filter_combo"
#define E_DFILTER_FL_KEY "display_filter_list"
-
-
/* Match selected byte pattern */
static void
match_selected_cb_do(gpointer data, int action, gchar *text)
}
/* This function allows users to right click in the details window and copy the text
- * information to the operating systems clipboard.
+ * information to the operating systems clipboard.
*
* We first check to see if a string representation is setup in the tree and then
* read the string. If not available then we try to grab the value. If all else
int optind_initial;
int status;
+#ifdef HAVE_AIRPCAP
+ char err_str[AIRPCAP_ERRBUF_SIZE];
+ gchar *cant_get_if_list_errstr;
+#endif
+
#define OPTSTRING_INIT "a:b:c:Df:g:Hhi:klLm:nN:o:pQr:R:Ss:t:vw:X:y:z:"
#if defined HAVE_LIBPCAP && defined _WIN32
/* Read the preference files. */
prefs = read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
&pf_open_errno, &pf_read_errno, &pf_path);
+
+#ifdef HAVE_AIRPCAP
+ /* Load the airpcap.dll */
+ if(!load_airpcap())
+ {
+ simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"%s","Failed to load airpcap.dll\nMake sure you have the right airpcap.dll installed!");
+ airpcap_if_active = NULL;
+ }
+ else
+ {
+ /* load the airpcap interfaces */
+ airpcap_if_list = get_airpcap_interface_list(&err, err_str);
+
+ if (airpcap_if_list == NULL && err == CANT_GET_AIRPCAP_INTERFACE_LIST) {
+ cant_get_if_list_errstr = cant_get_airpcap_if_list_error_message(err_str);
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s",
+ cant_get_if_list_errstr);
+ g_free(cant_get_if_list_errstr);
+ }
+
+ /* select the first ad default (THIS SHOULD BE CHANGED) */
+ airpcap_if_active = airpcap_get_default_if(airpcap_if_list);
+ }
+#endif
+
if (gpf_path != NULL) {
if (gpf_open_errno != 0) {
simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
gtk_widget_ref(menubar);
gtk_widget_ref(main_tb);
gtk_widget_ref(filter_tb);
+
+#ifdef HAVE_AIRPCAP
+ gtk_widget_ref(airpcap_tb);
+#endif
+
gtk_widget_ref(pkt_scrollw);
gtk_widget_ref(tv_scrollw);
gtk_widget_ref(byte_nb_ptr);
gtk_box_pack_start(GTK_BOX(main_vbox), filter_tb, FALSE, TRUE, 1);
}
+#ifdef HAVE_AIRPCAP
+ /* airpcap toolbar */
+ gtk_box_pack_start(GTK_BOX(main_vbox), airpcap_tb, FALSE, TRUE, 1);
+#endif
+
/* fill the main layout panes */
switch(prefs.gui_layout_type) {
case(layout_type_5):
gtk_box_pack_start(GTK_BOX(stat_hbox), filter_tb, FALSE, TRUE, 1);
}
+#ifdef HAVE_AIRPCAP
+ /* airpcap toolbar */
+ gtk_box_pack_start(GTK_BOX(main_vbox), airpcap_tb, FALSE, TRUE, 1);
+#endif
+
/* statusbar */
gtk_box_pack_start(GTK_BOX(stat_hbox), status_pane, TRUE, TRUE, 0);
gtk_paned_pack1(GTK_PANED(status_pane), info_bar, FALSE, FALSE);
gtk_widget_hide(filter_tb);
}
+#ifdef HAVE_AIRPCAP
+ if (recent.airpcap_toolbar_show) {
+ gtk_widget_show(airpcap_tb);
+ } else {
+ gtk_widget_hide(airpcap_tb);
+ }
+#endif
+
if (recent.packet_list_show && have_capture_file) {
gtk_widget_show(pkt_scrollw);
} else {
}
#endif
+#ifdef HAVE_AIRPCAP
+/*
+ * Changed callback for the channel combobox
+ */
+static void
+airpcap_toolbar_channel_changed_cb(GtkWidget *w _U_, gpointer data)
+{
+gchar ebuf[AIRPCAP_ERRBUF_SIZE];
+PAirpcapHandle ad;
+const gchar *s;
+int ch_num;
+
+ s = gtk_entry_get_text(GTK_ENTRY(data));
+
+if((data != NULL) && (w != NULL) )
+ {
+ s = gtk_entry_get_text(GTK_ENTRY(data));
+ if((g_strcasecmp("",s)))
+ {
+ sscanf(s,"%d",&ch_num);
+ if(airpcap_if_active != NULL)
+ {
+ ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list, airpcap_if_active->description), ebuf);
+
+ if(ad)
+ {
+ airpcap_if_set_device_channel(ad,ch_num);
+ airpcap_if_active->channel = ch_num;
+ airpcap_if_close(ad);
+ }
+ }
+ }
+ }
+}
+#endif
+
+
+#ifdef HAVE_AIRPCAP
+/*
+ * Callback for the wrong crc combo
+ */
+static void
+airpcap_toolbar_wrong_crc_combo_cb(GtkWidget *entry, gpointer user_data)
+{
+gchar ebuf[AIRPCAP_ERRBUF_SIZE];
+PAirpcapHandle ad;
+
+if( !block_toolbar_signals && (airpcap_if_active != NULL))
+ {
+ ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list,airpcap_if_active->description), ebuf);
+
+ if(ad)
+ {
+ airpcap_if_active->CrcValidationOn = airpcap_get_validation_type(gtk_entry_get_text(GTK_ENTRY(entry)));
+ airpcap_if_set_fcs_validation(ad,airpcap_if_active->CrcValidationOn);
+ /* Save configuration */
+ if(!airpcap_if_store_cur_config_as_adapter_default(ad))
+ {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Cannot save configuration!!!\nRemember that in order to store the configuration in the registry you have to:\n\n- Close all the airpcap-based applications.\n- Be sure to have administrative privileges.");
+ }
+ airpcap_if_close(ad);
+ }
+ }
+}
+#endif
+
+#ifdef HAVE_AIRPCAP
+void
+airpcap_toolbar_encryption_cb(GtkWidget *entry, gpointer user_data)
+{
+gchar ebuf[AIRPCAP_ERRBUF_SIZE];
+PAirpcapHandle ad;
+
+if( !block_toolbar_signals && (airpcap_if_active != NULL))
+{
+ ad = airpcap_if_open(get_airpcap_name_from_description(airpcap_if_list,airpcap_if_active->description), ebuf);
+
+ if(ad)
+ {
+ if(airpcap_if_active->DecryptionOn == AIRPCAP_DECRYPTION_ON)
+ {
+ airpcap_if_active->DecryptionOn = AIRPCAP_DECRYPTION_OFF;
+ airpcap_if_set_decryption_state(ad,airpcap_if_active->DecryptionOn);
+ /* Save configuration */
+ if(!airpcap_if_store_cur_config_as_adapter_default(ad))
+ {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Cannot save configuration!!!\nRemember that in order to store the configuration in the registry you have to:\n\n- Close all the airpcap-based applications.\n- Be sure to have administrative privileges.");
+ }
+ airpcap_if_close(ad);
+ }
+ else
+ {
+ airpcap_if_active->DecryptionOn = AIRPCAP_DECRYPTION_ON;
+ airpcap_if_set_decryption_state(ad,airpcap_if_active->DecryptionOn);
+ /* Save configuration */
+ if(!airpcap_if_store_cur_config_as_adapter_default(ad))
+ {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Cannot save configuration!!!\nRemember that in order to store the configuration in the registry you have to:\n\n- Close all the airpcap-based applications.\n- Be sure to have administrative privileges.");
+ }
+ airpcap_if_close(ad);
+ }
+ }
+ }
+}
+#endif
+
+#ifdef HAVE_AIRPCAP
+/*
+ * Callback for the Advanced Wireless Settings button
+ */
+static void
+toolbar_display_airpcap_advanced_cb(GtkWidget *w, gpointer data)
+{
+int *from_widget;
+
+ from_widget = (gint*)g_malloc(sizeof(gint));
+ *from_widget = AIRPCAP_ADVANCED_FROM_TOOLBAR;
+ OBJECT_SET_DATA(airpcap_tb,AIRPCAP_ADVANCED_FROM_KEY,from_widget);
+
+ display_airpcap_advanced_cb(w,data);
+}
+#endif
static void
create_main_window (gint pl_size, gint tv_size, gint bv_size, e_prefs *prefs)
*filter_reset;
GList *dfilter_list = NULL;
GtkTooltips *tooltips;
+
GtkAccelGroup *accel;
gchar *title;
+
+#ifdef HAVE_AIRPCAP
+ GtkWidget
+ *advanced_bt,
+ *interface_lb,
+ *channel_lb,
+ *channel_cm,
+ *wrong_crc_lb,
+ *encryption_ck,
+ *wrong_crc_cm,
+ *iconw;
+ GList *channel_list = NULL;
+ GList *linktype_list = NULL;
+ GList *link_list = NULL;
+ GtkTooltips *airpcap_tooltips;
+ gchar *if_label_text;
+ gint *from_widget = NULL;
+#endif
+
/* Display filter construct dialog has an Apply button, and "OK" not
only sets our text widget, it activates it (i.e., it causes us to
filter the capture). */
tooltips = gtk_tooltips_new();
+#ifdef HAVE_AIRPCAP
+ airpcap_tooltips = gtk_tooltips_new();
+#endif
+
#ifdef _WIN32
#if GTK_MAJOR_VERSION < 2
/* has to be done, after top_level window is created */
main_pane_h2 = gtk_hpaned_new();
gtk_widget_show(main_pane_h2);
+#ifdef HAVE_AIRPCAP
+ /* airpcap toolbar */
+#if GTK_MAJOR_VERSION < 2
+ airpcap_tb = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
+ GTK_TOOLBAR_BOTH);
+#else
+ airpcap_tb = gtk_toolbar_new();
+ gtk_toolbar_set_orientation(GTK_TOOLBAR(airpcap_tb),
+ GTK_ORIENTATION_HORIZONTAL);
+#endif /* GTK_MAJOR_VERSION */
+ gtk_widget_show(airpcap_tb);
+
+ /* Interface Label */
+ if(airpcap_if_active != NULL)
+ {
+ if_label_text = g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(airpcap_if_active));
+ interface_lb = gtk_label_new(if_label_text);
+ g_free(if_label_text);
+ }
+ else
+ {
+ interface_lb = gtk_label_new("No Wireless Interface Found ");
+ }
+
+ /* Add the label to the toolbar */
+ gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), interface_lb,
+ "Current Wireless Interface", "Private");
+ OBJECT_SET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_INTERFACE_KEY,interface_lb);
+ gtk_widget_show(interface_lb);
+ gtk_toolbar_insert_space(GTK_TOOLBAR(airpcap_tb),1);
+
+
+ /* Create the "802.11 Channel:" label */
+ channel_lb = gtk_label_new(" 802.11 Channel: ");
+ gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), channel_lb,
+ "Current 802.11 Channel", "Private");
+ gtk_widget_show(channel_lb);
+
+ #if GTK_MAJOR_VERSION < 2
+ gtk_widget_set_usize( GTK_WIDGET(channel_lb),
+ 100,
+ 28 );
+ #else
+ gtk_widget_set_size_request( GTK_WIDGET(channel_lb),
+ 100,
+ 28 );
+ #endif
+
+ /* Create the channel combo box */
+ channel_cm = gtk_combo_new();
+ gtk_editable_set_editable(GTK_EDITABLE(GTK_COMBO(channel_cm)->entry),FALSE);
+ OBJECT_SET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_CHANNEL_KEY,channel_cm);
+
+ channel_list = g_list_append(channel_list, "1");
+ channel_list = g_list_append(channel_list, "2");
+ channel_list = g_list_append(channel_list, "3");
+ channel_list = g_list_append(channel_list, "4");
+ channel_list = g_list_append(channel_list, "5");
+ channel_list = g_list_append(channel_list, "6");
+ channel_list = g_list_append(channel_list, "7");
+ channel_list = g_list_append(channel_list, "8");
+ channel_list = g_list_append(channel_list, "9");
+ channel_list = g_list_append(channel_list, "10");
+ channel_list = g_list_append(channel_list, "11");
+ channel_list = g_list_append(channel_list, "12");
+ channel_list = g_list_append(channel_list, "13");
+ channel_list = g_list_append(channel_list, "14");
+
+ gtk_combo_set_popdown_strings( GTK_COMBO(channel_cm), channel_list) ;
+
+ gtk_tooltips_set_tip(airpcap_tooltips, GTK_WIDGET(GTK_COMBO(channel_cm)->entry),
+ "Change the 802.11 RF channel",
+ NULL);
+
+ #if GTK_MAJOR_VERSION < 2
+ gtk_widget_set_usize( GTK_WIDGET(channel_cm),
+ 45,
+ 28 );
+ #else
+ gtk_widget_set_size_request( GTK_WIDGET(channel_cm),
+ 45,
+ 28 );
+ #endif
+
+ if(airpcap_if_active != NULL)
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_cm)->entry), airpcap_get_channel_name(airpcap_if_active->channel));
+ else
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_cm)->entry),"");
+
+ /* callback for channel combo box */
+ SIGNAL_CONNECT(GTK_COMBO(channel_cm)->entry,"changed",airpcap_toolbar_channel_changed_cb,GTK_COMBO(channel_cm)->entry);
+ gtk_widget_show(channel_cm);
+
+ gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), channel_cm,
+ "802.11 Channel", "Private");
+
+ gtk_toolbar_append_space(GTK_TOOLBAR(airpcap_tb));
+
+ /* Wrong CRC Label */
+ wrong_crc_lb = gtk_label_new(" FCS Filter: ");
+ gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), wrong_crc_lb,
+ "", "Private");
+ gtk_widget_show(wrong_crc_lb);
+
+ /* Wrong CRC combo */
+ wrong_crc_cm = gtk_combo_new();
+ gtk_editable_set_editable(GTK_EDITABLE(GTK_COMBO(wrong_crc_cm)->entry),FALSE);
+ OBJECT_SET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_WRONG_CRC_KEY,wrong_crc_cm);
+ gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), wrong_crc_cm,
+ "", "Private");
+
+ linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_ALL);
+ linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_CORRECT);
+ linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT);
+
+ gtk_combo_set_popdown_strings( GTK_COMBO(wrong_crc_cm), linktype_list) ;
+ gtk_tooltips_set_tip(airpcap_tooltips, GTK_WIDGET(GTK_COMBO(wrong_crc_cm)->entry),
+ "Select the 802.11 FCS filter that the wireless adapter will apply.",
+ NULL);
+
+ if(airpcap_if_active != NULL)
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_cm)->entry), airpcap_get_validation_name(airpcap_if_active->CrcValidationOn));
+ else
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(wrong_crc_cm)->entry),"");
+
+ SIGNAL_CONNECT(GTK_COMBO(wrong_crc_cm)->entry,"changed",airpcap_toolbar_wrong_crc_combo_cb,airpcap_tb);
+ gtk_widget_show(wrong_crc_cm);
+
+ gtk_toolbar_append_space(GTK_TOOLBAR(airpcap_tb));
+
+ /* encryption enabled box */
+
+ encryption_ck = gtk_toggle_button_new();
+ iconw = xpm_to_widget (wep_closed_24_xpm);
+ gtk_widget_show(iconw);
+ gtk_container_add(GTK_CONTAINER(encryption_ck),iconw);
+
+ #if GTK_MAJOR_VERSION < 2
+ gtk_widget_set_usize( GTK_WIDGET(encryption_ck),
+ 28,
+ 28 );
+ #else
+ gtk_widget_set_size_request( GTK_WIDGET(encryption_ck),
+ 28,
+ 28 );
+ #endif
+
+ OBJECT_SET_DATA(GTK_TOOLBAR(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY,encryption_ck);
+
+ if(airpcap_if_active != NULL)
+ {
+ if(airpcap_if_active->DecryptionOn == AIRPCAP_DECRYPTION_ON)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(encryption_ck),TRUE);
+ else
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(encryption_ck),FALSE);
+ }
+
+ SIGNAL_CONNECT(encryption_ck,"toggled",airpcap_toolbar_encryption_cb,airpcap_tb);
+ gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), encryption_ck,
+ "Enable the WEP decryption in the wireless driver", "Private");
+ gtk_widget_show(encryption_ck);
+
+ gtk_toolbar_append_space(GTK_TOOLBAR(airpcap_tb));
+
+ /* Advanced button */
+ advanced_bt = gtk_button_new_with_label("Advanced Wireless Settings...");
+ OBJECT_SET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_ADVANCED_KEY,advanced_bt);
+
+ SIGNAL_CONNECT(advanced_bt, "clicked", toolbar_display_airpcap_advanced_cb, airpcap_tb);
+ gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), advanced_bt,
+ "Set Advanced Wireless Settings...", "Private");
+ gtk_widget_show(advanced_bt);
+
+ /* select the default interface */
+ airpcap_if_active = airpcap_get_default_if(airpcap_if_list);
+
+ /* If no airpcap interface is present, gray everything */
+ if(airpcap_if_active == NULL)
+ {
+ if(airpcap_if_list == NULL)
+ {
+ /*No airpcap device found */
+ gtk_widget_set_sensitive(airpcap_tb,FALSE);
+ recent.airpcap_toolbar_show = FALSE;
+ }
+ else
+ {
+ /* default adapter is not airpcap... or is airpcap but is not found*/
+ airpcap_set_toolbar_stop_capture(airpcap_if_active);
+ gtk_widget_set_sensitive(airpcap_tb,FALSE);
+ recent.airpcap_toolbar_show = TRUE;
+ }
+ }
+ else
+ {
+ airpcap_set_toolbar_stop_capture(airpcap_if_active);
+ recent.airpcap_toolbar_show = TRUE;
+ }
+#endif
+
/* filter toolbar */
#if GTK_MAJOR_VERSION < 2
filter_tb = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
/** Global runtime version string */
extern GString *runtime_info_str;
+extern GtkWidget* airpcap_tb;
+
/** Global capture options type. */
typedef struct capture_options_tag * p_capture_options_t;
/** Pointer to global capture options. */
extern void protect_thread_critical_region(void);
extern void unprotect_thread_critical_region(void);
+void
+airpcap_toolbar_encryption_cb(GtkWidget *entry, gpointer user_data);
+
/** User requested "Zoom In" by menu or toolbar.
*
* @param widget parent widget (unused)
static void set_menu_sensitivity (GtkItemFactory *, const gchar *, gint);
static void main_toolbar_show_cb(GtkWidget *w _U_, gpointer d _U_);
static void filter_toolbar_show_cb(GtkWidget *w _U_, gpointer d _U_);
+#ifdef HAVE_AIRPCAP
+static void airpcap_toolbar_show_cb(GtkWidget *w _U_, gpointer d _U_);
+#endif
static void packet_list_show_cb(GtkWidget *w _U_, gpointer d _U_);
static void tree_view_show_cb(GtkWidget *w _U_, gpointer d _U_);
static void byte_view_show_cb(GtkWidget *w _U_, gpointer d _U_);
ITEM_FACTORY_ENTRY("/_View", NULL, NULL, 0, "<Branch>", NULL),
ITEM_FACTORY_ENTRY("/View/_Main Toolbar", NULL, main_toolbar_show_cb, 0, "<CheckItem>", NULL),
ITEM_FACTORY_ENTRY("/View/_Filter Toolbar", NULL, filter_toolbar_show_cb, 0, "<CheckItem>", NULL),
+#ifdef HAVE_AIRPCAP
+ ITEM_FACTORY_ENTRY("/View/_Wireless Toolbar", NULL, airpcap_toolbar_show_cb, 0, "<CheckItem>", NULL),
+#endif
ITEM_FACTORY_ENTRY("/View/_Statusbar", NULL, statusbar_show_cb, 0, "<CheckItem>", NULL),
ITEM_FACTORY_ENTRY("/View/<separator>", NULL, NULL, 0, "<Separator>", NULL),
ITEM_FACTORY_ENTRY("/View/Packet _List", NULL, packet_list_show_cb, 0, "<CheckItem>", NULL),
main_widgets_show_or_hide();
}
+#ifdef HAVE_AIRPCAP
+static void
+airpcap_toolbar_show_cb(GtkWidget *w _U_, gpointer d _U_)
+{
+
+ /* save current setting in recent */
+ recent.airpcap_toolbar_show = GTK_CHECK_MENU_ITEM(w)->active;
+
+ main_widgets_show_or_hide();
+}
+#endif
static void
packet_list_show_cb(GtkWidget *w _U_, gpointer d _U_)
menu = gtk_item_factory_get_widget(main_menu_factory, "/View/Filter Toolbar");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu), recent.filter_toolbar_show);
+ menu = gtk_item_factory_get_widget(main_menu_factory, "/View/Wireless Toolbar");
+ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu), recent.airpcap_toolbar_show);
+
menu = gtk_item_factory_get_widget(main_menu_factory, "/View/Statusbar");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu), recent.statusbar_show);
#define RECENT_KEY_MAIN_TOOLBAR_SHOW "gui.toolbar_main_show"
#define RECENT_KEY_FILTER_TOOLBAR_SHOW "gui.filter_toolbar_show"
+#define RECENT_KEY_AIRPCAP_TOOLBAR_SHOW "gui.airpcap_toolbar_show"
#define RECENT_KEY_PACKET_LIST_SHOW "gui.packet_list_show"
#define RECENT_KEY_TREE_VIEW_SHOW "gui.tree_view_show"
#define RECENT_KEY_BYTE_VIEW_SHOW "gui.byte_view_show"
fprintf(rf, RECENT_KEY_FILTER_TOOLBAR_SHOW ": %s\n",
recent.filter_toolbar_show == TRUE ? "TRUE" : "FALSE");
+#ifdef HAVE_AIRPCAP
+ fprintf(rf, "\n# Wireless Settings Toolbar show (hide).\n");
+ fprintf(rf, "# TRUE or FALSE (case-insensitive).\n");
+ fprintf(rf, RECENT_KEY_AIRPCAP_TOOLBAR_SHOW ": %s\n",
+ recent.airpcap_toolbar_show == TRUE ? "TRUE" : "FALSE");
+#endif
+
fprintf(rf, "\n# Packet list show (hide).\n");
fprintf(rf, "# TRUE or FALSE (case-insensitive).\n");
fprintf(rf, RECENT_KEY_PACKET_LIST_SHOW ": %s\n",
recent.gui_geometry_main_width);
fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_HEIGHT ": %d\n",
recent.gui_geometry_main_height);
-
+
fprintf(rf, "\n# Main window maximized (GTK2 only!).\n");
fprintf(rf, "# TRUE or FALSE (case-insensitive).\n");
fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_MAXIMIZED ": %s\n",
/* write the geometry values of a window to recent file */
-void
+void
write_recent_geom(gpointer key _U_, gpointer value, gpointer rf)
{
window_geometry_t *geom = value;
else {
recent.filter_toolbar_show = FALSE;
}
+ } else if (strcmp(key, RECENT_KEY_AIRPCAP_TOOLBAR_SHOW) == 0) {
+ if (strcasecmp(value, "true") == 0) {
+ recent.airpcap_toolbar_show = TRUE;
+ }
+ else {
+ recent.airpcap_toolbar_show = FALSE;
+ }
} else if (strcmp(key, RECENT_KEY_PACKET_LIST_SHOW) == 0) {
if (strcasecmp(value, "true") == 0) {
recent.packet_list_show = TRUE;
/* set defaults */
recent.main_toolbar_show = TRUE;
recent.filter_toolbar_show = TRUE;
+ recent.airpcap_toolbar_show = FALSE;
recent.packet_list_show = TRUE;
recent.tree_view_show = TRUE;
recent.byte_view_show = TRUE;
typedef struct recent_settings_tag {
gboolean main_toolbar_show;
gboolean filter_toolbar_show;
+ gboolean airpcap_toolbar_show;
gboolean packet_list_show;
gboolean tree_view_show;
gboolean byte_view_show;
--- /dev/null
+/* XPM */
+static char * capture_airpcap_16_xpm[] = {
+"16 16 256 2",
+" c None",
+". c #800000",
+"+ c #008000",
+"@ c #808000",
+"# c #000080",
+"$ c #800080",
+"% c #008080",
+"& c #C0C0C0",
+"* c #C0DCC0",
+"= c #A6CAF0",
+"- c #040404",
+"; c #080808",
+"> c #0C0C0C",
+", c #111111",
+"' c #161616",
+") c #1C1C1C",
+"! c #222222",
+"~ c #292929",
+"{ c #555555",
+"] c #4D4D4D",
+"^ c #424242",
+"/ c #393939",
+"( c #FF7C80",
+"_ c #FF5050",
+": c #D60093",
+"< c #CCECFF",
+"[ c #EFD6C6",
+"} c #E7E7D6",
+"| c #ADA990",
+"1 c #330000",
+"2 c #660000",
+"3 c #990000",
+"4 c #CC0000",
+"5 c #003300",
+"6 c #333300",
+"7 c #663300",
+"8 c #993300",
+"9 c #CC3300",
+"0 c #FF3300",
+"a c #006600",
+"b c #336600",
+"c c #666600",
+"d c #996600",
+"e c #CC6600",
+"f c #FF6600",
+"g c #009900",
+"h c #339900",
+"i c #669900",
+"j c #999900",
+"k c #CC9900",
+"l c #FF9900",
+"m c #00CC00",
+"n c #33CC00",
+"o c #66CC00",
+"p c #99CC00",
+"q c #CCCC00",
+"r c #FFCC00",
+"s c #66FF00",
+"t c #99FF00",
+"u c #CCFF00",
+"v c #000033",
+"w c #330033",
+"x c #660033",
+"y c #990033",
+"z c #CC0033",
+"A c #FF0033",
+"B c #003333",
+"C c #333333",
+"D c #663333",
+"E c #993333",
+"F c #CC3333",
+"G c #FF3333",
+"H c #006633",
+"I c #336633",
+"J c #666633",
+"K c #996633",
+"L c #CC6633",
+"M c #FF6633",
+"N c #009933",
+"O c #339933",
+"P c #669933",
+"Q c #999933",
+"R c #CC9933",
+"S c #FF9933",
+"T c #00CC33",
+"U c #33CC33",
+"V c #66CC33",
+"W c #99CC33",
+"X c #CCCC33",
+"Y c #FFCC33",
+"Z c #33FF33",
+"` c #66FF33",
+" . c #99FF33",
+".. c #CCFF33",
+"+. c #FFFF33",
+"@. c #000066",
+"#. c #330066",
+"$. c #660066",
+"%. c #990066",
+"&. c #CC0066",
+"*. c #FF0066",
+"=. c #003366",
+"-. c #333366",
+";. c #663366",
+">. c #993366",
+",. c #CC3366",
+"'. c #FF3366",
+"). c #006666",
+"!. c #336666",
+"~. c #666666",
+"{. c #996666",
+"]. c #CC6666",
+"^. c #009966",
+"/. c #339966",
+"(. c #669966",
+"_. c #999966",
+":. c #CC9966",
+"<. c #FF9966",
+"[. c #00CC66",
+"}. c #33CC66",
+"|. c #99CC66",
+"1. c #CCCC66",
+"2. c #FFCC66",
+"3. c #00FF66",
+"4. c #33FF66",
+"5. c #99FF66",
+"6. c #CCFF66",
+"7. c #FF00CC",
+"8. c #CC00FF",
+"9. c #009999",
+"0. c #993399",
+"a. c #990099",
+"b. c #CC0099",
+"c. c #000099",
+"d. c #333399",
+"e. c #660099",
+"f. c #CC3399",
+"g. c #FF0099",
+"h. c #006699",
+"i. c #336699",
+"j. c #663399",
+"k. c #996699",
+"l. c #CC6699",
+"m. c #FF3399",
+"n. c #339999",
+"o. c #669999",
+"p. c #999999",
+"q. c #CC9999",
+"r. c #FF9999",
+"s. c #00CC99",
+"t. c #33CC99",
+"u. c #66CC66",
+"v. c #99CC99",
+"w. c #CCCC99",
+"x. c #FFCC99",
+"y. c #00FF99",
+"z. c #33FF99",
+"A. c #66CC99",
+"B. c #99FF99",
+"C. c #CCFF99",
+"D. c #FFFF99",
+"E. c #0000CC",
+"F. c #330099",
+"G. c #6600CC",
+"H. c #9900CC",
+"I. c #CC00CC",
+"J. c #003399",
+"K. c #3333CC",
+"L. c #6633CC",
+"M. c #9933CC",
+"N. c #CC33CC",
+"O. c #FF33CC",
+"P. c #0066CC",
+"Q. c #3366CC",
+"R. c #666699",
+"S. c #9966CC",
+"T. c #CC66CC",
+"U. c #FF6699",
+"V. c #0099CC",
+"W. c #3399CC",
+"X. c #6699CC",
+"Y. c #9999CC",
+"Z. c #CC99CC",
+"`. c #FF99CC",
+" + c #00CCCC",
+".+ c #33CCCC",
+"++ c #66CCCC",
+"@+ c #99CCCC",
+"#+ c #CCCCCC",
+"$+ c #FFCCCC",
+"%+ c #00FFCC",
+"&+ c #33FFCC",
+"*+ c #66FF99",
+"=+ c #99FFCC",
+"-+ c #CCFFCC",
+";+ c #FFFFCC",
+">+ c #3300CC",
+",+ c #6600FF",
+"'+ c #9900FF",
+")+ c #0033CC",
+"!+ c #3333FF",
+"~+ c #6633FF",
+"{+ c #9933FF",
+"]+ c #CC33FF",
+"^+ c #FF33FF",
+"/+ c #0066FF",
+"(+ c #3366FF",
+"_+ c #6666CC",
+":+ c #9966FF",
+"<+ c #CC66FF",
+"[+ c #FF66CC",
+"}+ c #0099FF",
+"|+ c #3399FF",
+"1+ c #6699FF",
+"2+ c #9999FF",
+"3+ c #CC99FF",
+"4+ c #FF99FF",
+"5+ c #00CCFF",
+"6+ c #33CCFF",
+"7+ c #66CCFF",
+"8+ c #99CCFF",
+"9+ c #CCCCFF",
+"0+ c #FFCCFF",
+"a+ c #33FFFF",
+"b+ c #66FFCC",
+"c+ c #99FFFF",
+"d+ c #CCFFFF",
+"e+ c #FF6666",
+"f+ c #66FF66",
+"g+ c #FFFF66",
+"h+ c #6666FF",
+"i+ c #FF66FF",
+"j+ c #66FFFF",
+"k+ c #A50021",
+"l+ c #5F5F5F",
+"m+ c #777777",
+"n+ c #868686",
+"o+ c #969696",
+"p+ c #CBCBCB",
+"q+ c #B2B2B2",
+"r+ c #D7D7D7",
+"s+ c #DDDDDD",
+"t+ c #E3E3E3",
+"u+ c #EAEAEA",
+"v+ c #F1F1F1",
+"w+ c #F8F8F8",
+"x+ c #FFFBF0",
+"y+ c #A0A0A4",
+"z+ c #808080",
+"A+ c #FF0000",
+"B+ c #00FF00",
+"C+ c #FFFF00",
+"D+ c #0000FF",
+"E+ c #FF00FF",
+"F+ c #00FFFF",
+"G+ c #FFFFFF",
+" ",
+" 5. 5. ",
+"5. + 5. 5.+ 5.",
+"+ 5. a 5. n+n+ 5.a 5.+ ",
+"+ 5. a 5. n+& & n+ 5.a 5.+ ",
+"+ 5. a 5. n+#+& n+ 5.a 5.+ ",
+"+ 5. a 5. n+n+ 5.a 5.+ ",
+"5. + 5. o+n+ 5.+ 5.",
+" 5. & n+ 5. ",
+" & n+ ",
+" & n+ ",
+" & n+ ",
+" & n+ ",
+" & n+ ",
+" & n+ ",
+" "};
--- /dev/null
+/* XPM */
+static char * capture_capture_16_xpm[] = {
+"16 16 151 2",
+" c None",
+". c #7F7F7F",
+"+ c #A9A9A9",
+"@ c #8E8E8E",
+"# c #373737",
+"$ c #545454",
+"% c #3D3D3D",
+"& c #F1F1F1",
+"* c #C2C2C2",
+"= c #A4A4A4",
+"- c #121212",
+"; c #212121",
+"> c #E9E9E9",
+", c #C7C7C7",
+"' c #505050",
+") c #979797",
+"! c #595958",
+"~ c #181818",
+"{ c #1F1F1F",
+"] c #A0A0A0",
+"^ c #323232",
+"/ c #5F5E5B",
+"( c #5D5C59",
+"_ c #1D1C1B",
+": c #7A7A7A",
+"< c #838383",
+"[ c #1E2018",
+"} c #7F847C",
+"| c #3B3C3B",
+"1 c #000000",
+"2 c #353535",
+"3 c #696865",
+"4 c #6D6B65",
+"5 c #6B6964",
+"6 c #54534D",
+"7 c #282828",
+"8 c #828282",
+"9 c #3D4536",
+"0 c #566147",
+"a c #535D44",
+"b c #5E6B57",
+"c c #30322F",
+"d c #313131",
+"e c #91908C",
+"f c #595854",
+"g c #737270",
+"h c #73726C",
+"i c #131211",
+"j c #808080",
+"k c #5E5F55",
+"l c #57624E",
+"m c #636958",
+"n c #5A6852",
+"o c #5A5D59",
+"p c #686868",
+"q c #5B5A56",
+"r c #7A7772",
+"s c #7F7D77",
+"t c #41403C",
+"u c #464646",
+"v c #7E7A6B",
+"w c #575E4B",
+"x c #7A7862",
+"y c #525D4A",
+"z c #686A66",
+"A c #B4B4B4",
+"B c #4D4D4D",
+"C c #0F0F0E",
+"D c #454545",
+"E c #7E7E7E",
+"F c #7B564E",
+"G c #534C3D",
+"H c #785042",
+"I c #4E5947",
+"J c #5B5D59",
+"K c #E6E6E6",
+"L c #E5E5E5",
+"M c #989898",
+"N c #DCDCDC",
+"O c #E3E3E3",
+"P c #7D7D7D",
+"Q c #3C4338",
+"R c #3D4836",
+"S c #424A3C",
+"T c #3B3D39",
+"U c #080A07",
+"V c #5E605E",
+"W c #51524F",
+"X c #455137",
+"Y c #687355",
+"Z c #656B55",
+"` c #5F6759",
+" . c #393B38",
+".. c #242B21",
+"+. c #6B725C",
+"@. c #53503F",
+"#. c #565546",
+"$. c #555445",
+"%. c #474533",
+"&. c #313B28",
+"*. c #445036",
+"=. c #5D6B49",
+"-. c #6F7C64",
+";. c #6A6C68",
+">. c #6D6D6D",
+",. c #615F5D",
+"'. c #273024",
+"). c #73805E",
+"!. c #4A4C36",
+"~. c #434632",
+"{. c #56583E",
+"]. c #4B4D36",
+"^. c #484A35",
+"/. c #5C6647",
+"(. c #6A7652",
+"_. c #60704C",
+":. c #667359",
+"<. c #4E514A",
+"[. c #585957",
+"}. c #525352",
+"|. c #3F3F3F",
+"1. c #313C2D",
+"2. c #5A7051",
+"3. c #6E7655",
+"4. c #5C684A",
+"5. c #6B7352",
+"6. c #5A6547",
+"7. c #68704F",
+"8. c #616E4B",
+"9. c #6E7954",
+"0. c #66734E",
+"a. c #37412C",
+"b. c #1D2317",
+"c. c #2C302A",
+"d. c #242423",
+"e. c #364430",
+"f. c #B3AB7D",
+"g. c #8B8E66",
+"h. c #B3AA7C",
+"i. c #898D64",
+"j. c #B2A97B",
+"k. c #898B63",
+"l. c #B2A87B",
+"m. c #868760",
+"n. c #171D12",
+"o. c #3B3829",
+"p. c #2D2E21",
+"q. c #2D2D20",
+"r. c #3B3828",
+"s. c #2C2C1F",
+"t. c #2A2A2A",
+" ",
+" . + + + + @ # $ % ",
+" + & & & & * = - ; ",
+" + > , ' ' ) ! ~ { ",
+" + ] ^ / ( _ : < [ } | ",
+"1 + 2 3 4 5 6 7 8 9 0 a b c ",
+"1 + d e f g h i j k l m n o ",
+"1 + p q r s t u j v w x y z ",
+"1 + A B C C D = E F G H I J ",
+"1 + K L M M N O P Q R S I T ",
+"U V E E P P P P W X Y Z ` . ",
+"..+.@.@.#.$.%.&.*.=.-.;.>.,.@ . ",
+"'.).!.~.{.].^./.(._.:.<.[.}.p |.",
+"1.2.3.4.5.6.7.8.9.0.a.b.c.d. ",
+" e.f.g.h.i.j.k.l.m.n. { ",
+" o.p.o.p.o.q.r.s. t. "};
--- /dev/null
+/* XPM */
+static char * capture_details_16_xpm[] = {
+"16 16 131 2",
+" c None",
+". c #000000",
+"+ c #AAAAAA",
+"@ c #8E8E8E",
+"# c #373737",
+"$ c #FEFEFE",
+"% c #F4F4F4",
+"& c #F8F8F8",
+"* c #F5F5F5",
+"= c #FFFFFF",
+"- c #FBFBFB",
+"; c #F9F9F9",
+"> c #C2C2C2",
+", c #A4A4A4",
+"' c #121212",
+") c #FDFDFC",
+"! c #FBFBFA",
+"~ c #F8F8F7",
+"{ c #F6F6F5",
+"] c #B6B6B6",
+"^ c #616160",
+"/ c #181818",
+"( c #F0F0F0",
+"_ c #ECECEC",
+": c #F1F1F1",
+"< c #E4E4E4",
+"[ c #DCDCDC",
+"} c #EEEEED",
+"| c #E8E8E7",
+"1 c #ECECEB",
+"2 c #6A6A6A",
+"3 c #DEDEDE",
+"4 c #555555",
+"5 c #BFBFBF",
+"6 c #B9B9B8",
+"7 c #535353",
+"8 c #C3C3C2",
+"9 c #E0E0DF",
+"0 c #DEDEDD",
+"a c #DEDEDC",
+"b c #D9D9D8",
+"c c #E4E4E3",
+"d c #6D6D6D",
+"e c #545454",
+"f c #575757",
+"g c #9F9F9F",
+"h c #393938",
+"i c #D0D0CE",
+"j c #E3E3E2",
+"k c #DFDFDD",
+"l c #E2E2E0",
+"m c #E4E4E2",
+"n c #6C6C6C",
+"o c #FDFDFD",
+"p c #DFDFDF",
+"q c #C1C1C1",
+"r c #303030",
+"s c #C5C5C3",
+"t c #DFDFDE",
+"u c #DBDBD9",
+"v c #E1E1DE",
+"w c #D3D3D2",
+"x c #595959",
+"y c #454545",
+"z c #8B8B8A",
+"A c #C8C8C7",
+"B c #D1D1CF",
+"C c #D0D0CD",
+"D c #D6D6D4",
+"E c #6C6C6B",
+"F c #FAFAFA",
+"G c #EBEBEA",
+"H c #717170",
+"I c #969696",
+"J c #4E4E4E",
+"K c #BABAB8",
+"L c #DCDCDA",
+"M c #C9C9C7",
+"N c #C8C8C6",
+"O c #CBCBC9",
+"P c #D6D6D3",
+"Q c #F9F9F8",
+"R c #E7E7E5",
+"S c #8C8C8C",
+"T c #545453",
+"U c #C0C0BE",
+"V c #D1D1CE",
+"W c #CECECB",
+"X c #D2D2CE",
+"Y c #D4D4D0",
+"Z c #5D5D5D",
+"` c #B7B7B7",
+" . c #414141",
+".. c #868684",
+"+. c #C4C4C1",
+"@. c #CDCDCA",
+"#. c #CACAC7",
+"$. c #6B6B6A",
+"%. c #4C4C4B",
+"&. c #282827",
+"*. c #9A9A97",
+"=. c #C0C0BD",
+"-. c #CECECA",
+";. c #CCCCC8",
+">. c #F5F5F4",
+",. c #4B4B4A",
+"'. c #2F2F2E",
+"). c #333332",
+"!. c #252525",
+"~. c #92928F",
+"{. c #CFCFCB",
+"]. c #CDCDC9",
+"^. c #CCCCC7",
+"/. c #B1B1AF",
+"(. c #2E2E2E",
+"_. c #595958",
+":. c #787876",
+"<. c #6B6B69",
+"[. c #9D9D9A",
+"}. c #B6B6B2",
+"|. c #B5B5B1",
+"1. c #B4B4B0",
+"2. c #5C5C5B",
+"3. c #424242",
+"4. c #3C3C3B",
+"5. c #323231",
+"6. c #222221",
+"7. c #2C2C2C",
+"8. c #2D2D2D",
+"9. c #2C2C2B",
+"0. c #1B1B1A",
+" ",
+" . + + + + + + + + + + @ # ",
+" . $ % & * = = = $ - ; > , ' ",
+" . $ % & * = = ) ! ~ { ] ^ / ",
+" . = ( _ _ ( : < [ } | } 1 2 ",
+" . = 3 4 5 6 7 8 9 0 a b c d ",
+" . $ e + f d g h i j k l m n ",
+" . o 7 p g g q r s t u a v n ",
+" . - w x [ q y z A a B C D E ",
+" . F G H + I J K L M N O P E ",
+" . Q R S + S T U P V W X Y E ",
+" . ~ N Z [ ` ...+.@.#.W C $. ",
+" . { %.p g g q &.*.=.#.-.;.E ",
+" . >.,.+ '.).g !.~.{.].^.^.$. ",
+" . c /.(._.:.'.<.[.}.}.|.1.2. ",
+" . 3.4.(.&.5.'.6.7.(.(.8.9.0. "};
--- /dev/null
+/* XPM */
+static char * capture_ethernet_16_xpm[] = {
+"16 16 144 2",
+" c None",
+". c #6A6A6A",
+"+ c #3F3F3F",
+"@ c #565656",
+"# c #535353",
+"$ c #4B5A45",
+"% c #7C9773",
+"& c #7B906D",
+"* c #80916D",
+"= c #748766",
+"- c #7D8E6A",
+"; c #708362",
+"> c #6D7B5B",
+", c #75815E",
+"' c #718060",
+") c #697756",
+"! c #6F7B5C",
+"~ c #5C6E52",
+"{ c #4B523F",
+"] c #576B50",
+"^ c #959D92",
+"/ c #AAAEA9",
+"( c #8F968B",
+"_ c #A3A7A1",
+": c #8B9388",
+"< c #676E64",
+"[ c #525D42",
+"} c #727B6D",
+"| c #47543F",
+"1 c #6F746D",
+"2 c #4C5C42",
+"3 c #6C6C6C",
+"4 c #444D3B",
+"5 c #909A8D",
+"6 c #A5A5A5",
+"7 c #BDBDBD",
+"8 c #ABABAB",
+"9 c #9A9A9A",
+"0 c #666765",
+"a c #575E4C",
+"b c #98987A",
+"c c #3F4831",
+"d c #979076",
+"e c #425039",
+"f c #777777",
+"g c #444E3C",
+"h c #6D7B68",
+"i c #888888",
+"j c #868686",
+"k c #737373",
+"l c #6D6D6D",
+"m c #636363",
+"n c #464845",
+"o c #3F4836",
+"p c #957665",
+"q c #3B3A28",
+"r c #94655A",
+"s c #3F4C36",
+"t c #6F6F6F",
+"u c #44523F",
+"v c #506349",
+"w c #454D41",
+"x c #555A53",
+"y c #3A4138",
+"z c #515550",
+"A c #363C34",
+"B c #343932",
+"C c #464E37",
+"D c #4B5844",
+"E c #384430",
+"F c #434B3E",
+"G c #4F4F4F",
+"H c #475642",
+"I c #6B7F5E",
+"J c #566246",
+"K c #585F44",
+"L c #454E37",
+"M c #4B533B",
+"N c #495039",
+"O c #53593F",
+"P c #61694A",
+"Q c #5F6D4B",
+"R c #616C4A",
+"S c #6F755F",
+"T c #586151",
+"U c #4A4A4A",
+"V c #455440",
+"W c #848F71",
+"X c #606549",
+"Y c #79785F",
+"Z c #7E8065",
+"` c #5D614D",
+" . c #616247",
+".. c #4F5E40",
+"+. c #566847",
+"@. c #5E6E4B",
+"#. c #76856C",
+"$. c #616161",
+"%. c #585858",
+"&. c #787775",
+"*. c #B3B3B3",
+"=. c #666666",
+"-. c #3F4C3A",
+";. c #6F7B59",
+">. c #3D402E",
+",. c #484833",
+"'. c #4F513A",
+"). c #494A34",
+"!. c #41422F",
+"~. c #5B6647",
+"{. c #6B7752",
+"]. c #60704C",
+"^. c #707C5D",
+"/. c #4B4B4B",
+"(. c #474747",
+"_. c #646464",
+":. c #6E6E6E",
+"<. c #1F1F1F",
+"[. c #5B7151",
+"}. c #6B7654",
+"|. c #687251",
+"1. c #687250",
+"2. c #66714F",
+"3. c #66704F",
+"4. c #6A7551",
+"5. c #6C7853",
+"6. c #65724D",
+"7. c #2F3B26",
+"8. c #1E2618",
+"9. c #11150D",
+"0. c #525252",
+"a. c #33402D",
+"b. c #A5A175",
+"c. c #A4A074",
+"d. c #A39F73",
+"e. c #A39E72",
+"f. c #A29E72",
+"g. c #A09B6F",
+"h. c #131910",
+"i. c #3F402E",
+"j. c #3E3F2D",
+"k. c #3E3E2C",
+"l. c #3D3C2B",
+"m. c #3C3C3C",
+" ",
+" . + ",
+" @ ",
+" # ",
+" # ",
+"$ % & * = - ; > , ' ) ! ~ # ",
+"{ ] ^ / ( _ : < [ } | 1 2 3 ",
+"4 5 6 7 8 6 9 0 a b c d e f ",
+"g h i j k l m n o p q r s t ",
+"u v w x y z A B C D E F s G ",
+"H I J K L M N O P Q R S T U ",
+"V W X Y Z ` ...+.@.#.$.%.&.*.=.",
+"-.;.>.,.'.).!.~.{.].^./.(._.:.<.",
+" [.}.|.1.2.3.4.5.6.7.8.9.0. ",
+" a.b.c.c.d.e.e.f.g.h. # ",
+" i.j.j.j.k.k.k.l. m. "};
--- /dev/null
+/* XPM */
+static char * capture_prepare_16_xpm[] = {
+"16 16 159 2",
+" c None",
+". c #808080",
+"+ c #000000",
+"@ c #353535",
+"# c #444444",
+"$ c #545454",
+"% c #3D3D3D",
+"& c #AAAAAA",
+"* c #505050",
+"= c #4B4B4B",
+"- c #212121",
+"; c #494949",
+"> c #F6F6F6",
+", c #EFEFEF",
+"' c #A1A1A1",
+") c #272727",
+"! c #1F1F1F",
+"~ c #555555",
+"{ c #E1E1E1",
+"] c #0F100E",
+"^ c #7F847C",
+"/ c #3B3C3B",
+"( c #343E30",
+"_ c #697D61",
+": c #252821",
+"< c #626F56",
+"[ c #59674C",
+"} c #4F5C44",
+"| c #556147",
+"1 c #5E6950",
+"2 c #566147",
+"3 c #535D44",
+"4 c #5E6B57",
+"5 c #30322F",
+"6 c #292F24",
+"7 c #576750",
+"8 c #8C8C8C",
+"9 c #E9E9E9",
+"0 c #4B4D4B",
+"a c #828880",
+"b c #90968E",
+"c c #5E675B",
+"d c #7E836E",
+"e c #57624E",
+"f c #636958",
+"g c #5A6852",
+"h c #5A5D59",
+"i c #0E100D",
+"j c #7F817D",
+"k c #F3F3F3",
+"l c #E5E5E5",
+"m c #C1C1C1",
+"n c #4F4F4F",
+"o c #9E9E9E",
+"p c #656764",
+"q c #4B5542",
+"r c #9A9A81",
+"s c #575E4B",
+"t c #7A7862",
+"u c #525D4A",
+"v c #686A66",
+"w c #010101",
+"x c #0C0C0C",
+"y c #242423",
+"z c #6A6B6A",
+"A c #494D48",
+"B c #3D4836",
+"C c #927261",
+"D c #534C3D",
+"E c #785042",
+"F c #4E5947",
+"G c #5B5D59",
+"H c #1D221B",
+"I c #555A53",
+"J c #1D1E1C",
+"K c #4D514A",
+"L c #1B1B1B",
+"M c #323331",
+"N c #3B3E39",
+"O c #252A22",
+"P c #434C35",
+"Q c #535F4B",
+"R c #424A3C",
+"S c #3B3D39",
+"T c #2A3327",
+"U c #6D8261",
+"V c #596548",
+"W c #515A40",
+"X c #49513A",
+"Y c #484F38",
+"Z c #51563D",
+"` c #424C34",
+" . c #5B6547",
+".. c #596847",
+"+. c #687355",
+"@. c #656B55",
+"#. c #5F6759",
+"$. c #393B38",
+"%. c #2A3226",
+"&. c #8C9777",
+"*. c #6B6D54",
+"=. c #6D6E54",
+"-. c #6A6E57",
+";. c #6C7058",
+">. c #68694C",
+",. c #505D40",
+"'. c #5F6E4B",
+"). c #61704C",
+"!. c #6F7C64",
+"~. c #6A6C68",
+"{. c #6C6C6C",
+"]. c #615F5D",
+"^. c #8E8E8E",
+"/. c #7F7F7F",
+"(. c #273024",
+"_. c #73805E",
+":. c #4A4C36",
+"<. c #434632",
+"[. c #56583E",
+"}. c #4B4D36",
+"|. c #484A35",
+"1. c #5C6647",
+"2. c #6A7652",
+"3. c #60704C",
+"4. c #667359",
+"5. c #4E514A",
+"6. c #585957",
+"7. c #525352",
+"8. c #686868",
+"9. c #3F3F3F",
+"0. c #313C2D",
+"a. c #5A7051",
+"b. c #6E7655",
+"c. c #5C684A",
+"d. c #6B7352",
+"e. c #5A6547",
+"f. c #68704F",
+"g. c #616E4B",
+"h. c #6E7954",
+"i. c #66734E",
+"j. c #37412C",
+"k. c #1D2317",
+"l. c #2C302A",
+"m. c #364430",
+"n. c #B3AB7D",
+"o. c #8B8E66",
+"p. c #B3AA7C",
+"q. c #898D64",
+"r. c #B2A97B",
+"s. c #898B63",
+"t. c #B2A87B",
+"u. c #868760",
+"v. c #171D12",
+"w. c #3B3829",
+"x. c #2D2E21",
+"y. c #2D2D20",
+"z. c #3B3828",
+"A. c #2C2C1F",
+"B. c #2A2A2A",
+" ",
+" . + @ # $ % ",
+" & * * . = - ",
+" ; > , ' ) ! ",
+" ~ { ] ^ / ",
+"( _ ~ { : < [ } | 1 2 3 4 5 ",
+"6 7 8 9 0 a b c } d e f g h ",
+"i j k l m n o p q r s t u v ",
+"w & x y * * z A B C D E F G ",
+"H I J K L M N O P Q B R F S ",
+"T U V W X Y Z ` ...+.@.#.$. ",
+"%.&.*.=.-.;.>.,.'.).!.~.{.].^./.",
+"(._.:.<.[.}.|.1.2.3.4.5.6.7.8.9.",
+"0.a.b.c.d.e.f.g.h.i.j.k.l.y ",
+" m.n.o.p.q.r.s.t.u.v. ! ",
+" w.x.w.x.w.y.z.A. B. "};
--- /dev/null
+/* XPM */
+static char * wep_closed_24_xpm[] = {
+"24 24 212 2",
+" c None",
+". c #333333",
+"+ c #727272",
+"@ c #737373",
+"# c #616161",
+"$ c #000000",
+"% c #202020",
+"& c #A5A5A5",
+"* c #EEEEEE",
+"= c #ECECEC",
+"- c #E7E7E7",
+"; c #E3E3E3",
+"> c #CBCBCB",
+", c #424242",
+"' c #1F1F1F",
+") c #D4D4D4",
+"! c #E8E8E8",
+"~ c #B5B5B5",
+"{ c #707070",
+"] c #6C6C6C",
+"^ c #BCBCBC",
+"/ c #DFDFDF",
+"( c #C8C8C8",
+"_ c #5B5B5B",
+": c #A4A4A4",
+"< c #818181",
+"[ c #919191",
+"} c #DDDDDD",
+"| c #2D2D2D",
+"1 c #3B3B3B",
+"2 c #EDEDED",
+"3 c #BABABA",
+"4 c #010101",
+"5 c #A0A0A0",
+"6 c #D6D6D6",
+"7 c #777777",
+"8 c #7F7F7F",
+"9 c #E2E2E2",
+"0 c #757575",
+"a c #3D3D3D",
+"b c #E6E6E6",
+"c c #AFAFAF",
+"d c #767676",
+"e c #DCDCDC",
+"f c #8B6C4F",
+"g c #AE8A6A",
+"h c #D2A06E",
+"i c #AD8562",
+"j c #90735A",
+"k c #8F7156",
+"l c #8E7054",
+"m c #8F7054",
+"n c #8E6F54",
+"o c #C99560",
+"p c #C48F5A",
+"q c #8A6849",
+"r c #79502A",
+"s c #331707",
+"t c #EFDBBF",
+"u c #E5C7A0",
+"v c #D8B385",
+"w c #D4AC7C",
+"x c #D0A873",
+"y c #CAA06A",
+"z c #C79C64",
+"A c #C89C64",
+"B c #C3985F",
+"C c #C09054",
+"D c #BC8545",
+"E c #B67A38",
+"F c #9A5E1B",
+"G c #2A1306",
+"H c #F0DABF",
+"I c #E4C6A0",
+"J c #D6AF80",
+"K c #D3AC7B",
+"L c #D0A570",
+"M c #C99F68",
+"N c #C69B64",
+"O c #C69C64",
+"P c #C89D66",
+"Q c #C79C65",
+"R c #C39860",
+"S c #C09256",
+"T c #BC8645",
+"U c #B67C36",
+"V c #985E1A",
+"W c #291306",
+"X c #EED8BC",
+"Y c #786752",
+"Z c #D2AC7D",
+"` c #D3AA7B",
+" . c #AA885C",
+".. c #896C46",
+"+. c #755C3B",
+"@. c #644F33",
+"#. c #634F33",
+"$. c #765D3C",
+"%. c #B58D59",
+"&. c #60492C",
+"*. c #604523",
+"=. c #7E5627",
+"-. c #995D1A",
+";. c #EED8BB",
+">. c #191611",
+",. c #C8A377",
+"'. c #D2A97A",
+"). c #7B6242",
+"!. c #57452C",
+"~. c #241C12",
+"{. c #99774C",
+"]. c #C59B64",
+"^. c #A57D4C",
+"/. c #140F08",
+"(. c #B27E3F",
+"_. c #36240F",
+":. c #623C11",
+"<. c #EFDABE",
+"[. c #332C23",
+"}. c #7F684B",
+"|. c #271F16",
+"1. c #5C4A32",
+"2. c #6D5638",
+"3. c #241C11",
+"4. c #98764C",
+"5. c #C49B62",
+"6. c #C49960",
+"7. c #A47D4A",
+"8. c #B8803E",
+"9. c #4B3216",
+"0. c #52330E",
+"a. c #EFD8BB",
+"b. c #4D4234",
+"c. c #443727",
+"d. c #1E1810",
+"e. c #3B2F1F",
+"f. c #816440",
+"g. c #231B11",
+"h. c #4B3B25",
+"i. c #614C30",
+"j. c #A58152",
+"k. c #A37C4A",
+"l. c #0A0704",
+"m. c #583E1E",
+"n. c #33220E",
+"o. c #86531A",
+"p. c #685947",
+"q. c #19140E",
+"r. c #7D6547",
+"s. c #0D0A07",
+"t. c #98774D",
+"u. c #97764A",
+"v. c #C49961",
+"w. c #A47C4A",
+"x. c #BA813E",
+"y. c #B27733",
+"z. c #A36B2F",
+"A. c #EDD6B8",
+"B. c #7F6B54",
+"C. c #3D3122",
+"D. c #B79161",
+"E. c #15110A",
+"F. c #A47D4C",
+"G. c #231A0F",
+"H. c #4A3822",
+"I. c #5F492C",
+"J. c #715634",
+"K. c #A17844",
+"L. c #140E07",
+"M. c #B67D3A",
+"N. c #B07530",
+"O. c #A67137",
+"P. c #EED8BA",
+"Q. c #E0C099",
+"R. c #D1A973",
+"S. c #CBA26B",
+"T. c #C49962",
+"U. c #C49A62",
+"V. c #C09257",
+"W. c #BD8C4E",
+"X. c #B9803D",
+"Y. c #B67D38",
+"Z. c #AB783F",
+"`. c #EED5B7",
+" + c #DFC096",
+".+ c #D2A776",
+"++ c #CEA46E",
+"@+ c #C89D65",
+"#+ c #C1955C",
+"$+ c #C2955C",
+"%+ c #C2965C",
+"&+ c #C09155",
+"*+ c #BC8A4B",
+"=+ c #BA8442",
+"-+ c #BE8A4C",
+";+ c #A9773C",
+">+ c #D5AE7E",
+",+ c #CFA772",
+"'+ c #C49256",
+")+ c #C08D51",
+"!+ c #BA8849",
+"~+ c #B78342",
+"{+ c #B48240",
+"]+ c #B68241",
+"^+ c #B88544",
+"/+ c #BB8949",
+"(+ c #BC8748",
+"_+ c #BA874A",
+":+ c #B98548",
+"<+ c #B27B3B",
+"[+ c #88521A",
+"}+ c #231005",
+" ",
+" ",
+" . + @ # $ ",
+" % & * = - ; > , ",
+" ' ) ! ~ { ] ^ / ( _ ",
+" : ! < $ [ } ^ | ",
+" 1 2 3 4 5 6 7 ",
+" 8 9 0 a b c $ ",
+" d e # a 3 $ ",
+" f g h i j k l l m m n o p q r ",
+" s t u v w x y z z A z B C D E F G ",
+" s H I J K L M N O P Q R S T U V W ",
+" s X Y Z ` ...+.@.#.$.%.&.*.=.-.W ",
+" s ;.>.,.'.).!.~.{.O ].^./.(._.:.W ",
+" s <.[.}.|.1.2.3.4.5.6.7./.8.9.0.W ",
+" s a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.W ",
+" s X p.q.r.s.t.3.u.v.R w./.x.y.z.W ",
+" s A.B.C.D.E.F.G.H.I.J.K.L.M.N.O.W ",
+" s P.Q.` R.S.N 6.T.U.v.V.W.X.Y.Z.W ",
+" s `. +.+++@+6.#+$+%+%+&+*+=+-+;+W ",
+" s >+,+'+)+!+~+{+]+^+/+(+_+:+<+[+}+ ",
+" G G W W W W W W W W W W W W }+ ",
+" ",
+" "};
+
git.samba.org / metze / wireshark / wip.git / commitdiff