7 files changed, 808 insertions, 1 deletions
diff --git a/noncore/net/wellenreiter/libwellenreiter/source/Makefile b/noncore/net/wellenreiter/libwellenreiter/source/Makefile index 05a5bd3..3670d96 100644 --- a/noncore/net/wellenreiter/libwellenreiter/source/Makefile +++ b/noncore/net/wellenreiter/libwellenreiter/source/Makefile @@ -1,17 +1,17 @@ # $Id$ INCLUDES = LIBRARIES = -LIBOBJ = sock.o log.o +LIBOBJ = proto.o sock.o log.o cardmode.o sniff.o CXX = g++ -Wall -pedantic -g $(INCLUDES) -DDEBUG static: libwellenreiter.a libwellenreiter.a: $(LIBOBJ) ar -cr libwellenreiter.a $(LIBOBJ) shared: libwellenreiter.so libwellenreiter.so: $(LIBOBJ) $(CXX) -shared -o libwellenreiter.so $(LIBOBJ) clean: rm -f *.o *.a *.so *~ diff --git a/noncore/net/wellenreiter/libwellenreiter/source/cardmode.cc b/noncore/net/wellenreiter/libwellenreiter/source/cardmode.cc new file mode 100644 index 0000000..62c2940 --- a/dev/null +++ b/noncore/net/wellenreiter/libwellenreiter/source/cardmode.cc @@ -0,0 +1,97 @@ +/* + * Set card modes for sniffing + * + * $Id$ + */ + +#include "cardmode.hh" + +/* main card into monitor function */ +int card_into_monitormode (void *orighandle, char *device, int cardtype) +{ + int datalink; /* used for getting the pcap datalink type */ + char CiscoRFMON[35] = "/proc/driver/aironet/"; + FILE *CISCO_CONFIG_FILE; + char errbuf[PCAP_ERRBUF_SIZE]; + pcap_t *handle; + + handle = (pcap_t *)orighandle; + + /* Checks if we have a device to sniff on */ + if(device == NULL) + { + wl_logerr("No device given"); + return 0; + } + + /* Setting the prmiscous and up flag to the interface */ + if (!card_set_promisc_up(device)) + { + wl_logerr("Cannot set interface to promisc mode: %s", strerror(errno)); + return 0; + } + wl_loginfo("Interface set to promisc mode"); + + /* Check the cardtype and executes the commands to go into monitor mode */ + if (cardtype == CARD_TYPE_CISCO) + { + /* bring the sniffer into rfmon mode */ + snprintf(CiscoRFMON, sizeof(CiscoRFMON), DEFAULT_PATH, device); + if((CISCO_CONFIG_FILE = fopen(CiscoRFMON,"w")) == NULL) + { + wl_logerr("Cannot open config file: %s", strerror(errno)); + return 0; + } + fputs ("Mode: r",CISCO_CONFIG_FILE); + fputs ("Mode: y",CISCO_CONFIG_FILE); + fputs ("XmitPower: 1",CISCO_CONFIG_FILE); + fclose(CISCO_CONFIG_FILE); + } + else if (cardtype == CARD_TYPE_NG) + { + char wlanngcmd[62]; + snprintf(wlanngcmd, sizeof(wlanngcmd), "%s %s lnxreq_wlansniff channel=1 enable=true", WLANCTL_PATH, device); + if (system(wlanngcmd) != 0) + { + wl_logerr("Could not set %s in raw mode, check cardtype", device); + return 0; + } + } + else if (cardtype == CARD_TYPE_HOSTAP) + { + wl_logerr("Got a host-ap card, nothing is implemented now"); + } + + /* Check the interface if it is in the correct raw mode */ + if((handle = pcap_open_live(device, BUFSIZ, 1, 0, errbuf)) == NULL) + { + wl_logerr("pcap_open_live() failed: %s", strerror(errno)); + return 0; + } + +#ifdef HAVE_PCAP_NONBLOCK + pcap_setnonblock(handle, 1, errstr); +#endif + + /* getting the datalink type */ + datalink = pcap_datalink(handle); + + if (datalink != DLT_IEEE802_11) /* Rawmode is IEEE802_11 */ + { + wl_loginfo("Interface %s does not work in the correct 802.11 raw mode", device); + pcap_close(handle); + return 0; + } + wl_loginfo("Your successfully listen on %s in 802.11 raw mode", device); + + return 1; +} + +/* Set card into promisc mode */ +int card_set_promisc_up (const char *device) +{ + char ifconfigcmd[32]; + snprintf(ifconfigcmd, sizeof(ifconfigcmd), SBIN_PATH, device); + + return (system(ifconfigcmd) ? 1 : 0); +} diff --git a/noncore/net/wellenreiter/libwellenreiter/source/cardmode.hh b/noncore/net/wellenreiter/libwellenreiter/source/cardmode.hh new file mode 100644 index 0000000..d80b24b --- a/dev/null +++ b/noncore/net/wellenreiter/libwellenreiter/source/cardmode.hh @@ -0,0 +1,34 @@ +/* $Id$ */ + +#ifndef CARDMODE_HH +#define CARDMODE_HH + +#include <string.h> +#include <stdlib.h> +#include <pcap.h> +#include <errno.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <net/bpf.h> + +#include "../../libwellenreiter/source/log.hh" + +/* Defines, used for the card setup */ +#define DEFAULT_PATH "/proc/driver/aironet/%s/Config" +#define CARD_TYPE_CISCO 1 +#define CARD_TYPE_NG 2 +#define CARD_TYPE_HOSTAP 3 + +/* only for now, until we have the daemon running */ +/*the config file should provide these information */ +#define CARD_TYPE CARD_TYPE_CISCO +#define SBIN_PATH "/sbin/ifconfig %s promisc up" +#define WLANCTL_PATH "/sbin/wlanctl-ng" + +/* Prototypes */ + +int card_into_monitormode (void *, char *, int); +int card_set_promisc_up (const char *); + +#endif /* CARDMODE_HH */ diff --git a/noncore/net/wellenreiter/libwellenreiter/source/extract.hh b/noncore/net/wellenreiter/libwellenreiter/source/extract.hh new file mode 100644 index 0000000..f948bcb --- a/dev/null +++ b/noncore/net/wellenreiter/libwellenreiter/source/extract.hh @@ -0,0 +1,59 @@ +/* $Id$ */ +/* + * Copyright (c) 1992, 1993, 1994, 1995, 1996 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that: (1) source code distributions + * retain the above copyright notice and this paragraph in its entirety, (2) + * distributions including binary code include the above copyright notice and + * this paragraph in its entirety in the documentation or other materials + * provided with the distribution, and (3) all advertising materials mentioning + * features or use of this software display the following acknowledgement: + * ``This product includes software developed by the University of California, + * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of + * the University nor the names of its contributors may be used to endorse + * or promote products derived from this software without specific prior + * written permission. + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. + */ +/* Network to host order macros */ + +#ifndef EXTRACT_HH +#define EXTRACT_HH + +#ifdef LBL_ALIGN +#define EXTRACT_16BITS(p) \ + ((u_int16_t)((u_int16_t)*((const u_int8_t *)(p) + 0) << 8 | \ + (u_int16_t)*((const u_int8_t *)(p) + 1))) +#define EXTRACT_32BITS(p) \ + ((u_int32_t)((u_int32_t)*((const u_int8_t *)(p) + 0) << 24 | \ + (u_int32_t)*((const u_int8_t *)(p) + 1) << 16 | \ + (u_int32_t)*((const u_int8_t *)(p) + 2) << 8 | \ + (u_int32_t)*((const u_int8_t *)(p) + 3))) +#else +#define EXTRACT_16BITS(p) \ + ((u_int16_t)ntohs(*(const u_int16_t *)(p))) +#define EXTRACT_32BITS(p) \ + ((u_int32_t)ntohl(*(const u_int32_t *)(p))) +#endif + +#define EXTRACT_24BITS(p) \ + ((u_int32_t)((u_int32_t)*((const u_int8_t *)(p) + 0) << 16 | \ + (u_int32_t)*((const u_int8_t *)(p) + 1) << 8 | \ + (u_int32_t)*((const u_int8_t *)(p) + 2))) + +/* Little endian protocol host order macros */ +#define EXTRACT_LE_8BITS(p) (*(p)) +#define EXTRACT_LE_16BITS(p) \ + ((u_int16_t)((u_int16_t)*((const u_int8_t *)(p) + 1) << 8 | \ + (u_int16_t)*((const u_int8_t *)(p) + 0))) +#define EXTRACT_LE_32BITS(p) \ + ((u_int32_t)((u_int32_t)*((const u_int8_t *)(p) + 3) << 24 | \ + (u_int32_t)*((const u_int8_t *)(p) + 2) << 16 | \ + (u_int32_t)*((const u_int8_t *)(p) + 1) << 8 | \ + (u_int32_t)*((const u_int8_t *)(p) + 0))) + +#endif /* EXTRACT_HH */ diff --git a/noncore/net/wellenreiter/libwellenreiter/source/ieee802_11.hh b/noncore/net/wellenreiter/libwellenreiter/source/ieee802_11.hh new file mode 100644 index 0000000..872fd40 --- a/dev/null +++ b/noncore/net/wellenreiter/libwellenreiter/source/ieee802_11.hh @@ -0,0 +1,250 @@ +/* $Id$ */ +/* + * Copyright (c) 2001 + * Fortress Technologies + * Charlie Lenahan ( clenahan@fortresstech.com ) + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that: (1) source code distributions + * retain the above copyright notice and this paragraph in its entirety, (2) + * distributions including binary code include the above copyright notice and + * this paragraph in its entirety in the documentation or other materials + * provided with the distribution, and (3) all advertising materials mentioning + * features or use of this software display the following acknowledgement: + * ``This product includes software developed by the University of California, + * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of + * the University nor the names of its contributors may be used to endorse + * or promote products derived from this software without specific prior + * written permission. + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. + */ + +#ifndef IEEE802_11_HH +#define IEEE802_11_HH + +#define IEEE802_11_FC_LEN 2 + +#define T_MGMT 0x0 /* management */ +#define T_CTRL 0x1 /* control */ +#define T_DATA 0x2 /* data */ +#define T_RESV 0x3 /* reserved */ + +#define ST_ASSOC_REQUEST 0x0 +#define ST_ASSOC_RESPONSE 0x1 +#define ST_REASSOC_REQUEST 0x2 +#define ST_REASSOC_RESPONSE 0x3 +#define ST_PROBE_REQUEST 0x4 +#define ST_PROBE_RESPONSE 0x5 +/* RESERVED 0x6 */ +/* RESERVED 0x7 */ +#define ST_BEACON 0x8 +#define ST_ATIM 0x9 +#define ST_DISASSOC 0xA +#define ST_AUTH 0xB +#define ST_DEAUTH 0xC +/* RESERVED 0xD */ +/* RESERVED 0xE */ +/* RESERVED 0xF */ + + +#define CTRL_PS_POLL 0xA +#define CTRL_RTS 0xB +#define CTRL_CTS 0xC +#define CTRL_ACK 0xD +#define CTRL_CF_END 0xE +#define CTRL_END_ACK 0xF + +/* + * Bits in the frame control field. + */ +#define FC_VERSION(fc) ((fc) & 0x3) +#define FC_TYPE(fc) (((fc) >> 2) & 0x3) +#define FC_SUBTYPE(fc) (((fc) >> 4) & 0xF) +#define FC_TO_DS(fc) ((fc) & 0x0100) +#define FC_FROM_DS(fc) ((fc) & 0x0200) +#define FC_MORE_FLAG(fc) ((fc) & 0x0400) +#define FC_RETRY(fc) ((fc) & 0x0800) +#define FC_POWER_MGMT(fc) ((fc) & 0x1000) +#define FC_MORE_DATA(fc) ((fc) & 0x2000) +#define FC_WEP(fc) ((fc) & 0x4000) +#define FC_ORDER(fc) ((fc) & 0x8000) + +struct mgmt_header_t { + u_int16_t fc; + u_int16_t duration; + u_int8_t da[6]; + u_int8_t sa[6]; + u_int8_t bssid[6]; + u_int16_t seq_ctrl; +}; + +#define MGMT_HEADER_LEN (2+2+6+6+6+2) + +#define CAPABILITY_ESS(cap) ((cap) & 0x0001) +#define CAPABILITY_IBSS(cap) ((cap) & 0x0002) +#define CAPABILITY_CFP(cap) ((cap) & 0x0004) +#define CAPABILITY_CFP_REQ(cap) ((cap) & 0x0008) +#define CAPABILITY_PRIVACY(cap) ((cap) & 0x0010) + +struct ssid_t { + u_int8_t element_id; + u_int8_t length; + u_char ssid[33]; /* 32 + 1 for null */ +} ; + +struct rates_t { + u_int8_t element_id; + u_int8_t length; + u_int8_t rate[8]; +}; + +struct challenge_t { + u_int8_t element_id; + u_int8_t length; + u_int8_t text[254]; /* 1-253 + 1 for null */ +}; +struct fh_t { + u_int8_t element_id; + u_int8_t length; + u_int16_t dwell_time; + u_int8_t hop_set; + u_int8_t hop_pattern; + u_int8_t hop_index; +}; + +struct ds_t { + u_int8_t element_id; + u_int8_t length; + u_int8_t channel; +}; + +struct cf_t { + u_int8_t element_id; + u_int8_t length; + u_int8_t count; + u_int8_t period; + u_int16_t max_duration; + u_int16_t dur_remaing; +}; + +struct tim_t { + u_int8_t element_id; + u_int8_t length; + u_int8_t count; + u_int8_t period; + u_int8_t bitmap_control; + u_int8_t bitmap[251]; +}; + +#define E_SSID 0 +#define E_RATES 1 +#define E_FH 2 +#define E_DS 3 +#define E_CF 4 +#define E_TIM 5 +#define E_IBSS 6 +#define E_CISCO 133 +/* reserved 7 */ +/* reserved 8 */ +/* reserved 9 */ +/* reserved 10 */ +/* reserved 11 */ +/* reserved 12 */ +/* reserved 13 */ +/* reserved 14 */ +/* reserved 15 */ +/* reserved 16 */ + +#define E_CHALLENGE 16 +/* reserved 17 */ +/* reserved 18 */ +/* reserved 19 */ +/* reserved 16 */ +/* reserved 16 */ + + +struct mgmt_body_t { + u_int8_t timestamp[8]; + u_int16_t beacon_interval; + u_int16_t listen_interval; + u_int16_t status_code; + u_int16_t aid; + u_char ap[6]; + u_int16_t reason_code; + u_int16_t auth_alg; + u_int16_t auth_trans_seq_num; + struct challenge_t challenge; + u_int16_t capability_info; + struct ssid_t ssid; + struct rates_t rates; + struct ds_t ds; + struct cf_t cf; + struct fh_t fh; + struct tim_t tim; +}; + +struct ctrl_rts_t { + u_int16_t fc; + u_int16_t duration; + u_int8_t ra[6]; + u_int8_t ta[6]; + u_int8_t fcs[4]; +}; + +#define CTRL_RTS_LEN (2+2+6+6+4) + +struct ctrl_cts_t { + u_int16_t fc; + u_int16_t duration; + u_int8_t ra[6]; + u_int8_t fcs[4]; +}; + +#define CTRL_CTS_LEN (2+2+6+4) + +struct ctrl_ack_t { + u_int16_t fc; + u_int16_t duration; + u_int8_t ra[6]; + u_int8_t fcs[4]; +}; + +#define CTRL_ACK_LEN (2+2+6+4) + +struct ctrl_ps_poll_t { + u_int16_t fc; + u_int16_t aid; + u_int8_t bssid[6]; + u_int8_t ta[6]; + u_int8_t fcs[4]; +}; + +#define CTRL_PS_POLL_LEN (2+2+6+6+4) + +struct ctrl_end_t { + u_int16_t fc; + u_int16_t duration; + u_int8_t ra[6]; + u_int8_t bssid[6]; + u_int8_t fcs[4]; +}; + +#define CTRL_END_LEN (2+2+6+6+4) + +struct ctrl_end_ack_t { + u_int16_t fc; + u_int16_t duration; + u_int8_t ra[6]; + u_int8_t bssid[6]; + u_int8_t fcs[4]; +}; + +#define CTRL_END_ACK_LEN (2+2+6+6+4) + +#define IV_IV(iv) ((iv) & 0xFFFFFF) +#define IV_PAD(iv) (((iv) >> 24) & 0x3F) +#define IV_KEYID(iv) (((iv) >> 30) & 0x03) + +#endif /* IEEE802_11_HH */ diff --git a/noncore/net/wellenreiter/libwellenreiter/source/sniff.cc b/noncore/net/wellenreiter/libwellenreiter/source/sniff.cc new file mode 100644 index 0000000..fedd8fc --- a/dev/null +++ b/noncore/net/wellenreiter/libwellenreiter/source/sniff.cc @@ -0,0 +1,303 @@ +/* + * rfmon mode sniffer + * + * $Id$ + */ + +#include "sniff.hh" +#include "ieee802_11.hh" +#include "extract.hh" +#include "log.hh" + +/* Main function, checks packets */ +void process_packets(const struct pcap_pkthdr *pkthdr, const unsigned char *packet) +{ + unsigned int caplen = pkthdr->caplen; + unsigned int length = pkthdr->len; + u_int16_t fc; + unsigned int HEADER_LENGTH; + + /* pinfo holds all interresting information for us */ + struct packetinfo pinfo; + struct packetinfo *pinfoptr; + pinfoptr=&pinfo; + + pinfoptr->isvalid = 0; + pinfoptr->pktlen = pkthdr->len; + + if (caplen < IEEE802_11_FC_LEN) + { + /* This is a garbage packet, because is does not long enough + to hold a 802.11b header */ + pinfoptr->isvalid = 0; + return; + } + + /* Gets the framecontrol bits (2bytes long) */ + fc = EXTRACT_LE_16BITS(packet); + + HEADER_LENGTH = GetHeaderLength(fc); + + if (caplen < HEADER_LENGTH) + { + /* This is a garbage packet, because it is not long enough + to hold a correct header of its type */ + pinfoptr->isvalid = 0; + return; + } + + /* Decode 802.11b header out of the packet */ + if (decode_80211b_hdr(packet,pinfoptr) == 0) + { + /* Justification of the ofset to further process the packet */ + length -= HEADER_LENGTH; + caplen -= HEADER_LENGTH; + packet += HEADER_LENGTH; + } + else /* Something is wrong,could not be a correct packet */ + return; + + switch (FC_TYPE(fc)) + { + /* Is it a managemnet frame? */ + case T_MGMT: + switch (FC_SUBTYPE(fc)) + { + case ST_BEACON: + if (handle_beacon(fc, packet,pinfoptr) ==0) + { + if (!strcmp(pinfoptr->desthwaddr,"ff:ff:ff:ff:ff:ff") == 0) + { + /* Every beacon must have the broadcast as destination + so it must be a shitti packet */ + pinfoptr->isvalid = 0; + return; + } + + if (pinfoptr->cap_ESS == pinfoptr->cap_IBSS) + { + /* Only one of both are possible, so must be + a noise packet, if this comes up */ + pinfoptr->isvalid = 0; + return; + } + if (pinfoptr->channel < 1 || pinfoptr->channel > 14) + { + /* Only channels between 1 and 14 are possible + others must be noise packets */ + pinfoptr->isvalid = 0; + return; + } + + + /* Here should be the infos to the gui issued */ + if (pinfoptr->cap_ESS == 1 &&pinfoptr->cap_IBSS ==0) + { + printf ("\nHave found an accesspoint:"); + } + else if(pinfoptr->cap_ESS == 0 && pinfoptr->cap_IBSS == 1) + { + printf ("\nHave found an AD-HOC station:"); + + } + if (strcmp (pinfoptr->ssid,NONBROADCASTING) ==0) + { + printf ("\n\tOn a non-broadcasting network"); + } + else + { + printf ("\n\tOn network : %s",pinfoptr->ssid); + } + printf ("\n\tLen SSID : %d",pinfoptr->ssid_len); + printf ("\n\tOn Channel : %d",pinfoptr->channel); + printf ("\n\tEncryption : %s", pinfoptr->cap_WEP ? "ON" : "OFF"); + printf ("\n\tMacaddress : %s",pinfoptr->sndhwaddr); + printf ("\n\tBssid : %s",pinfoptr->bssid); + printf ("\n\tDest : %s\n",pinfoptr->desthwaddr); + } + break; + default: + wl_logerr("Unknown IEEE802.11 frame subtype (%d)", FC_SUBTYPE(fc)); + break; + } /* End of switch over different mgt frame types */ + + break; + + case T_CTRL: + wl_loginfo("Received control frame, not implemented yet"); + break; + + case T_DATA: + wl_loginfo("Received date frame, not implemented yet"); + break; + + default: + wl_logerr("Unknown IEEE802.11 frame type (%d)", FC_TYPE(fc)); + break; + } +} + +/* This decodes the 802.11b frame header out of the 802.11b packet + all the infos is placed into the packetinfo structure */ +int decode_80211b_hdr(const u_char *p,struct packetinfo *ppinfo) +{ + const struct mgmt_header_t *mgthdr = (const struct mgmt_header_t *) p; + ppinfo->fcsubtype = FC_SUBTYPE(mgthdr->fc); + + /* Get the sender, bssid and dest mac address */ + etheraddr_string(mgthdr->bssid,ppinfo->bssid); + etheraddr_string(mgthdr->da,ppinfo->desthwaddr); + etheraddr_string(mgthdr->sa,ppinfo->sndhwaddr); + ppinfo->fc_wep = FC_WEP(mgthdr->fc); + return 0; +} + + +void etheraddr_string(register const u_char *ep, char *text) +{ + static char hex[] = "0123456789abcdef"; + register unsigned int i, j; + register char *cp; + char buf[sizeof("00:00:00:00:00:00")]; + cp = buf; + if ((j = *ep >> 4) != 0) + *cp++ = hex[j]; + *cp++ = hex[*ep++ & 0xf]; + for (i = 5; (int)--i >= 0;) { + *cp++ = ':'; + if ((j = *ep >> 4) != 0) + *cp++ = hex[j]; + *cp++ = hex[*ep++ & 0xf]; + } + *cp = '\0'; + strcpy(text,buf); +} + +/* beacon handler */ +int handle_beacon(u_int16_t fc, const u_char *p,struct packetinfo *ppinfo) +{ + struct mgmt_body_t pbody; + int offset = 0; + + /* Get the static informations out of the packet */ + memset(&pbody, 0, sizeof(pbody)); + memcpy(&pbody.timestamp, p, 8); + offset += 8; + pbody.beacon_interval = EXTRACT_LE_16BITS(p+offset); + offset += 2; + pbody.capability_info = EXTRACT_LE_16BITS(p+offset); + offset += 2; + + /* Gets the different flags out of the capabilities */ + ppinfo->cap_ESS = CAPABILITY_ESS(pbody.capability_info); + ppinfo->cap_IBSS = CAPABILITY_IBSS(pbody.capability_info); + ppinfo->cap_WEP = CAPABILITY_PRIVACY(pbody.capability_info); + + /* Gets the tagged elements out of the packets */ + while (offset + 1 < ppinfo->pktlen) + { + switch (*(p + offset)) + { + case E_SSID: + memcpy(&(pbody.ssid),p+offset,2); offset += 2; + if (pbody.ssid.length > 0) + { + memcpy(&(pbody.ssid.ssid),p+offset,pbody.ssid.length); offset += pbody.ssid.length; + pbody.ssid.ssid[pbody.ssid.length]='\0'; + if (strcmp((char *)pbody.ssid.ssid,"")==0) + ppinfo->ssid = NONBROADCASTING; + else + ppinfo->ssid = (char *)pbody.ssid.ssid; + ppinfo->ssid_len = pbody.ssid.length; + } + break; + + case E_CHALLENGE: + memcpy(&(pbody.challenge),p+offset,2); offset += 2; + if (pbody.challenge.length > 0) + { + memcpy(&(pbody.challenge.text),p+offset,pbody.challenge.length); offset += pbody.challenge.length; + pbody.challenge.text[pbody.challenge.length]='\0'; + } + break; + case E_RATES: + memcpy(&(pbody.rates),p+offset,2); offset += 2; + if (pbody.rates.length > 0) + { + memcpy(&(pbody.rates.rate),p+offset,pbody.rates.length); offset += pbody.rates.length; + } + break; + case E_DS: + memcpy(&(pbody.ds),p+offset,3); offset +=3; + ppinfo->channel = pbody.ds.channel; + break; + case E_CF: + memcpy(&(pbody.cf),p+offset,8); offset +=8; + break; + case E_TIM: + memcpy(&(pbody.tim),p+offset,2); offset +=2; + memcpy(&(pbody.tim.count),p+offset,3); offset +=3; + if ((pbody.tim.length -3) > 0) + { + memcpy((pbody.tim.bitmap),p+(pbody.tim.length -3),(pbody.tim.length -3)); + offset += pbody.tim.length -3; + } + break; + default: + + offset+= *(p+offset+1) + 2; + break; + } /* end of switch*/ + } /* end of for loop */ + return 0; + +} /* End of handle_beacon */ + + +int GetHeaderLength(u_int16_t fc) +{ + int iLength=0; + + switch (FC_TYPE(fc)) + { + case T_MGMT: + iLength = MGMT_HEADER_LEN; + break; + case T_CTRL: + switch (FC_SUBTYPE(fc)) + { + case CTRL_PS_POLL: + iLength = CTRL_PS_POLL_LEN; + break; + case CTRL_RTS: + iLength = CTRL_RTS_LEN; + break; + case CTRL_CTS: + iLength = CTRL_CTS_LEN; + break; + case CTRL_ACK: + iLength = CTRL_ACK_LEN; + break; + case CTRL_CF_END: + iLength = CTRL_END_LEN; + break; + case CTRL_END_ACK: + iLength = CTRL_END_ACK_LEN; + break; + default: + iLength = 0; + break; + } + break; + case T_DATA: + if (FC_TO_DS(fc) && FC_FROM_DS(fc)) + iLength = 30; + else + iLength = 24; + break; + default: + wl_logerr("unknown IEEE802.11 frame type (%d)", FC_TYPE(fc)); + break; + } + return iLength; +} diff --git a/noncore/net/wellenreiter/libwellenreiter/source/sniff.hh b/noncore/net/wellenreiter/libwellenreiter/source/sniff.hh new file mode 100644 index 0000000..fa8519b --- a/dev/null +++ b/noncore/net/wellenreiter/libwellenreiter/source/sniff.hh @@ -0,0 +1,64 @@ +/* $Id$ */ + +#ifndef SNIFF_HH +#define SNIFF_HH + +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <pcap.h> +#include <errno.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <net/bpf.h> + +#define NONBROADCASTING "non-broadcasting" + +/* holds all the interresting data */ +struct packetinfo +{ + int isvalid; + int pktlen; + int fctype; + int fcsubtype; + int fc_wep; + int cap_WEP; + int cap_IBSS; + int cap_ESS; + int channel; + char bssid[sizeof("00:00:00:00:00:00")]; + char desthwaddr[sizeof("00:00:00:00:00:00")]; + char sndhwaddr[sizeof("00:00:00:00:00:00")]; + char *ssid; + int ssid_len; +}; + +void process_packets(const struct pcap_pkthdr* pkthdr,const u_char* packet); +int decode_80211b_hdr(const u_char *p,struct packetinfo *ppinfo); +void etheraddr_string(register const u_char *ep,char * text); +int handle_beacon(u_int16_t fc, const u_char *p,struct packetinfo *ppinfo); + +int GetHeaderLength(u_int16_t fc); + +/* + * True if "l" bytes of "var" were captured. + * + * The "snapend - (l) <= snapend" checks to make sure "l" isn't so large + * that "snapend - (l)" underflows. + * + * The check is for <= rather than < because "l" might be 0. + */ +#define TTEST2(var, l) (snapend - (l) <= snapend && \ + (const u_char *)&(var) <= snapend - (l)) + +/* True if "var" was captured */ +#define TTEST(var) TTEST2(var, sizeof(var)) + +/* Bail if "l" bytes of "var" were not captured */ +#define TCHECK2(var, l) if (!TTEST2(var, l)) goto trunc + +/* Bail if "var" was not captured */ +#define TCHECK(var) TCHECK2(var, sizeof(var)) + +#endif /* SNIFF_HH */ |