2 This file is part of GNUnet.
3 Copyright (C) 2010, 2011, 2012 GNUnet e.V.
4 Copyright (c) 2007, 2008, Andy Green <andy@warmcat.com>
5 Copyright Copyright (C) 2009 Thomas d'Otreppe
7 GNUnet is free software: you can redistribute it and/or modify it
8 under the terms of the GNU Affero General Public License as published
9 by the Free Software Foundation, either version 3 of the License,
10 or (at your option) any later version.
12 GNUnet is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Affero General Public License for more details.
17 You should have received a copy of the GNU Affero General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 SPDX-License-Identifier: AGPL3.0-or-later
23 * @file src/transport/gnunet-helper-transport-wlan.c
24 * @brief mediator between the wlan interface and gnunet; must run as root (SUID will do)
25 * This code will work under GNU/Linux only.
26 * @author David Brodski
27 * @author Christian Grothoff
29 * This program will allow receiving and sending traffic from the WLAN
30 * interface. It will force traffic to be in 'ad-hoc' mode, use the
31 * proper MAC address of the WLAN interface and use a GNUnet-specific
32 * SSID (and a GNUnet-specific SNAP header). It only takes a single
33 * argument, which is the name of the WLAN interface to use. The
34 * program detects if the interface is not a WLAN interface and exits
35 * with an error in that case.
37 * Once initialized, the program will first send a 'struct
38 * GNUNET_TRANSPORT_WLAN_HelperControlMessage' to 'stdout'. That
39 * message contains the MAC address of the WLAN interface. It will
40 * then read messages from the WLAN interface and send them together
41 * with performance information as 'struct
42 * GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage' messages to 'stdout'.
43 * Furthermore, it will read a stream of messages from 'stdin' that
44 * have the format from 'struct
45 * GNUNET_TRANSPORT_WLAN_RadiotapSendMessage'. Those messages will
46 * then be sent via the WLAN interface; however, the sender MAC
47 * address will be forced to be the correct address from our WLAN
48 * card. If 'stdin' closes, receiving from the WLAN interface will
49 * continue. If 'stdout' causes a SIGPIPE, the process dies from the
50 * signal. Errors cause an error message to be reported to 'stderr',
51 * in most cases the process also exits (with status code '1'). The
52 * program never terminates normally; it is safe to kill the
53 * process with SIGTERM or SIGKILL at any time.
55 * Since it uses RAW sockets, the binary must be installed SUID or run
56 * as 'root'. In order to keep the security risk of the resulting
57 * SUID binary minimal, the program ONLY opens the RAW socket with
58 * root privileges, then drops them and only then starts to process
59 * command line arguments. The code also does not link against any
60 * shared libraries (except libc) and is strictly minimal (except for
61 * checking for errors). The following list of people have reviewed
62 * this code and considered it safe since the last modification (if
63 * you reviewed it, please have your name added to the list):
65 * - Christian Grothoff (Apr 3rd 2012)
69 * we use our local copy of ieee80211_radiotap.h
71 * - since we can't support extensions we don't understand
72 * - since linux does not include it in userspace headers
74 * Portions of this code were taken from the ieee80211_radiotap.h header,
77 * Copyright (c) 2003, 2004 David Young. All rights reserved.
79 * Redistribution and use in source and binary forms, with or without
80 * modification, are permitted provided that the following conditions
82 * 1. Redistributions of source code must retain the above copyright
83 * notice, this list of conditions and the following disclaimer.
84 * 2. Redistributions in binary form must reproduce the above copyright
85 * notice, this list of conditions and the following disclaimer in the
86 * documentation and/or other materials provided with the distribution.
87 * 3. The name of David Young may not be used to endorse or promote
88 * products derived from this software without specific prior
91 * THIS SOFTWARE IS PROVIDED BY DAVID YOUNG ``AS IS'' AND ANY
92 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
93 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
94 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DAVID
95 * YOUNG BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
96 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
97 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
98 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
99 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
100 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
101 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
106 * Modifications to fit into the linux IEEE 802.11 stack,
107 * Mike Kershaw (dragorn@kismetwireless.net)
110 * parts taken from aircrack-ng, parts changend.
112 #include "gnunet_config.h"
115 #include <sys/socket.h>
116 #include <sys/ioctl.h>
117 #include <sys/types.h>
119 #include <sys/wait.h>
120 #include <sys/time.h>
121 #include <sys/stat.h>
122 #include <netpacket/packet.h>
123 #include <linux/if_ether.h>
124 #include <linux/if.h>
125 #include <linux/wireless.h>
126 #include <netinet/in.h>
127 #include <linux/if_tun.h>
135 #include <sys/param.h>
139 #include "gnunet_protocols.h"
140 #include "plugin_transport_wlan.h"
143 * Packet format type for the messages we receive from
144 * the kernel. This is for Ethernet 10Mbps format (no
145 * performance information included).
147 #define ARPHRD_ETHER 1
151 * Packet format type for the messages we receive from
152 * the kernel. This is for plain messages (with no
153 * performance information included).
155 #define ARPHRD_IEEE80211 801
159 * Packet format type for the messages we receive from
160 * the kernel. This is for the PRISM format.
162 #define ARPHRD_IEEE80211_PRISM 802
165 * Packet format type for the messages we receive from
166 * the kernel. This is for messages with a
167 * 'struct Ieee80211RadiotapHeader' (see below).
169 #define ARPHRD_IEEE80211_FULL 803
173 * Maximum size of a message allowed in either direction
174 * (used for our receive and sent buffers).
180 /* ********* structure of messages of type ARPHRD_IEEE80211_PRISM *********** */
183 * Device name length in PRISM frames.
184 * (In the kernel, this is "WLAN_DEVNAMELEN_MAX")
186 #define PRISM_DEVICE_NAME_LENGTH 16
189 * Monitor Frame (indicator that we have a 'struct PrismHeader').
191 #define PRISM_MSGCODE_MONITOR 0x0041
194 * Mac time element. In micro-seconds.
195 * Drivers appear to use a 64bit counter to hold mactime internal
196 * the then fill the prism header with the lower 32 bits
198 #define PRISM_DID_MACTIME 0x2041
203 #define PRISM_DID_CHANNEL 0x3041
206 * Signal element. Should be the signal strength in dbm, some people
207 * suggest that instead "100 - (strength in dbm)" is used (to make this
208 * a positive integer).
210 #define PRISM_DID_SIGNAL 0x6041
215 #define PRISM_DID_NOISE 0x7041
218 * Rate element, in units/multiples of 500Khz
220 #define PRISM_DID_RATE 0x8041
224 * Value is set (supplied)
226 #define PRISM_STATUS_OK 0
229 * Value not supplied.
231 #define PRISM_STATUS_NO_VALUE 1
235 * Values in the 'struct PrismHeader'. All in host byte order (!).
240 * This has a different ID for each parameter, see
241 * PRISM_DID_* constants.
246 * See PRISM_STATUS_*-constants. Note that they are unusual: 0 = set; 1 = not set
251 * length of data (which is always a uint32_t, but presumably this can be used
252 * to specify that fewer bytes are used (with values in 'len' from 0-4). We
261 } __attribute__ ((packed));
265 * Prism header format ('struct p80211msg' in Linux). All in host byte order (!).
270 * We expect this to be a PRISM_MSGCODE_*.
275 * The length of the entire header.
280 * Name of the device that captured the packet.
282 char devname[PRISM_DEVICE_NAME_LENGTH];
284 /* followed by 'struct PrismValue's. Documentation suggests that these
285 are typically the hosttime, mactime, channel, rssi, sq, signal, noise,
286 rate, istx and frmlen values, but documentation is sparse. So we
287 will use the 'did' fields to find out what we actually got. */
288 } __attribute__ ((packed));
291 /* ****** end of structure of messages of type ARPHRD_IEEE80211_PRISM ******* */
293 /* ********** structure of messages of type ARPHRD_IEEE80211_FULL *********** */
296 * Bits in the 'it_present' bitmask from the 'struct
297 * Ieee80211RadiotapHeader'. For each value, we give the name, data
298 * type, unit and then a description below. Note that the actual size
299 * of the extension can be bigger as arguments must be padded so that
300 * args of a given length must begin at a boundary of that length.
301 * However, note that compound args are allowed (eg, 2 x uint16_t for
302 * IEEE80211_RADIOTAP_CHANNEL) so total argument length is not a
303 * reliable indicator of alignment requirement. See also
304 * 'man 9 ieee80211_radiotap'.
309 * IEEE80211_RADIOTAP_TSFT __le64 microseconds
311 * Value in microseconds of the MAC's 64-bit 802.11 Time
312 * Synchronization Function timer when the first bit of the
313 * MPDU arrived at the MAC. For received frames, only.
315 IEEE80211_RADIOTAP_TSFT = 0,
318 * IEEE80211_RADIOTAP_FLAGS uint8_t bitmap
320 * Properties of transmitted and received frames. See flags
323 IEEE80211_RADIOTAP_FLAGS = 1,
326 * IEEE80211_RADIOTAP_RATE uint8_t 500kb/s
330 IEEE80211_RADIOTAP_RATE = 2,
333 * IEEE80211_RADIOTAP_CHANNEL 2 x __le16 MHz, bitmap
335 * Tx/Rx frequency in MHz, followed by flags (see below).
337 IEEE80211_RADIOTAP_CHANNEL = 3,
339 * IEEE80211_RADIOTAP_FHSS __le16 see below
341 * For frequency-hopping radios, the hop set (first byte)
342 * and pattern (second byte).
344 IEEE80211_RADIOTAP_FHSS = 4,
347 * IEEE80211_RADIOTAP_DBM_ANTSIGNAL s8 decibels from
348 * one milliwatt (dBm)
350 * RF signal power at the antenna, decibel difference from
353 IEEE80211_RADIOTAP_DBM_ANTSIGNAL = 5,
356 * IEEE80211_RADIOTAP_DBM_ANTNOISE s8 decibels from
357 * one milliwatt (dBm)
359 * RF noise power at the antenna, decibel difference from one
362 IEEE80211_RADIOTAP_DBM_ANTNOISE = 6,
365 * IEEE80211_RADIOTAP_LOCK_QUALITY __le16 unitless
367 * Quality of Barker code lock. Unitless. Monotonically
368 * nondecreasing with "better" lock strength. Called "Signal
369 * Quality" in datasheets. (Is there a standard way to measure
372 IEEE80211_RADIOTAP_LOCK_QUALITY = 7,
375 * IEEE80211_RADIOTAP_TX_ATTENUATION __le16 unitless
377 * Transmit power expressed as unitless distance from max
378 * power set at factory calibration. 0 is max power.
379 * Monotonically nondecreasing with lower power levels.
381 IEEE80211_RADIOTAP_TX_ATTENUATION = 8,
384 * IEEE80211_RADIOTAP_DB_TX_ATTENUATION __le16 decibels (dB)
386 * Transmit power expressed as decibel distance from max power
387 * set at factory calibration. 0 is max power. Monotonically
388 * nondecreasing with lower power levels.
390 IEEE80211_RADIOTAP_DB_TX_ATTENUATION = 9,
393 * IEEE80211_RADIOTAP_DBM_TX_POWER s8 decibels from
394 * one milliwatt (dBm)
396 * Transmit power expressed as dBm (decibels from a 1 milliwatt
397 * reference). This is the absolute power level measured at
400 IEEE80211_RADIOTAP_DBM_TX_POWER = 10,
403 * IEEE80211_RADIOTAP_ANTENNA uint8_t antenna index
405 * Unitless indication of the Rx/Tx antenna for this packet.
406 * The first antenna is antenna 0.
408 IEEE80211_RADIOTAP_ANTENNA = 11,
411 * IEEE80211_RADIOTAP_DB_ANTSIGNAL uint8_t decibel (dB)
413 * RF signal power at the antenna, decibel difference from an
414 * arbitrary, fixed reference.
416 IEEE80211_RADIOTAP_DB_ANTSIGNAL = 12,
419 * IEEE80211_RADIOTAP_DB_ANTNOISE uint8_t decibel (dB)
421 * RF noise power at the antenna, decibel difference from an
422 * arbitrary, fixed reference point.
424 IEEE80211_RADIOTAP_DB_ANTNOISE = 13,
427 * IEEE80211_RADIOTAP_RX_FLAGS __le16 bitmap
429 * Properties of received frames. See flags defined below.
431 IEEE80211_RADIOTAP_RX_FLAGS = 14,
434 * IEEE80211_RADIOTAP_TX_FLAGS __le16 bitmap
436 * Properties of transmitted frames. See flags defined below.
438 IEEE80211_RADIOTAP_TX_FLAGS = 15,
441 * IEEE80211_RADIOTAP_RTS_RETRIES uint8_t data
443 * Number of rts retries a transmitted frame used.
445 IEEE80211_RADIOTAP_RTS_RETRIES = 16,
448 * IEEE80211_RADIOTAP_DATA_RETRIES uint8_t data
450 * Number of unicast retries a transmitted frame used.
452 IEEE80211_RADIOTAP_DATA_RETRIES = 17,
455 * Extension bit, used to indicate that more bits are needed for
458 IEEE80211_RADIOTAP_EXT = 31
462 * Bitmask indicating an extension of the bitmask is used.
463 * (Mask corresponding to IEEE80211_RADIOTAP_EXT).
465 #define IEEE80211_RADIOTAP_PRESENT_EXTEND_MASK (1 << IEEE80211_RADIOTAP_EXT)
470 * Bit in IEEE80211_RADIOTAP_FLAGS (which we might get
471 * as part of a 'struct Ieee80211RadiotapHeader' extension
472 * if the IEEE80211_RADIOTAP_FLAGS bit is set in
473 * 'it_present'). The radiotap flags are an 8-bit field.
475 * Frame was sent/received during CFP (Contention Free Period)
477 #define IEEE80211_RADIOTAP_F_CFP 0x01
480 * Bit in IEEE80211_RADIOTAP_FLAGS (which we might get
481 * as part of a 'struct Ieee80211RadiotapHeader' extension
482 * if the IEEE80211_RADIOTAP_FLAGS bit is set in
483 * 'it_present'). The radiotap flags are an 8-bit field.
485 * Frame was sent/received with short preamble
487 #define IEEE80211_RADIOTAP_F_SHORTPRE 0x02
490 * Bit in IEEE80211_RADIOTAP_FLAGS (which we might get
491 * as part of a 'struct Ieee80211RadiotapHeader' extension
492 * if the IEEE80211_RADIOTAP_FLAGS bit is set in
493 * 'it_present'). The radiotap flags are an 8-bit field.
495 * Frame was sent/received with WEP encryption
497 #define IEEE80211_RADIOTAP_F_WEP 0x04
500 * Bit in IEEE80211_RADIOTAP_FLAGS (which we might get
501 * as part of a 'struct Ieee80211RadiotapHeader' extension
502 * if the IEEE80211_RADIOTAP_FLAGS bit is set in
503 * 'it_present'). The radiotap flags are an 8-bit field.
505 * Frame was sent/received with fragmentation
507 #define IEEE80211_RADIOTAP_F_FRAG 0x08
510 * Bit in IEEE80211_RADIOTAP_FLAGS (which we might get
511 * as part of a 'struct Ieee80211RadiotapHeader' extension
512 * if the IEEE80211_RADIOTAP_FLAGS bit is set in
513 * 'it_present'). The radiotap flags are an 8-bit field.
515 * Frame includes FCS (CRC at the end that needs to be removeD).
517 #define IEEE80211_RADIOTAP_F_FCS 0x10
520 * Bit in IEEE80211_RADIOTAP_FLAGS (which we might get
521 * as part of a 'struct Ieee80211RadiotapHeader' extension
522 * if the IEEE80211_RADIOTAP_FLAGS bit is set in
523 * 'it_present'). The radiotap flags are an 8-bit field.
525 * Frame has padding between 802.11 header and payload
526 * (to 32-bit boundary)
528 #define IEEE80211_RADIOTAP_F_DATAPAD 0x20
532 * For IEEE80211_RADIOTAP_RX_FLAGS:
533 * frame failed crc check
535 #define IEEE80211_RADIOTAP_F_RX_BADFCS 0x0001
538 * For IEEE80211_RADIOTAP_TX_FLAGS ('txflags' in 'struct RadiotapTransmissionHeader'):
539 * failed due to excessive retries
541 #define IEEE80211_RADIOTAP_F_TX_FAIL 0x0001
544 * For IEEE80211_RADIOTAP_TX_FLAGS ('txflags' in 'struct RadiotapTransmissionHeader'):
545 * used cts 'protection'
547 #define IEEE80211_RADIOTAP_F_TX_CTS 0x0002
550 * For IEEE80211_RADIOTAP_TX_FLAGS ('txflags' in 'struct RadiotapTransmissionHeader'):
551 * used rts/cts handshake
553 #define IEEE80211_RADIOTAP_F_TX_RTS 0x0004
556 * For IEEE80211_RADIOTAP_TX_FLAGS ('txflags' in 'struct RadiotapTransmissionHeader'):
557 * frame should not be ACKed
559 #define IEEE80211_RADIOTAP_F_TX_NOACK 0x0008
562 * For IEEE80211_RADIOTAP_TX_FLAGS ('txflags' in 'struct RadiotapTransmissionHeader'):
563 * sequence number handled by userspace
565 #define IEEE80211_RADIOTAP_F_TX_NOSEQ 0x0010
569 * Generic header for radiotap messages (receiving and sending). A
570 * bit mask (it_present) determines which specific records follow.
572 * I am trying to describe precisely what the application programmer
573 * should expect in the following, and for that reason I tell the
574 * units and origin of each measurement (where it applies), or else I
575 * use sufficiently weaselly language ("is a monotonically nondecreasing
576 * function of...") that I cannot set false expectations for lawyerly
579 * The radio capture header precedes the 802.11 header.
580 * All data in the header is little endian on all platforms.
582 struct Ieee80211RadiotapHeader
585 * Version 0. Only increases for drastic changes, introduction of
586 * compatible new fields does not count.
596 * length of the whole header in bytes, including it_version,
597 * it_pad, it_len, and data fields.
602 * A bitmap telling which fields are present. Set bit 31
603 * (0x80000000) to extend the bitmap by another 32 bits. Additional
604 * extensions are made by setting bit 31.
611 * Format of the header we need to prepend to messages to be sent to the
614 struct RadiotapTransmissionHeader
617 * First we begin with the 'generic' header we also get when receiving
620 struct Ieee80211RadiotapHeader header;
623 * Transmission rate (we use 0, kernel makes up its mind anyway).
628 * Padding (we use 0). There is a requirement to pad args, so that
629 * args of a given length must begin at a boundary of that length.
630 * As our next argument is the 'it_len' with 2 bytes, we need 1 byte
636 * Transmission flags from on the IEEE80211_RADIOTAP_F_TX_* constant family.
642 * The above 'struct RadiotapTransmissionHeader' should have the
643 * following value for 'header.it_present' based on the presence of
644 * the 'rate' and 'txflags' in the overall struct.
646 #define IEEE80211_RADIOTAP_OUR_TRANSMISSION_HEADER_MASK ((1 \
648 IEEE80211_RADIOTAP_RATE) \
651 IEEE80211_RADIOTAP_TX_FLAGS))
656 * struct Ieee80211RadiotapHeaderIterator - tracks walk through present radiotap arguments
657 * in the radiotap header. Used when we parse radiotap packets received from the kernel.
659 struct Ieee80211RadiotapHeaderIterator
662 * pointer to the radiotap header we are walking through
664 const struct Ieee80211RadiotapHeader *rtheader;
667 * pointer to current radiotap arg
669 const uint8_t *this_arg;
672 * internal next argument pointer
677 * internal pointer to next present uint32_t (if IEEE80211_RADIOTAP_EXT is used).
679 const uint32_t *next_bitmap;
682 * length of radiotap header in host byte ordering
687 * internal shifter for current uint32_t bitmap, (it_present in host byte order),
688 * If bit 0 is set, the 'arg_index' argument is present.
690 uint32_t bitmap_shifter;
693 * IEEE80211_RADIOTAP_... index of current arg
695 unsigned int this_arg_index;
698 * internal next argument index
700 unsigned int arg_index;
704 /* ************** end of structure of ARPHRD_IEEE80211_FULL ************** */
706 /* ************************** our globals ******************************* */
709 * struct for storing the information of the hardware. There is only
715 * file descriptor for the raw socket
720 * Which format has the header that we're getting when receiving packets?
721 * Some ARPHRD_IEEE80211_XXX-value.
726 * Name of the interface, not necessarily 0-terminated (!).
728 char iface[IFNAMSIZ];
731 * MAC address of our own WLAN interface.
733 struct GNUNET_TRANSPORT_WLAN_MacAddress pl_mac;
738 * IO buffer used for buffering data in transit (to wireless or to stdout).
743 * How many bytes of data are stored in 'buf' for transmission right now?
744 * Data always starts at offset 0 and extends to 'size'.
749 * How many bytes that were stored in 'buf' did we already write to the
750 * destination? Always smaller than 'size'.
755 * Buffered data; twice the maximum allowed message size as we add some
758 char buf[MAXLINE * 2];
763 * Buffer for data read from stdin to be transmitted to the wirless card.
765 static struct SendBuffer write_pout;
768 * Buffer for data read from the wireless card to be transmitted to stdout.
770 static struct SendBuffer write_std;
774 /* *********** specialized version of server_mst.c begins here ********** */
777 * To what multiple do we align messages? 8 byte should suffice for everyone
780 #define ALIGN_FACTOR 8
783 * Smallest supported message.
785 #define MIN_BUFFER_SIZE sizeof(struct GNUNET_MessageHeader)
789 * Functions with this signature are called whenever a
790 * complete message is received by the tokenizer.
793 * @param message the actual message
795 typedef void (*MessageTokenizerCallback) (void *cls,
797 GNUNET_MessageHeader *
801 * Handle to a message stream tokenizer.
803 struct MessageStreamTokenizer
806 * Function to call on completed messages.
808 MessageTokenizerCallback cb;
816 * Size of the buffer (starting at 'hdr').
821 * How many bytes in buffer have we already processed?
826 * How many bytes in buffer are valid right now?
831 * Beginning of the buffer. Typed like this to force alignment.
833 struct GNUNET_MessageHeader *hdr;
838 * Create a message stream tokenizer.
840 * @param cb function to call on completed messages
841 * @param cb_cls closure for cb
842 * @return handle to tokenizer
844 static struct MessageStreamTokenizer *
845 mst_create (MessageTokenizerCallback cb,
848 struct MessageStreamTokenizer *ret;
850 ret = malloc (sizeof(struct MessageStreamTokenizer));
853 fprintf (stderr, "Failed to allocate buffer for tokenizer\n");
856 ret->hdr = malloc (MIN_BUFFER_SIZE);
857 if (NULL == ret->hdr)
859 fprintf (stderr, "Failed to allocate buffer for alignment\n");
862 ret->curr_buf = MIN_BUFFER_SIZE;
864 ret->cb_cls = cb_cls;
870 * Add incoming data to the receive buffer and call the
871 * callback for all complete messages.
873 * @param mst tokenizer to use
874 * @param buf input data to add
875 * @param size number of bytes in buf
876 * @return GNUNET_OK if we are done processing (need more data)
877 * GNUNET_SYSERR if the data stream is corrupt
880 mst_receive (struct MessageStreamTokenizer *mst,
881 const char *buf, size_t size)
883 const struct GNUNET_MessageHeader *hdr;
888 unsigned long offset;
892 ibuf = (char *) mst->hdr;
896 if ((mst->curr_buf - mst->off < sizeof(struct GNUNET_MessageHeader)) ||
897 (0 != (mst->off % ALIGN_FACTOR)))
899 /* need to align or need more space */
900 mst->pos -= mst->off;
901 memmove (ibuf, &ibuf[mst->off], mst->pos);
904 if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader))
907 GNUNET_MIN (sizeof(struct GNUNET_MessageHeader)
908 - (mst->pos - mst->off), size);
909 GNUNET_memcpy (&ibuf[mst->pos], buf, delta);
914 if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader))
918 hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
919 want = ntohs (hdr->size);
920 if (want < sizeof(struct GNUNET_MessageHeader))
923 "Received invalid message from stdin\n");
926 if (mst->curr_buf - mst->off < want)
928 /* need more space */
929 mst->pos -= mst->off;
930 memmove (ibuf, &ibuf[mst->off], mst->pos);
933 if (want > mst->curr_buf)
935 mst->hdr = realloc (mst->hdr, want);
936 if (NULL == mst->hdr)
938 fprintf (stderr, "Failed to allocate buffer for alignment\n");
941 ibuf = (char *) mst->hdr;
942 mst->curr_buf = want;
944 hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
945 if (mst->pos - mst->off < want)
947 delta = GNUNET_MIN (want - (mst->pos - mst->off), size);
948 GNUNET_memcpy (&ibuf[mst->pos], buf, delta);
953 if (mst->pos - mst->off < want)
957 mst->cb (mst->cb_cls, hdr);
959 if (mst->off == mst->pos)
961 /* reset to beginning of buffer, it's free right now! */
968 if (size < sizeof(struct GNUNET_MessageHeader))
970 offset = (unsigned long) buf;
971 need_align = (0 != offset % ALIGN_FACTOR) ? GNUNET_YES : GNUNET_NO;
972 if (GNUNET_NO == need_align)
974 /* can try to do zero-copy and process directly from original buffer */
975 hdr = (const struct GNUNET_MessageHeader *) buf;
976 want = ntohs (hdr->size);
977 if (want < sizeof(struct GNUNET_MessageHeader))
980 "Received invalid message from stdin\n");
984 break; /* or not, buffer incomplete, so copy to private buffer... */
985 mst->cb (mst->cb_cls, hdr);
991 /* need to copy to private buffer to align;
992 * yes, we go a bit more spagetti than usual here */
998 if (size + mst->pos > mst->curr_buf)
1000 mst->hdr = realloc (mst->hdr, size + mst->pos);
1001 if (NULL == mst->hdr)
1003 fprintf (stderr, "Failed to allocate buffer for alignment\n");
1006 ibuf = (char *) mst->hdr;
1007 mst->curr_buf = size + mst->pos;
1009 if (mst->pos + size > mst->curr_buf)
1012 "Assertion failed\n");
1015 GNUNET_memcpy (&ibuf[mst->pos], buf, size);
1023 * Destroys a tokenizer.
1025 * @param mst tokenizer to destroy
1028 mst_destroy (struct MessageStreamTokenizer *mst)
1034 /* ***************** end of server_mst.c clone ***************** **/
1037 /* ************** code for handling of ARPHRD_IEEE80211_FULL ************** */
1040 * Radiotap header iteration
1042 * call __ieee80211_radiotap_iterator_init() to init a semi-opaque iterator
1043 * struct Ieee80211RadiotapHeaderIterator (no need to init the struct beforehand)
1044 * then loop calling __ieee80211_radiotap_iterator_next()... it returns -1
1045 * if there are no more args in the header, or the next argument type index
1046 * that is present. The iterator's this_arg member points to the start of the
1047 * argument associated with the current argument index that is present,
1048 * which can be found in the iterator's this_arg_index member. This arg
1049 * index corresponds to the IEEE80211_RADIOTAP_... defines.
1051 * @param iterator iterator to initialize
1052 * @param radiotap_header message to parse
1053 * @param max_length number of valid bytes in radiotap_header
1054 * @return 0 on success, -1 on error
1057 ieee80211_radiotap_iterator_init (struct
1058 Ieee80211RadiotapHeaderIterator *iterator,
1060 Ieee80211RadiotapHeader *radiotap_header,
1063 if ((iterator == NULL) ||
1064 (radiotap_header == NULL))
1067 /* Linux only supports version 0 radiotap format */
1068 if (0 != radiotap_header->it_version)
1071 /* sanity check for allowed length and radiotap length field */
1072 if ((max_length < sizeof(struct Ieee80211RadiotapHeader)) ||
1073 (max_length < (GNUNET_le16toh (radiotap_header->it_len))))
1076 memset (iterator, 0, sizeof(struct Ieee80211RadiotapHeaderIterator));
1077 iterator->rtheader = radiotap_header;
1078 iterator->max_length = GNUNET_le16toh (radiotap_header->it_len);
1079 iterator->bitmap_shifter = GNUNET_le32toh (radiotap_header->it_present);
1080 iterator->arg = ((uint8_t *) radiotap_header) + sizeof(struct
1081 Ieee80211RadiotapHeader);
1083 /* find payload start allowing for extended bitmap(s) */
1084 if (0 != (iterator->bitmap_shifter & IEEE80211_RADIOTAP_PRESENT_EXTEND_MASK))
1086 while (GNUNET_le32toh (*((uint32_t *) iterator->arg))
1087 & IEEE80211_RADIOTAP_PRESENT_EXTEND_MASK)
1089 iterator->arg += sizeof(uint32_t);
1091 * check for insanity where the present bitmaps
1092 * keep claiming to extend up to or even beyond the
1093 * stated radiotap header length
1095 if (iterator->arg - ((uint8_t*) iterator->rtheader) >
1096 iterator->max_length)
1099 iterator->arg += sizeof(uint32_t);
1101 * no need to check again for blowing past stated radiotap
1102 * header length, becuase ieee80211_radiotap_iterator_next
1103 * checks it before it is dereferenced
1106 /* we are all initialized happily */
1112 * Returns the next radiotap parser iterator arg.
1114 * This function returns the next radiotap arg index (IEEE80211_RADIOTAP_...)
1115 * and sets iterator->this_arg to point to the payload for the arg. It takes
1116 * care of alignment handling and extended present fields. interator->this_arg
1117 * can be changed by the caller. The args pointed to are in little-endian
1120 * @param iterator: radiotap_iterator to move to next arg (if any)
1121 * @return next present arg index on success or -1 if no more or error
1124 ieee80211_radiotap_iterator_next (struct
1125 Ieee80211RadiotapHeaderIterator *iterator)
1128 * small length lookup table for all radiotap types we heard of
1129 * starting from b0 in the bitmap, so we can walk the payload
1130 * area of the radiotap header
1132 * There is a requirement to pad args, so that args
1133 * of a given length must begin at a boundary of that length
1134 * -- but note that compound args are allowed (eg, 2 x uint16_t
1135 * for IEEE80211_RADIOTAP_CHANNEL) so total arg length is not
1136 * a reliable indicator of alignment requirement.
1138 * upper nybble: content alignment for arg
1139 * lower nybble: content length for arg
1142 static const uint8_t rt_sizes[] = {
1143 [IEEE80211_RADIOTAP_TSFT] = 0x88,
1144 [IEEE80211_RADIOTAP_FLAGS] = 0x11,
1145 [IEEE80211_RADIOTAP_RATE] = 0x11,
1146 [IEEE80211_RADIOTAP_CHANNEL] = 0x24,
1147 [IEEE80211_RADIOTAP_FHSS] = 0x22,
1148 [IEEE80211_RADIOTAP_DBM_ANTSIGNAL] = 0x11,
1149 [IEEE80211_RADIOTAP_DBM_ANTNOISE] = 0x11,
1150 [IEEE80211_RADIOTAP_LOCK_QUALITY] = 0x22,
1151 [IEEE80211_RADIOTAP_TX_ATTENUATION] = 0x22,
1152 [IEEE80211_RADIOTAP_DB_TX_ATTENUATION] = 0x22,
1153 [IEEE80211_RADIOTAP_DBM_TX_POWER] = 0x11,
1154 [IEEE80211_RADIOTAP_ANTENNA] = 0x11,
1155 [IEEE80211_RADIOTAP_DB_ANTSIGNAL] = 0x11,
1156 [IEEE80211_RADIOTAP_DB_ANTNOISE] = 0x11,
1157 [IEEE80211_RADIOTAP_TX_FLAGS] = 0x22,
1158 [IEEE80211_RADIOTAP_RX_FLAGS] = 0x22,
1159 [IEEE80211_RADIOTAP_RTS_RETRIES] = 0x11,
1160 [IEEE80211_RADIOTAP_DATA_RETRIES] = 0x11
1162 * add more here as they are defined in
1163 * include/net/ieee80211_radiotap.h
1168 * for every radiotap entry we can at
1169 * least skip (by knowing the length)...
1171 while (iterator->arg_index < sizeof(rt_sizes))
1173 int hit = (0 != (iterator->bitmap_shifter & 1));
1177 unsigned int wanted_alignment;
1178 unsigned int unalignment;
1180 * arg is present, account for alignment padding
1181 * 8-bit args can be at any alignment
1182 * 16-bit args must start on 16-bit boundary
1183 * 32-bit args must start on 32-bit boundary
1184 * 64-bit args must start on 64-bit boundary
1186 * note that total arg size can differ from alignment of
1187 * elements inside arg, so we use upper nybble of length table
1188 * to base alignment on. First, 'wanted_alignment' is set to be
1189 * 1 for 8-bit, 2 for 16-bit, 4 for 32-bit and 8 for 64-bit
1190 * arguments. Then, we calculate the 'unalignment' (how many
1191 * bytes we are over by taking the difference of 'arg' and the
1192 * overall starting point modulo the desired alignment. As
1193 * desired alignments are powers of two, we can do modulo with
1194 * binary "&" (and also avoid the possibility of a division by
1195 * zero if the 'rt_sizes' table contains bogus entries).
1197 * also note: these alignments are relative to the start of the
1198 * radiotap header. There is no guarantee that the radiotap
1199 * header itself is aligned on any kind of boundary, thus we
1200 * need to really look at the delta here.
1202 wanted_alignment = rt_sizes[iterator->arg_index] >> 4;
1203 unalignment = (((void *) iterator->arg) - ((void *) iterator->rtheader))
1204 & (wanted_alignment - 1);
1205 if (0 != unalignment)
1207 /* need padding (by 'wanted_alignment - unalignment') */
1208 iterator->arg_index += wanted_alignment - unalignment;
1212 * this is what we will return to user, but we need to
1213 * move on first so next call has something fresh to test
1215 iterator->this_arg_index = iterator->arg_index;
1216 iterator->this_arg = iterator->arg;
1218 /* internally move on the size of this arg (using lower nybble from
1220 iterator->arg += rt_sizes[iterator->arg_index] & 0x0f;
1223 * check for insanity where we are given a bitmap that
1224 * claims to have more arg content than the length of the
1225 * radiotap section. We will normally end up equalling this
1226 * max_length on the last arg, never exceeding it.
1228 if ((((void *) iterator->arg) - ((void *) iterator->rtheader)) >
1229 iterator->max_length)
1233 /* Now, move on to next bit / next entry */
1234 iterator->arg_index++;
1236 if (0 == (iterator->arg_index % 32))
1238 /* completed current uint32_t bitmap */
1239 if (0 != (iterator->bitmap_shifter & 1))
1241 /* bit 31 was set, there is more; move to next uint32_t bitmap */
1242 iterator->bitmap_shifter = GNUNET_le32toh (*iterator->next_bitmap);
1243 iterator->next_bitmap++;
1247 /* no more bitmaps: end (by setting arg_index to high, unsupported value) */
1248 iterator->arg_index = sizeof(rt_sizes);
1253 /* just try the next bit (while loop will move on) */
1254 iterator->bitmap_shifter >>= 1;
1257 /* if we found a valid arg earlier, return it now */
1259 return iterator->this_arg_index;
1262 /* we don't know how to handle any more args (or there are no more),
1263 so we're done (this is not an error) */
1269 * Calculate crc32, the start of the calculation
1271 * @param buf buffer to calc the crc
1272 * @param len len of the buffer
1275 static unsigned long
1276 calc_crc_osdep (const unsigned char *buf, size_t len)
1278 static const unsigned long int crc_tbl_osdep[256] = {
1279 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
1280 0xE963A535, 0x9E6495A3,
1281 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD,
1282 0xE7B82D07, 0x90BF1D91,
1283 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB,
1284 0xF4D4B551, 0x83D385C7,
1285 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
1286 0xFA0F3D63, 0x8D080DF5,
1287 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447,
1288 0xD20D85FD, 0xA50AB56B,
1289 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75,
1290 0xDCD60DCF, 0xABD13D59,
1291 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
1292 0xCFBA9599, 0xB8BDA50F,
1293 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11,
1294 0xC1611DAB, 0xB6662D3D,
1295 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
1296 0x9FBFE4A5, 0xE8B8D433,
1297 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
1298 0x91646C97, 0xE6635C01,
1299 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B,
1300 0x8208F4C1, 0xF50FC457,
1301 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49,
1302 0x8CD37CF3, 0xFBD44C65,
1303 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
1304 0xA4D1C46D, 0xD3D6F4FB,
1305 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5,
1306 0xAA0A4C5F, 0xDD0D7CC9,
1307 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3,
1308 0xB966D409, 0xCE61E49F,
1309 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
1310 0xB7BD5C3B, 0xC0BA6CAD,
1311 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF,
1312 0x04DB2615, 0x73DC1683,
1313 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D,
1314 0x0A00AE27, 0x7D079EB1,
1315 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
1316 0x196C3671, 0x6E6B06E7,
1317 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9,
1318 0x17B7BE43, 0x60B08ED5,
1319 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767,
1320 0x3FB506DD, 0x48B2364B,
1321 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
1322 0x316E8EEF, 0x4669BE79,
1323 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703,
1324 0x220216B9, 0x5505262F,
1325 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31,
1326 0x2CD99E8B, 0x5BDEAE1D,
1327 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
1328 0x72076785, 0x05005713,
1329 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D,
1330 0x7CDCEFB7, 0x0BDBDF21,
1331 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B,
1332 0x6FB077E1, 0x18B74777,
1333 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
1334 0x616BFFD3, 0x166CCF45,
1335 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7,
1336 0x4969474D, 0x3E6E77DB,
1337 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5,
1338 0x47B2CF7F, 0x30B5FFE9,
1339 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
1340 0x54DE5729, 0x23D967BF,
1341 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1,
1342 0x5A05DF1B, 0x2D02EF8D
1345 unsigned long crc = 0xFFFFFFFF;
1347 for (; len > 0; len--, buf++)
1348 crc = crc_tbl_osdep[(crc ^ *buf) & 0xFF] ^ (crc >> 8);
1354 * Calculate and check crc of the wlan packet
1356 * @param buf buffer of the packet, with len + 4 bytes of data,
1357 * the last 4 bytes being the checksum
1358 * @param len length of the payload in data
1359 * @return 0 on success (checksum matches), 1 on error
1362 check_crc_buf_osdep (const unsigned char *buf, size_t len)
1366 crc = calc_crc_osdep (buf, len);
1368 if ((((crc) & 0xFF) == buf[0])&&(((crc >> 8) & 0xFF) == buf[1])&&
1369 ( ((crc >> 16) & 0xFF) == buf[2]) &&( ((crc >> 24) & 0xFF) == buf[3]) )
1375 /* ************end of code for handling of ARPHRD_IEEE80211_FULL ************** */
1378 /* ************beginning of code for reading packets from kernel ************** */
1381 * Return the channel from the frequency (in Mhz)
1383 * @param frequency of the channel
1384 * @return number of the channel
1387 get_channel_from_frequency (int32_t frequency)
1389 if ((frequency >= 2412)&&(frequency <= 2472))
1390 return (frequency - 2407) / 5;
1391 if (frequency == 2484)
1393 if ((frequency >= 5000)&&(frequency <= 6100))
1394 return (frequency - 5000) / 5;
1400 * Get the channel used by our WLAN interface.
1402 * @param dev pointer to the dev struct of the card
1403 * @return channel number, -1 on error
1406 linux_get_channel (const struct HardwareInfos *dev)
1411 memset (&wrq, 0, sizeof(struct iwreq));
1412 strncpy (wrq.ifr_name, dev->iface, IFNAMSIZ);
1413 if (0 > ioctl (dev->fd_raw, SIOCGIWFREQ, &wrq))
1415 frequency = wrq.u.freq.m; /* 'iw_freq' defines 'm' as '__s32', so we keep it signed */
1416 if (100000000 < frequency)
1417 frequency /= 100000;
1418 else if (1000000 < frequency)
1420 if (1000 < frequency)
1421 return get_channel_from_frequency (frequency);
1427 * Read from the raw socket (the wlan card), parse the packet and
1428 * put the result into the buffer for transmission to 'stdout'.
1430 * @param dev pointer to the struct of the wlan card
1431 * @param buf buffer to read to; first bytes will be the 'struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame',
1432 * followed by the actual payload
1433 * @param buf_size size of the buffer
1434 * @param ri where to write radiotap_rx info
1435 * @return number of bytes written to 'buf'
1438 linux_read (struct HardwareInfos *dev,
1439 unsigned char *buf, size_t buf_size,
1440 struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *ri)
1442 unsigned char tmpbuf[buf_size];
1447 int got_channel = 0;
1448 int fcs_removed = 0;
1450 caplen = read (dev->fd_raw, tmpbuf, buf_size);
1453 if (EAGAIN == errno)
1455 fprintf (stderr, "Failed to read from RAW socket: %s\n", strerror (errno));
1459 memset (ri, 0, sizeof(*ri));
1460 switch (dev->arptype_in)
1462 case ARPHRD_IEEE80211_PRISM:
1464 const struct PrismHeader *ph;
1466 ph = (const struct PrismHeader*) tmpbuf;
1468 if ((n < 8) || (n >= caplen))
1469 return 0; /* invalid format */
1470 if ((PRISM_MSGCODE_MONITOR == ph->msgcode) &&
1471 (n >= sizeof(struct PrismHeader)))
1475 struct PrismValue pv;
1477 left = n - sizeof(struct PrismHeader);
1478 pos = (const char *) &ph[1];
1479 while (left > sizeof(struct PrismValue))
1481 left -= sizeof(struct PrismValue);
1482 GNUNET_memcpy (&pv, pos, sizeof(struct PrismValue));
1483 pos += sizeof(struct PrismValue);
1487 case PRISM_DID_NOISE:
1488 if (PRISM_STATUS_OK == pv.status)
1490 ri->ri_noise = pv.data;
1491 /* got_noise = 1; */
1495 case PRISM_DID_RATE:
1496 if (PRISM_STATUS_OK == pv.status)
1497 ri->ri_rate = pv.data * 500000;
1500 case PRISM_DID_CHANNEL:
1501 if (PRISM_STATUS_OK == pv.status)
1503 ri->ri_channel = pv.data;
1508 case PRISM_DID_MACTIME:
1509 if (PRISM_STATUS_OK == pv.status)
1510 ri->ri_mactime = pv.data;
1513 case PRISM_DID_SIGNAL:
1514 if (PRISM_STATUS_OK == pv.status)
1516 ri->ri_power = pv.data;
1517 /* got_signal = 1; */
1523 if ((n < 8) || (n >= caplen))
1524 return 0; /* invalid format */
1528 case ARPHRD_IEEE80211_FULL:
1530 struct Ieee80211RadiotapHeaderIterator iterator;
1531 struct Ieee80211RadiotapHeader *rthdr;
1533 memset (&iterator, 0, sizeof(iterator));
1534 rthdr = (struct Ieee80211RadiotapHeader *) tmpbuf;
1535 n = GNUNET_le16toh (rthdr->it_len);
1536 if ((n < sizeof(struct Ieee80211RadiotapHeader)) || (n >= caplen))
1537 return 0; /* invalid 'it_len' */
1538 if (0 != ieee80211_radiotap_iterator_init (&iterator, rthdr, caplen))
1540 /* go through the radiotap arguments we have been given by the driver */
1541 while (0 <= ieee80211_radiotap_iterator_next (&iterator))
1543 switch (iterator.this_arg_index)
1545 case IEEE80211_RADIOTAP_TSFT:
1546 ri->ri_mactime = GNUNET_le64toh (*((uint64_t *) iterator.this_arg));
1549 case IEEE80211_RADIOTAP_DBM_ANTSIGNAL:
1552 ri->ri_power = *((int8_t*) iterator.this_arg);
1557 case IEEE80211_RADIOTAP_DB_ANTSIGNAL:
1560 ri->ri_power = *((int8_t*) iterator.this_arg);
1565 case IEEE80211_RADIOTAP_DBM_ANTNOISE:
1568 ri->ri_noise = *((int8_t*) iterator.this_arg);
1573 case IEEE80211_RADIOTAP_DB_ANTNOISE:
1576 ri->ri_noise = *((int8_t*) iterator.this_arg);
1581 case IEEE80211_RADIOTAP_ANTENNA:
1582 ri->ri_antenna = *iterator.this_arg;
1585 case IEEE80211_RADIOTAP_CHANNEL:
1586 ri->ri_channel = *iterator.this_arg;
1590 case IEEE80211_RADIOTAP_RATE:
1591 ri->ri_rate = (*iterator.this_arg) * 500000;
1594 case IEEE80211_RADIOTAP_FLAGS:
1596 uint8_t flags = *iterator.this_arg;
1597 /* is the CRC visible at the end? if so, remove */
1598 if (0 != (flags & IEEE80211_RADIOTAP_F_FCS))
1601 caplen -= sizeof(uint32_t);
1606 case IEEE80211_RADIOTAP_RX_FLAGS:
1608 uint16_t flags = ntohs (*((uint16_t *) iterator.this_arg));
1609 if (0 != (flags & IEEE80211_RADIOTAP_F_RX_BADFCS))
1613 } /* end of 'switch' */
1614 } /* end of the 'while' loop */
1618 case ARPHRD_IEEE80211:
1619 n = 0; /* no header */
1624 if (sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee8023Frame) > caplen)
1625 return 0; /* invalid */
1626 GNUNET_memcpy (&buf[sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame)],
1627 tmpbuf + sizeof(struct
1628 GNUNET_TRANSPORT_WLAN_Ieee8023Frame),
1629 caplen - sizeof(struct
1630 GNUNET_TRANSPORT_WLAN_Ieee8023Frame)
1631 - 4 /* 4 byte FCS */);
1632 return caplen - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee8023Frame) - 4;
1636 errno = ENOTSUP; /* unsupported format */
1641 ri->ri_channel = linux_get_channel (dev);
1643 /* detect CRC32 at the end, even if the flag wasn't set and remove it */
1644 if ((0 == fcs_removed) &&
1645 (0 == check_crc_buf_osdep (tmpbuf + n, caplen - sizeof(uint32_t))))
1647 /* NOTE: this heuristic can of course fail if there happens to
1648 be a matching checksum at the end. Would be good to have
1649 some data to see how often this heuristic actually works. */
1650 caplen -= sizeof(uint32_t);
1652 /* copy payload to target buffer */
1653 GNUNET_memcpy (buf, tmpbuf + n, caplen);
1658 /* ************end of code for reading packets from kernel ************** */
1660 /* ************other helper functions for main start here ************** */
1664 * Open the wireless network interface for reading/writing.
1666 * @param dev pointer to the device struct
1667 * @return 0 on success
1670 open_device_raw (struct HardwareInfos *dev)
1674 struct packet_mreq mr;
1675 struct sockaddr_ll sll;
1677 /* find the interface index */
1678 memset (&ifr, 0, sizeof(ifr));
1679 strncpy (ifr.ifr_name, dev->iface, IFNAMSIZ);
1680 if (-1 == ioctl (dev->fd_raw, SIOCGIFINDEX, &ifr))
1682 fprintf (stderr, "ioctl(SIOCGIFINDEX) on interface `%.*s' failed: %s\n",
1683 IFNAMSIZ, dev->iface, strerror (errno));
1687 /* lookup the hardware type */
1688 memset (&sll, 0, sizeof(sll));
1689 sll.sll_family = AF_PACKET;
1690 sll.sll_ifindex = ifr.ifr_ifindex;
1691 sll.sll_protocol = htons (ETH_P_ALL);
1692 if (-1 == ioctl (dev->fd_raw, SIOCGIFHWADDR, &ifr))
1694 fprintf (stderr, "ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n",
1695 IFNAMSIZ, dev->iface, strerror (errno));
1698 if (((ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211) &&
1699 (ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER) &&
1700 (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_PRISM) &&
1701 (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_FULL)))
1704 "Error: interface `%.*s' is not using a supported hardware address family (got %d)\n",
1705 IFNAMSIZ, dev->iface,
1706 ifr.ifr_hwaddr.sa_family);
1710 /* lookup iw mode */
1711 memset (&wrq, 0, sizeof(struct iwreq));
1712 strncpy (wrq.ifr_name, dev->iface, IFNAMSIZ);
1713 if (-1 == ioctl (dev->fd_raw, SIOCGIWMODE, &wrq))
1715 /* most probably not supported (ie for rtap ipw interface) *
1716 * so just assume its correctly set... */
1717 wrq.u.mode = IW_MODE_MONITOR;
1720 if ((wrq.u.mode != IW_MODE_MONITOR) &&
1721 (wrq.u.mode != IW_MODE_ADHOC))
1724 "Error: interface `%.*s' is not in monitor or ad-hoc mode (got %d)\n",
1725 IFNAMSIZ, dev->iface,
1730 /* Is interface st to up, broadcast & running ? */
1731 if ((ifr.ifr_flags | IFF_UP | IFF_BROADCAST | IFF_RUNNING) != ifr.ifr_flags)
1733 /* Bring interface up */
1734 ifr.ifr_flags |= IFF_UP | IFF_BROADCAST | IFF_RUNNING;
1736 if (-1 == ioctl (dev->fd_raw, SIOCSIFFLAGS, &ifr))
1738 fprintf (stderr, "ioctl(SIOCSIFFLAGS) on interface `%.*s' failed: %s\n",
1739 IFNAMSIZ, dev->iface, strerror (errno));
1744 /* bind the raw socket to the interface */
1745 if (-1 == bind (dev->fd_raw, (struct sockaddr *) &sll, sizeof(sll)))
1747 fprintf (stderr, "Failed to bind interface `%.*s': %s\n", IFNAMSIZ,
1748 dev->iface, strerror (errno));
1752 /* lookup the hardware type */
1753 if (-1 == ioctl (dev->fd_raw, SIOCGIFHWADDR, &ifr))
1755 fprintf (stderr, "ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n",
1756 IFNAMSIZ, dev->iface, strerror (errno));
1760 GNUNET_memcpy (&dev->pl_mac, ifr.ifr_hwaddr.sa_data, MAC_ADDR_SIZE);
1761 dev->arptype_in = ifr.ifr_hwaddr.sa_family;
1762 if ((ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER) &&
1763 (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211) &&
1764 (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_PRISM) &&
1765 (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_FULL))
1767 fprintf (stderr, "Unsupported hardware link type %d on interface `%.*s'\n",
1768 ifr.ifr_hwaddr.sa_family, IFNAMSIZ, dev->iface);
1772 /* enable promiscuous mode */
1773 memset (&mr, 0, sizeof(mr));
1774 mr.mr_ifindex = sll.sll_ifindex;
1775 mr.mr_type = PACKET_MR_PROMISC;
1777 setsockopt (dev->fd_raw, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mr,
1781 "Failed to enable promiscuous mode on interface `%.*s'\n",
1791 * Test if the given interface name really corresponds to a wireless
1794 * @param iface name of the interface
1795 * @return 0 on success, 1 on error
1798 test_wlan_interface (const char *iface)
1804 ret = snprintf (strbuf, sizeof(strbuf),
1805 "/sys/class/net/%s/phy80211/subsystem",
1807 if ((ret < 0) || (ret >= sizeof(strbuf)) || (0 != stat (strbuf, &sbuf)))
1810 "Did not find 802.11 interface `%s'. Exiting.\n",
1819 * Test incoming packets mac for being our own.
1821 * @param taIeeeHeader buffer of the packet
1822 * @param dev the Hardware_Infos struct
1823 * @return 0 if mac belongs to us, 1 if mac is for another target
1826 mac_test (const struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader,
1827 const struct HardwareInfos *dev)
1829 static struct GNUNET_TRANSPORT_WLAN_MacAddress all_zeros;
1831 if ((0 == memcmp (&taIeeeHeader->addr3, &all_zeros, MAC_ADDR_SIZE)) ||
1832 (0 == memcmp (&taIeeeHeader->addr1, &all_zeros, MAC_ADDR_SIZE)))
1833 return 0; /* some drivers set no Macs, then assume it is all for us! */
1835 if (0 != memcmp (&taIeeeHeader->addr3, &mac_bssid_gnunet, MAC_ADDR_SIZE))
1836 return 1; /* not a GNUnet ad-hoc package */
1837 if ((0 == memcmp (&taIeeeHeader->addr1, &dev->pl_mac, MAC_ADDR_SIZE)) ||
1838 (0 == memcmp (&taIeeeHeader->addr1, &bc_all_mac, MAC_ADDR_SIZE)))
1839 return 0; /* for us, or broadcast */
1840 return 1; /* not for us */
1845 * Set the wlan header to sane values to make attacks more difficult
1847 * @param taIeeeHeader pointer to the header of the packet
1848 * @param dev pointer to the Hardware_Infos struct
1851 mac_set (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader,
1852 const struct HardwareInfos *dev)
1854 taIeeeHeader->frame_control = htons (IEEE80211_FC0_TYPE_DATA);
1855 taIeeeHeader->addr2 = dev->pl_mac;
1856 taIeeeHeader->addr3 = mac_bssid_gnunet;
1861 * Process data from the stdin. Takes the message, prepends the
1862 * radiotap transmission header, forces the sender MAC to be correct
1863 * and puts it into our buffer for transmission to the kernel.
1865 * @param cls pointer to the device struct ('struct HardwareInfos*')
1866 * @param hdr pointer to the start of the packet
1869 stdin_send_hw (void *cls, const struct GNUNET_MessageHeader *hdr)
1871 struct HardwareInfos *dev = cls;
1872 const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header;
1873 struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *wlanheader;
1875 struct RadiotapTransmissionHeader rtheader;
1876 struct GNUNET_TRANSPORT_WLAN_Ieee8023Frame etheader;
1878 sendsize = ntohs (hdr->size);
1880 sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage)) ||
1881 (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER != ntohs (hdr->type)))
1883 fprintf (stderr, "Received malformed message\n");
1886 sendsize -= (sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage)
1887 - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame));
1888 if (MAXLINE < sendsize)
1890 fprintf (stderr, "Packet too big for buffer\n");
1893 header = (const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) hdr;
1894 switch (dev->arptype_in)
1896 case ARPHRD_IEEE80211_PRISM:
1897 case ARPHRD_IEEE80211_FULL:
1898 case ARPHRD_IEEE80211:
1899 rtheader.header.it_version = 0;
1900 rtheader.header.it_pad = 0;
1901 rtheader.header.it_len = GNUNET_htole16 (sizeof(rtheader));
1902 rtheader.header.it_present = GNUNET_htole16 (
1903 IEEE80211_RADIOTAP_OUR_TRANSMISSION_HEADER_MASK);
1904 rtheader.rate = header->rate;
1906 rtheader.txflags = GNUNET_htole16 (IEEE80211_RADIOTAP_F_TX_NOACK
1907 | IEEE80211_RADIOTAP_F_TX_NOSEQ);
1908 GNUNET_memcpy (write_pout.buf, &rtheader, sizeof(rtheader));
1909 GNUNET_memcpy (&write_pout.buf[sizeof(rtheader)], &header->frame, sendsize);
1910 wlanheader = (struct
1911 GNUNET_TRANSPORT_WLAN_Ieee80211Frame *) &write_pout.buf[sizeof(
1915 /* payload contains MAC address, but we don't trust it, so we'll
1916 * overwrite it with OUR MAC address to prevent mischief */
1917 mac_set (wlanheader, dev);
1918 write_pout.size = sendsize + sizeof(rtheader);
1922 etheader.dst = header->frame.addr1;
1923 /* etheader.src = header->frame.addr2; --- untrusted input */
1924 etheader.src = dev->pl_mac;
1925 etheader.type = htons (ETH_P_IP);
1926 GNUNET_memcpy (write_pout.buf, ðeader, sizeof(etheader));
1927 GNUNET_memcpy (&write_pout.buf[sizeof(etheader)], &header[1], sendsize
1928 - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame));
1929 write_pout.size = sendsize - sizeof(struct
1930 GNUNET_TRANSPORT_WLAN_Ieee80211Frame)
1936 "Unsupported ARPTYPE!\n");
1943 * Main function of the helper. This code accesses a WLAN interface
1944 * in monitoring mode (layer 2) and then forwards traffic in both
1945 * directions between the WLAN interface and stdin/stdout of this
1946 * process. Error messages are written to stdout.
1948 * @param argc number of arguments, must be 2
1949 * @param argv arguments only argument is the name of the interface (i.e. 'mon0')
1950 * @return 0 on success (never happens, as we don't return unless aborted), 1 on error
1953 main (int argc, char *argv[])
1955 struct HardwareInfos dev;
1956 char readbuf[MAXLINE];
1961 struct MessageStreamTokenizer *stdin_mst;
1964 /* assert privs so we can modify the firewall rules! */
1966 #ifdef HAVE_SETRESUID
1967 uid_t uid = getuid ();
1969 if (0 != setresuid (uid, 0, 0))
1972 "Failed to setresuid to root: %s\n",
1977 if (0 != seteuid (0))
1980 "Failed to seteuid back to root: %s\n", strerror (errno));
1986 /* make use of SGID capabilities on POSIX */
1987 memset (&dev, 0, sizeof(dev));
1988 dev.fd_raw = socket (PF_PACKET, SOCK_RAW, htons (ETH_P_ALL));
1989 raw_eno = errno; /* remember for later */
1991 /* now that we've dropped root rights, we can do error checking */
1995 "You must specify the name of the interface as the first and only argument to this program.\n");
1996 if (-1 != dev.fd_raw)
1997 (void) close (dev.fd_raw);
2001 if (-1 == dev.fd_raw)
2003 fprintf (stderr, "Failed to create raw socket: %s\n", strerror (raw_eno));
2006 if (dev.fd_raw >= FD_SETSIZE)
2008 fprintf (stderr, "File descriptor too large for select (%d > %d)\n",
2009 dev.fd_raw, FD_SETSIZE);
2010 (void) close (dev.fd_raw);
2013 if (0 != test_wlan_interface (argv[1]))
2015 (void) close (dev.fd_raw);
2018 strncpy (dev.iface, argv[1], IFNAMSIZ);
2019 if (0 != open_device_raw (&dev))
2021 (void) close (dev.fd_raw);
2027 uid_t uid = getuid ();
2028 #ifdef HAVE_SETRESUID
2029 if (0 != setresuid (uid, uid, uid))
2031 fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno));
2032 if (-1 != dev.fd_raw)
2033 (void) close (dev.fd_raw);
2037 if (0 != (setuid (uid) | seteuid (uid)))
2039 fprintf (stderr, "Failed to setuid: %s\n", strerror (errno));
2040 if (-1 != dev.fd_raw)
2041 (void) close (dev.fd_raw);
2048 /* send MAC address of the WLAN interface to STDOUT first */
2050 struct GNUNET_TRANSPORT_WLAN_HelperControlMessage macmsg;
2052 macmsg.hdr.size = htons (sizeof(macmsg));
2053 macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL);
2054 GNUNET_memcpy (&macmsg.mac, &dev.pl_mac, sizeof(struct
2055 GNUNET_TRANSPORT_WLAN_MacAddress));
2056 GNUNET_memcpy (write_std.buf, &macmsg, sizeof(macmsg));
2057 write_std.size = sizeof(macmsg);
2060 stdin_mst = mst_create (&stdin_send_hw, &dev);
2066 if ((0 == write_pout.size) && (1 == stdin_open))
2068 FD_SET (STDIN_FILENO, &rfds);
2069 maxfd = MAX (maxfd, STDIN_FILENO);
2071 if (0 == write_std.size)
2073 FD_SET (dev.fd_raw, &rfds);
2074 maxfd = MAX (maxfd, dev.fd_raw);
2077 if (0 < write_std.size)
2079 FD_SET (STDOUT_FILENO, &wfds);
2080 maxfd = MAX (maxfd, STDOUT_FILENO);
2082 if (0 < write_pout.size)
2084 FD_SET (dev.fd_raw, &wfds);
2085 maxfd = MAX (maxfd, dev.fd_raw);
2088 int retval = select (maxfd + 1, &rfds, &wfds, NULL, NULL);
2089 if ((-1 == retval) && (EINTR == errno))
2093 fprintf (stderr, "select failed: %s\n", strerror (errno));
2097 if (FD_ISSET (STDOUT_FILENO, &wfds))
2100 write (STDOUT_FILENO, write_std.buf + write_std.pos,
2101 write_std.size - write_std.pos);
2104 fprintf (stderr, "Failed to write to STDOUT: %s\n", strerror (errno));
2107 write_std.pos += ret;
2108 if (write_std.pos == write_std.size)
2114 if (FD_ISSET (dev.fd_raw, &wfds))
2117 write (dev.fd_raw, write_pout.buf + write_pout.pos,
2118 write_pout.size - write_pout.pos);
2121 fprintf (stderr, "Failed to write to WLAN device: %s\n",
2125 write_pout.pos += ret;
2126 if ((write_pout.pos != write_pout.size) && (0 != ret))
2128 /* we should not get partial sends with packet-oriented devices... */
2129 fprintf (stderr, "Write error, partial send: %u/%u\n",
2130 (unsigned int) write_pout.pos,
2131 (unsigned int) write_pout.size);
2134 if (write_pout.pos == write_pout.size)
2137 write_pout.size = 0;
2141 if (FD_ISSET (STDIN_FILENO, &rfds))
2144 read (STDIN_FILENO, readbuf, sizeof(readbuf));
2147 fprintf (stderr, "Read error from STDIN: %s\n", strerror (errno));
2152 /* stop reading... */
2155 mst_receive (stdin_mst, readbuf, ret);
2158 if (FD_ISSET (dev.fd_raw, &rfds))
2160 struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm;
2164 GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) write_std.buf;
2166 linux_read (&dev, (unsigned char *) &rrm->frame,
2167 sizeof(write_std.buf)
2169 GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
2170 + sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame),
2174 fprintf (stderr, "Read error from raw socket: %s\n", strerror (errno));
2177 if ((0 < ret) && (0 == mac_test (&rrm->frame, &dev)))
2179 write_std.size = ret
2181 GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
2182 - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame);
2183 rrm->header.size = htons (write_std.size);
2184 rrm->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER);
2188 /* Error handling, try to clean up a bit at least */
2189 mst_destroy (stdin_mst);
2190 (void) close (dev.fd_raw);
2191 return 1; /* we never exit 'normally' */
2194 /* end of gnunet-helper-transport-wlan.c */