2 This file is part of GNUnet.
3 (C) 2010, 2011, 2012 Christian Grothoff (and other contributing authors)
4 Copyright (c) 2007, 2008, Andy Green <andy@warmcat.com>
5 Copyright (C) 2009 Thomas d'Otreppe
7 GNUnet is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published
9 by the Free Software Foundation; either version 3, or (at your
10 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 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNUnet; see the file COPYING. If not, write to the
19 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
22 #include "gnunet_config.h"
23 #include "plugin_transport_wlan.h"
24 #include "gnunet_protocols.h"
28 #include "gnunet_util_lib.h"
31 #include "gnunet_protocols.h"
33 #include <bluetooth/bluetooth.h>
34 #include <bluetooth/hci.h>
35 #include <bluetooth/hci_lib.h>
36 #include <bluetooth/rfcomm.h>
37 #include <bluetooth/sdp.h>
38 #include <bluetooth/sdp_lib.h>
43 #include <sys/ioctl.h>
44 #include <sys/param.h>
45 #include <sys/socket.h>
47 #include <sys/types.h>
54 * Maximum number of ports assignable for RFCOMMM protocol.
59 * Maximum size of a message allowed in either direction
60 * (used for our receive and sent buffers).
66 * Maximum number of loops without inquiring for new devices.
71 /* Maximum size of the interface's name */
78 * A copy of the MAC Address.
80 struct GNUNET_TRANSPORT_WLAN_MacAddress_Copy
82 UINT8 mac[MAC_ADDR_SIZE];
85 // {31191E56-FA7E-4517-870E-71B86BBCC52F}
86 #define GNUNET_BLUETOOTH_SDP_UUID \
88 0x31, 0x19, 0x1E, 0x56, \
92 0x71, 0xB8, 0x6B, 0xBC, 0xC5, 0x2F \
97 * struct for storing the information of the hardware. There is only
103 * Name of the interface, not necessarily 0-terminated (!).
105 char iface[IFNAMSIZ];
111 struct GNUNET_NETWORK_Handle *handle;
114 * MAC address of our own bluetooth interface.
116 struct GNUNET_TRANSPORT_WLAN_MacAddress_Copy pl_mac;
119 * file descriptor for the rfcomm socket
124 * MAC address of our own bluetooth interface.
126 struct GNUNET_TRANSPORT_WLAN_MacAddress pl_mac;
131 sdp_session_t *session ;
136 * IO buffer used for buffering data in transit (to wireless or to stdout).
141 * How many bytes of data are stored in 'buf' for transmission right now?
142 * Data always starts at offset 0 and extends to 'size'.
147 * How many bytes that were stored in 'buf' did we already write to the
148 * destination? Always smaller than 'size'.
153 * Buffered data; twice the maximum allowed message size as we add some
156 char buf[MAXLINE * 2];
161 * Devices buffer used to keep a list with all the discoverable devices in
162 * order to send them HELLO messages one by one when it receive a broadcast message.
164 struct BroadcastMessages
166 /* List with the discoverable devices' addresses */
167 bdaddr_t devices[MAX_PORTS];
169 /* List with the open sockets */
173 /* The number of the devices */
176 /* The current position */
184 * Address used to identify the broadcast messages.
186 static struct GNUNET_TRANSPORT_WLAN_MacAddress broadcast_address = {{255, 255, 255, 255, 255, 255}};
189 * Buffer with the discoverable devices.
191 static struct BroadcastMessages neighbours;
193 static int searching_devices_count = 0;
197 * Buffer for data read from stdin to be transmitted to the bluetooth device
199 static struct SendBuffer write_pout;
202 * Buffer for data read from the bluetooth device to be transmitted to stdout.
204 static struct SendBuffer write_std;
207 /* ****** this are the same functions as the ones used in gnunet-helper-transport-wlan.c ****** */
210 * To what multiple do we align messages? 8 byte should suffice for everyone
213 #define ALIGN_FACTOR 8
216 * Smallest supported message.
218 #define MIN_BUFFER_SIZE sizeof (struct GNUNET_MessageHeader)
222 * Functions with this signature are called whenever a
223 * complete message is received by the tokenizer.
226 * @param message the actual message
228 typedef void (*MessageTokenizerCallback) (void *cls,
230 GNUNET_MessageHeader *
234 * Handle to a message stream tokenizer.
236 struct MessageStreamTokenizer
240 * Function to call on completed messages.
242 MessageTokenizerCallback cb;
250 * Size of the buffer (starting at 'hdr').
255 * How many bytes in buffer have we already processed?
260 * How many bytes in buffer are valid right now?
265 * Beginning of the buffer. Typed like this to force alignment.
267 struct GNUNET_MessageHeader *hdr;
273 * Create a message stream tokenizer.
275 * @param cb function to call on completed messages
276 * @param cb_cls closure for cb
277 * @return handle to tokenizer
279 static struct MessageStreamTokenizer *
280 mst_create (MessageTokenizerCallback cb,
283 struct MessageStreamTokenizer *ret;
285 ret = malloc (sizeof (struct MessageStreamTokenizer));
288 fprintf (stderr, "Failed to allocate buffer for tokenizer\n");
291 ret->hdr = malloc (MIN_BUFFER_SIZE);
292 if (NULL == ret->hdr)
294 fprintf (stderr, "Failed to allocate buffer for alignment\n");
297 ret->curr_buf = MIN_BUFFER_SIZE;
299 ret->cb_cls = cb_cls;
307 * Add incoming data to the receive buffer and call the
308 * callback for all complete messages.
310 * @param mst tokenizer to use
311 * @param buf input data to add
312 * @param size number of bytes in buf
313 * @return GNUNET_OK if we are done processing (need more data)
314 * GNUNET_SYSERR if the data stream is corrupt
317 mst_receive (struct MessageStreamTokenizer *mst,
318 const char *buf, size_t size)
320 const struct GNUNET_MessageHeader *hdr;
325 unsigned long offset;
329 ibuf = (char *) mst->hdr;
333 if (mst->pos < mst->off)
335 //fprintf (stderr, "We processed too many bytes!\n");
336 return GNUNET_SYSERR;
338 if ((mst->curr_buf - mst->off < sizeof (struct GNUNET_MessageHeader)) ||
339 (0 != (mst->off % ALIGN_FACTOR)))
341 /* need to align or need more space */
342 mst->pos -= mst->off;
343 memmove (ibuf, &ibuf[mst->off], mst->pos);
346 if (mst->pos - mst->off < sizeof (struct GNUNET_MessageHeader))
349 GNUNET_MIN (sizeof (struct GNUNET_MessageHeader) -
350 (mst->pos - mst->off), size);
351 memcpy (&ibuf[mst->pos], buf, delta);
356 if (mst->pos - mst->off < sizeof (struct GNUNET_MessageHeader))
358 //FIXME should I reset ??
363 hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
364 want = ntohs (hdr->size);
365 if (want < sizeof (struct GNUNET_MessageHeader))
368 "Received invalid message from stdin\n");
369 return GNUNET_SYSERR;
371 if ((mst->curr_buf - mst->off < want) &&
374 /* need more space */
375 mst->pos -= mst->off;
376 memmove (ibuf, &ibuf[mst->off], mst->pos);
379 if (want > mst->curr_buf)
383 fprintf (stderr, "Error! We should proceeded 0 bytes\n");
384 return GNUNET_SYSERR;
386 mst->hdr = realloc (mst->hdr, want);
387 if (NULL == mst->hdr)
389 fprintf (stderr, "Failed to allocate buffer for alignment\n");
392 ibuf = (char *) mst->hdr;
393 mst->curr_buf = want;
395 hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
396 if (mst->pos - mst->off < want)
398 delta = GNUNET_MIN (want - (mst->pos - mst->off), size);
399 if (mst->pos + delta > mst->curr_buf)
401 fprintf (stderr, "The size of the buffer will be exceeded!\n");
402 return GNUNET_SYSERR;
404 memcpy (&ibuf[mst->pos], buf, delta);
409 if (mst->pos - mst->off < want)
411 //FIXME should I use this?
416 mst->cb (mst->cb_cls, hdr);
418 if (mst->off == mst->pos)
420 /* reset to beginning of buffer, it's free right now! */
427 fprintf (stderr, "There should some valid bytes in the buffer on this stage\n");
428 return GNUNET_SYSERR;
432 if (size < sizeof (struct GNUNET_MessageHeader))
434 offset = (unsigned long) buf;
435 need_align = (0 != offset % ALIGN_FACTOR) ? GNUNET_YES : GNUNET_NO;
436 if (GNUNET_NO == need_align)
438 /* can try to do zero-copy and process directly from original buffer */
439 hdr = (const struct GNUNET_MessageHeader *) buf;
440 want = ntohs (hdr->size);
441 if (want < sizeof (struct GNUNET_MessageHeader))
444 "Received invalid message from stdin\n");
447 return GNUNET_SYSERR;
450 break; /* or not, buffer incomplete, so copy to private buffer... */
451 mst->cb (mst->cb_cls, hdr);
457 /* need to copy to private buffer to align;
458 * yes, we go a bit more spagetti than usual here */
464 if (size + mst->pos > mst->curr_buf)
466 mst->hdr = realloc (mst->hdr, size + mst->pos);
467 if (NULL == mst->hdr)
469 fprintf (stderr, "Failed to allocate buffer for alignment\n");
472 ibuf = (char *) mst->hdr;
473 mst->curr_buf = size + mst->pos;
475 if (mst->pos + size > mst->curr_buf)
478 "Assertion failed\n");
481 memcpy (&ibuf[mst->pos], buf, size);
488 * Destroys a tokenizer.
490 * @param mst tokenizer to destroy
493 mst_destroy (struct MessageStreamTokenizer *mst)
500 * Calculate crc32, the start of the calculation
502 * @param buf buffer to calc the crc
503 * @param len len of the buffer
507 calc_crc_osdep (const unsigned char *buf, size_t len)
509 static const unsigned long int crc_tbl_osdep[256] = {
510 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
511 0xE963A535, 0x9E6495A3,
512 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD,
513 0xE7B82D07, 0x90BF1D91,
514 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB,
515 0xF4D4B551, 0x83D385C7,
516 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
517 0xFA0F3D63, 0x8D080DF5,
518 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447,
519 0xD20D85FD, 0xA50AB56B,
520 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75,
521 0xDCD60DCF, 0xABD13D59,
522 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
523 0xCFBA9599, 0xB8BDA50F,
524 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11,
525 0xC1611DAB, 0xB6662D3D,
526 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
527 0x9FBFE4A5, 0xE8B8D433,
528 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
529 0x91646C97, 0xE6635C01,
530 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B,
531 0x8208F4C1, 0xF50FC457,
532 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49,
533 0x8CD37CF3, 0xFBD44C65,
534 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
535 0xA4D1C46D, 0xD3D6F4FB,
536 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5,
537 0xAA0A4C5F, 0xDD0D7CC9,
538 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3,
539 0xB966D409, 0xCE61E49F,
540 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
541 0xB7BD5C3B, 0xC0BA6CAD,
542 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF,
543 0x04DB2615, 0x73DC1683,
544 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D,
545 0x0A00AE27, 0x7D079EB1,
546 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
547 0x196C3671, 0x6E6B06E7,
548 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9,
549 0x17B7BE43, 0x60B08ED5,
550 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767,
551 0x3FB506DD, 0x48B2364B,
552 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
553 0x316E8EEF, 0x4669BE79,
554 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703,
555 0x220216B9, 0x5505262F,
556 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31,
557 0x2CD99E8B, 0x5BDEAE1D,
558 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
559 0x72076785, 0x05005713,
560 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D,
561 0x7CDCEFB7, 0x0BDBDF21,
562 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B,
563 0x6FB077E1, 0x18B74777,
564 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
565 0x616BFFD3, 0x166CCF45,
566 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7,
567 0x4969474D, 0x3E6E77DB,
568 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5,
569 0x47B2CF7F, 0x30B5FFE9,
570 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
571 0x54DE5729, 0x23D967BF,
572 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1,
573 0x5A05DF1B, 0x2D02EF8D
576 unsigned long crc = 0xFFFFFFFF;
578 for (; len > 0; len--, buf++)
579 crc = crc_tbl_osdep[(crc ^ *buf) & 0xFF] ^ (crc >> 8);
585 * Calculate and check crc of the bluetooth packet
587 * @param buf buffer of the packet, with len + 4 bytes of data,
588 * the last 4 bytes being the checksum
589 * @param len length of the payload in data
590 * @return 0 on success (checksum matches), 1 on error
593 check_crc_buf_osdep (const unsigned char *buf, size_t len)
597 crc = calc_crc_osdep (buf, len);
599 if (((crc) & 0xFF) == buf[0] && ((crc >> 8) & 0xFF) == buf[1] &&
600 ((crc >> 16) & 0xFF) == buf[2] && ((crc >> 24) & 0xFF) == buf[3])
607 /* ************** end of clone ***************** */
611 * Function used to get the code of last error and to print the type of error.
616 LPVOID lpMsgBuf = NULL;
617 FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
618 NULL, GetLastError(), 0, (LPTSTR) &lpMsgBuf, 0, NULL);
619 fprintf (stderr, "%s\n", (char *)lpMsgBuf) ;
626 * Function used to initialize the Windows Sockets
629 initialize_windows_sockets()
632 WORD wVersionRequested = MAKEWORD (2, 0);
633 if (WSAStartup (wVersionRequested, &wsaData) != NO_ERROR)
635 fprintf (stderr , "Error initializing window sockets!\n");
642 * Function used to convert the GUID.
643 * @param bytes the GUID represented as a char array
644 * @param uuid pointer to the GUID
647 convert_guid(char *bytes, GUID * uuid)
650 uuid->Data1 = ((bytes[0] << 24) & 0xff000000) | ((bytes[1] << 16) & 0x00ff0000) | ((bytes[2] << 8) & 0x0000ff00) | (bytes[3] & 0x000000ff);
651 uuid->Data2 = ((bytes[4] << 8) & 0xff00) | (bytes[5] & 0x00ff);
652 uuid->Data3 = ((bytes[6] << 8) & 0xff00) | (bytes[7] & 0x00ff);
654 for (i = 0; i < 8; i++)
656 uuid->Data4[i] = bytes[i + 8];
663 * Function for assigning a port number
665 * @param socket the socket used to bind
666 * @param addr pointer to the rfcomm address
667 * @return 0 on success
670 bind_socket (int socket, struct sockaddr_rc *addr)
674 /* Bind every possible port (from 0 to 30) and stop when binding doesn't fail */
675 //FIXME : it should start from port 1, but on my computer it doesn't work :)
676 for (port = 3; port <= 30; port++)
678 addr->rc_channel = port;
679 status = bind (socket, (struct sockaddr *) addr, sizeof (struct sockaddr_rc));
690 * Function used for creating the service record and registering it.
692 * @param dev pointer to the device struct
693 * @return 0 on success
696 register_service (struct HardwareInfos *dev)
698 // advertise the service
699 CSADDR_INFO addr_info;
702 unsigned char uuid[] = GNUNET_BLUETOOTH_SDP_UUID;
704 int addr_len = sizeof (SOCKADDR_BTH);
706 /* get the port on which we are listening on */
707 memset (& addr, 0, sizeof (SOCKADDR_BTH));
708 fd = GNUNET_NETWORK_get_fd (dev->handle);
711 fprintf (stderr, "Failed to get the file descriptor\n");
714 if (SOCKET_ERROR == getsockname (fd, (SOCKADDR*)&addr, &addr_len))
716 fprintf (stderr, "Failed to get the port on which we are listening on: \n");
721 /* save the device address */
722 memcpy (&dev->pl_mac, &addr.btAddr, sizeof (BTH_ADDR));
724 /* set the address information */
725 memset (&addr_info, 0, sizeof (CSADDR_INFO));
726 addr_info.iProtocol = BTHPROTO_RFCOMM;
727 addr_info.iSocketType = SOCK_STREAM;
728 addr_info.LocalAddr.lpSockaddr = (LPSOCKADDR)&addr;
729 addr_info.LocalAddr.iSockaddrLength = sizeof (addr);
730 addr_info.RemoteAddr.lpSockaddr = (LPSOCKADDR)&addr;
731 addr_info.RemoteAddr.iSockaddrLength = sizeof (addr);
733 convert_guid((char *) uuid, &guid);
735 /* register the service */
736 memset (&wqs, 0, sizeof (WSAQUERYSET));
737 wqs.dwSize = sizeof (WSAQUERYSET);
738 wqs.dwNameSpace = NS_BTH;
739 wqs.lpszServiceInstanceName = "GNUnet Bluetooth Service";
740 wqs.lpszComment = "This is the service used by the GNUnnet plugin transport";
741 wqs.lpServiceClassId = &guid;
742 wqs.dwNumberOfCsAddrs = 1;
743 wqs.lpcsaBuffer = &addr_info ;
744 wqs.lpBlob = 0; //FIXME it should be 0 for a new entry
746 if (SOCKET_ERROR == WSASetService (&wqs , RNRSERVICE_REGISTER, 0))
748 fprintf (stderr, "Failed to register the SDP service: ");
754 fprintf (stderr, "The SDP service was registered\n");
761 * Function used for creating the service record and registering it.
763 * @param dev pointer to the device struct
764 * @param rc_channel the rfcomm channel
765 * @return 0 on success
768 register_service (struct HardwareInfos *dev, int rc_channel)
772 * 2. set the service ID, class, profile information
773 * 3. make the service record publicly browsable
774 * 4. register the RFCOMM channel
775 * 5. set the name, provider and description
776 * 6. register the service record to the local SDP server
779 uint8_t svc_uuid_int[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
780 dev->pl_mac.mac[5], dev->pl_mac.mac[4], dev->pl_mac.mac[3],
781 dev->pl_mac.mac[2], dev->pl_mac.mac[1], dev->pl_mac.mac[0]};
782 const char *service_dsc = "Bluetooth plugin services";
783 const char *service_prov = "GNUnet provider";
784 uuid_t root_uuid, rfcomm_uuid, svc_uuid;
785 sdp_list_t *root_list = 0, *rfcomm_list = 0, *proto_list = 0,
786 *access_proto_list = 0, *svc_list = 0;
787 sdp_record_t *record = 0;
788 sdp_data_t *channel = 0;
790 record = sdp_record_alloc();
792 /* Set the general service ID */
793 sdp_uuid128_create (&svc_uuid, &svc_uuid_int);
794 svc_list = sdp_list_append (0, &svc_uuid);
795 sdp_set_service_classes (record, svc_list);
796 sdp_set_service_id (record, svc_uuid);
798 /* Make the service record publicly browsable */
799 sdp_uuid16_create (&root_uuid, PUBLIC_BROWSE_GROUP);
800 root_list = sdp_list_append (0, &root_uuid);
801 sdp_set_browse_groups (record, root_list);
803 /* Register the RFCOMM channel */
804 sdp_uuid16_create (&rfcomm_uuid, RFCOMM_UUID);
805 channel = sdp_data_alloc (SDP_UINT8, &rc_channel);
806 rfcomm_list = sdp_list_append (0, &rfcomm_uuid);
807 sdp_list_append (rfcomm_list, channel);
808 proto_list = sdp_list_append (0, rfcomm_list);
810 /* Set protocol information */
811 access_proto_list = sdp_list_append (0, proto_list);
812 sdp_set_access_protos (record, access_proto_list);
814 /* Set the name, provider, and description */
815 sdp_set_info_attr (record, dev->iface, service_prov, service_dsc);
817 /* Connect to the local SDP server */
818 dev->session = sdp_connect (BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY);
822 fprintf (stderr, "Failed to connect to the SDP server on interface `%.*s': %s\n",
823 IFNAMSIZ, dev->iface, strerror (errno));
828 /* Register the service record */
829 if (sdp_record_register (dev->session, record, 0) < 0)
831 fprintf (stderr, "Failed to register a service record on interface `%.*s': %s\n",
832 IFNAMSIZ, dev->iface, strerror (errno));
838 sdp_data_free (channel);
839 sdp_list_free (root_list, 0);
840 sdp_list_free (rfcomm_list, 0);
841 sdp_list_free (proto_list, 0);
842 sdp_list_free (access_proto_list, 0);
843 sdp_list_free (svc_list, 0);
844 sdp_record_free (record);
852 * Function for searching and browsing for a service. This will return the
853 * port number on which the service is running.
855 * @param dest target address
859 get_channel(const char *dest)
863 DWORD wqs_len = sizeof (WSAQUERYSET);
867 unsigned char uuid[] = GNUNET_BLUETOOTH_SDP_UUID;
868 convert_guid ((char *) uuid, &guid);
870 wqs = (WSAQUERYSET*)malloc (wqs_len);
871 ZeroMemory (wqs, wqs_len);
873 wqs->dwSize = sizeof (WSAQUERYSET) ;
874 wqs->lpServiceClassId = &guid;
875 wqs->dwNameSpace = NS_BTH;
876 wqs->dwNumberOfCsAddrs = 0;
877 wqs->lpszContext = (LPSTR)dest;
879 if (SOCKET_ERROR == WSALookupServiceBegin (wqs, LUP_FLUSHCACHE | LUP_RETURN_ALL, &h))
881 if (GetLastError() == WSASERVICE_NOT_FOUND)
883 fprintf (stderr, "WARNING! The device with address %s wasn't found. Skipping the message!", dest);
888 fprintf (stderr, "Failed to find the port number: ");
895 /* search the sdp service */
898 if (SOCKET_ERROR == WSALookupServiceNext (h, LUP_FLUSHCACHE | LUP_RETURN_ALL, &wqs_len, wqs))
900 int error = WSAGetLastError();
906 //fprintf (stderr, "WSAFAULT error! (the memory allocated wasn't enought\n");
907 wqs = (WSAQUERYSET*)malloc (wqs_len);
910 fprintf (stderr, "Failed! The address was valid but there was no data record of requested type\n");
915 // fprintf (stderr, "No matching service found\n");
918 fprintf (stderr, "Failed to look over the services: ");
920 WSALookupServiceEnd (h);
926 channel = ((SOCKADDR_BTH*)wqs->lpcsaBuffer->RemoteAddr.lpSockaddr)->port;
931 WSALookupServiceEnd (h);
937 * Function used for searching and browsing for a service. This will return the
938 * port number on which the service is running.
940 * @param dev pointer to the device struct
941 * @param dest target address
945 get_channel(struct HardwareInfos *dev, bdaddr_t dest)
948 * 1. detect all nearby devices
949 * 2. for each device:
950 * 2.1. connect to the SDP server running
951 * 2.2. get a list of service records with the specific UUID
952 * 2.3. for each service record get a list of the protocol sequences and get
955 uint8_t svc_uuid_int[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
956 dest.b[5], dest.b[4], dest.b[3],
957 dest.b[2], dest.b[1], dest.b[0]};
958 sdp_session_t *session = 0;
959 sdp_list_t *search_list = 0, *attrid_list = 0, *response_list = 0, *it = 0;
961 uint32_t range = 0x0000ffff;
962 uint8_t channel = -1;
964 /* Connect to the local SDP server */
965 session = sdp_connect (BDADDR_ANY, &dest, 0);
968 fprintf (stderr, "Failed to connect to the SDP server on interface `%.*s': %s\n",
969 IFNAMSIZ, dev->iface, strerror (errno));
974 sdp_uuid128_create (&svc_uuid, &svc_uuid_int);
975 search_list = sdp_list_append (0, &svc_uuid);
976 attrid_list = sdp_list_append (0, &range);
978 if (sdp_service_search_attr_req (session, search_list,
979 SDP_ATTR_REQ_RANGE, attrid_list, &response_list) == 0)
981 for (it = response_list; it; it = it->next)
983 sdp_record_t *record = (sdp_record_t*) it->data;
984 //TODO print some record informations to be sure everything is good
985 sdp_list_t *proto_list = 0;
986 if (sdp_get_access_protos (record, &proto_list) == 0)
988 channel = sdp_get_proto_port (proto_list, RFCOMM_UUID);
989 sdp_list_free (proto_list, 0);
991 sdp_record_free (record);
995 sdp_list_free (search_list, 0);
996 sdp_list_free (attrid_list, 0);
997 sdp_list_free (response_list, 0);
1002 fprintf (stderr, "Failed to find the listening channel for interface `%.*s': %s\n",
1003 IFNAMSIZ, dev->iface, strerror (errno));
1010 * Read from the socket and put the result into the buffer for transmission to 'stdout'.
1012 * @param sock file descriptor for reading
1013 * @param buf buffer to read to; first bytes will be the 'struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame',
1014 * followed by the actual payload
1015 * @param buf_size size of the buffer
1016 * @param ri where to write radiotap_rx info
1017 * @return number of bytes written to 'buf'
1020 read_from_the_socket (void *sock,
1021 unsigned char *buf, size_t buf_size,
1022 struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *ri)
1024 unsigned char tmpbuf[buf_size];
1028 count = GNUNET_NETWORK_socket_recv ((struct GNUNET_NETWORK_Handle *)sock, tmpbuf, buf_size);
1030 count = read (*((int *)sock), tmpbuf, buf_size);
1035 if (EAGAIN == errno)
1040 fprintf (stderr, "Failed to read from the HCI socket: %s\n", strerror (errno));
1047 /* Get the channel used */ //FIXME probably not needed anymore
1049 struct sockaddr_rc rc_addr = { 0 };
1051 memset (&rc_addr, 0, sizeof (rc_addr));
1052 len = sizeof (rc_addr);
1053 if (0 > getsockname (*((int *)sock), (struct sockaddr *) &rc_addr, (socklen_t *) &len))
1055 fprintf (stderr, "getsockname() call failed : %s\n", strerror (errno));
1059 memset (ri, 0, sizeof (*ri));
1060 ri->ri_channel = rc_addr.rc_channel;
1063 /* Detect CRC32 at the end */
1064 if (0 == check_crc_buf_osdep (tmpbuf, count - sizeof (uint32_t)))
1066 count -= sizeof(uint32_t);
1069 memcpy (buf, tmpbuf, count);
1075 * Open the bluetooth interface for reading/writing
1077 * @param dev pointer to the device struct
1078 * @return 0 on success
1081 open_device (struct HardwareInfos *dev)
1086 /* bind the hci socket to the interface */
1087 addr.addressFamily = AF_BTH;
1089 addr.port = BT_PORT_ANY;
1091 //FIXME flags parameter
1092 if (GNUNET_NETWORK_socket_bind (dev->handle, (const SOCKADDR*)&addr, sizeof (SOCKADDR_BTH), 0) != GNUNET_OK)
1094 fprintf (stderr, "Failed to bind the socket: ");
1095 if (GetLastError() == WSAENETDOWN)
1097 fprintf (stderr, "Please make sure that your Bluetooth device is ON!\n");
1104 /* start listening on the socket */
1105 if (GNUNET_NETWORK_socket_listen (dev->handle, 4) != GNUNET_OK)
1107 fprintf (stderr, "Failed to listen on the socket: ");
1112 /* register the sdp service */
1113 if (register_service(dev) != 0)
1115 fprintf (stderr, "Failed to register a service: ");
1120 int i, dev_id = -1, fd_hci;
1123 struct hci_dev_list_req list;
1124 struct hci_dev_req dev[HCI_MAX_DEV];
1125 } request; //used for detecting the local devices
1126 struct sockaddr_rc rc_addr = { 0 }; //used for binding
1128 /* Initialize the neighbour structure */
1129 neighbours.dev_id = -1;
1130 for (i = 0; i < MAX_PORTS; i++)
1131 neighbours.fds[i] = -1;
1133 /* Open a HCI socket */
1134 fd_hci = socket (AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
1138 fprintf (stderr, "Failed to create HCI socket: %s\n", strerror (errno));
1142 memset (&request, 0, sizeof(request));
1143 request.list.dev_num = HCI_MAX_DEV;
1145 if (ioctl (fd_hci, HCIGETDEVLIST, (void *) &request) < 0)
1147 fprintf (stderr, "ioctl(HCIGETDEVLIST) on interface `%.*s' failed: %s\n",
1148 IFNAMSIZ, dev->iface, strerror (errno));
1152 /* Search for a device with dev->iface name */
1153 for (i = 0; i < request.list.dev_num; i++)
1155 struct hci_dev_info dev_info;
1157 memset (&dev_info, 0, sizeof(struct hci_dev_info));
1158 dev_info.dev_id = request.dev[i].dev_id;
1159 strncpy (dev_info.name, dev->iface, IFNAMSIZ);
1161 if (ioctl (fd_hci, HCIGETDEVINFO, (void *) &dev_info))
1163 fprintf (stderr, "ioctl(HCIGETDEVINFO) on interface `%.*s' failed: %s\n",
1164 IFNAMSIZ, dev->iface, strerror (errno));
1168 if (strcmp (dev_info.name, dev->iface) == 0)
1171 dev_id = dev_info.dev_id; //the device was found
1173 * Copy the MAC address to the device structure
1175 memcpy (&dev->pl_mac, &dev_info.bdaddr, sizeof (bdaddr_t));
1177 /* Check if the interface is up */
1178 if (hci_test_bit (HCI_UP, (void *) &dev_info.flags) == 0)
1180 /* Bring the interface up */
1181 if (ioctl (fd_hci, HCIDEVUP, dev_info.dev_id))
1183 fprintf (stderr, "ioctl(HCIDEVUP) on interface `%.*s' failed: %s\n",
1184 IFNAMSIZ, dev->iface, strerror (errno));
1189 /* Check if the device is discoverable */
1190 if (hci_test_bit (HCI_PSCAN, (void *) &dev_info.flags) == 0 ||
1191 hci_test_bit (HCI_ISCAN, (void *) &dev_info.flags) == 0)
1193 /* Set interface Page Scan and Inqury Scan ON */
1194 struct hci_dev_req dev_req;
1196 memset (&dev_req, 0, sizeof (dev_req));
1197 dev_req.dev_id = dev_info.dev_id;
1198 dev_req.dev_opt = SCAN_PAGE | SCAN_INQUIRY;
1200 if (ioctl (fd_hci, HCISETSCAN, (unsigned long) &dev_req))
1202 fprintf (stderr, "ioctl(HCISETSCAN) on interface `%.*s' failed: %s\n",
1203 IFNAMSIZ, dev->iface, strerror (errno));
1213 /* Check if the interface was not found */
1216 fprintf (stderr, "The interface %s was not found\n", dev->iface);
1220 /* Close the hci socket */
1221 (void) close(fd_hci);
1225 /* Bind the rfcomm socket to the interface */
1226 memset (&rc_addr, 0, sizeof (rc_addr));
1227 rc_addr.rc_family = AF_BLUETOOTH;
1228 rc_addr.rc_bdaddr = *BDADDR_ANY;
1230 if (bind_socket (dev->fd_rfcomm, &rc_addr) != 0)
1232 fprintf (stderr, "Failed to bind interface `%.*s': %s\n", IFNAMSIZ,
1233 dev->iface, strerror (errno));
1237 /* Register a SDP service */
1238 if (register_service (dev, rc_addr.rc_channel) != 0)
1240 fprintf (stderr, "Failed to register a service on interface `%.*s': %s\n", IFNAMSIZ,
1241 dev->iface, strerror (errno));
1245 /* Switch socket in listening mode */
1246 if (listen (dev->fd_rfcomm, 5) == -1) //FIXME: probably we need a bigger number
1248 fprintf (stderr, "Failed to listen on socket for interface `%.*s': %s\n", IFNAMSIZ,
1249 dev->iface, strerror (errno));
1260 * Set the header to sane values to make attacks more difficult
1262 * @param taIeeeHeader pointer to the header of the packet
1263 * @param dev pointer to the Hardware_Infos struct
1265 **** copy from gnunet-helper-transport-wlan.c ****
1268 mac_set (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader,
1269 const struct HardwareInfos *dev)
1271 taIeeeHeader->frame_control = htons (IEEE80211_FC0_TYPE_DATA);
1272 taIeeeHeader->addr3 = mac_bssid_gnunet;
1275 memcpy (&taIeeeHeader->addr2, &dev->pl_mac, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
1277 taIeeeHeader->addr2 = dev->pl_mac;
1283 * Test if the given interface name really corresponds to a bluetooth
1286 * @param iface name of the interface
1287 * @return 0 on success, 1 on error
1288 **** similar with the one from gnunet-helper-transport-wlan.c ****
1291 test_bluetooth_interface (const char *iface)
1297 ret = snprintf (strbuf, sizeof (strbuf),
1298 "/sys/class/bluetooth/%s/subsystem",
1300 if ((ret < 0) || (ret >= sizeof (strbuf)) || (0 != stat (strbuf, &sbuf)))
1303 "Did not find 802.15.1 interface `%s'. Exiting.\n",
1312 * Test incoming packets mac for being our own.
1314 * @param taIeeeHeader buffer of the packet
1315 * @param dev the Hardware_Infos struct
1316 * @return 0 if mac belongs to us, 1 if mac is for another target
1318 **** same as the one from gnunet-helper-transport-wlan.c ****
1321 mac_test (const struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader,
1322 const struct HardwareInfos *dev)
1324 static struct GNUNET_TRANSPORT_WLAN_MacAddress all_zeros;
1326 if ( (0 == memcmp (&taIeeeHeader->addr3, &all_zeros, MAC_ADDR_SIZE)) ||
1327 (0 == memcmp (&taIeeeHeader->addr1, &all_zeros, MAC_ADDR_SIZE)) )
1328 return 0; /* some drivers set no Macs, then assume it is all for us! */
1330 if (0 != memcmp (&taIeeeHeader->addr3, &mac_bssid_gnunet, MAC_ADDR_SIZE))
1331 return 1; /* not a GNUnet ad-hoc package */
1332 if ( (0 == memcmp (&taIeeeHeader->addr1, &dev->pl_mac, MAC_ADDR_SIZE)) ||
1333 (0 == memcmp (&taIeeeHeader->addr1, &bc_all_mac, MAC_ADDR_SIZE)) )
1334 return 0; /* for us, or broadcast */
1335 return 1; /* not for us */
1340 * Process data from the stdin. Takes the message, forces the sender MAC to be correct
1341 * and puts it into our buffer for transmission to the receiver.
1343 * @param cls pointer to the device struct ('struct HardwareInfos*')
1344 * @param hdr pointer to the start of the packet
1346 **** same as the one from gnunet-helper-transport-wlan.c ****
1349 stdin_send_hw (void *cls, const struct GNUNET_MessageHeader *hdr)
1351 struct HardwareInfos *dev = cls;
1352 const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header;
1353 struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *blueheader;
1356 sendsize = ntohs (hdr->size);
1358 sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage)) ||
1359 (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER != ntohs (hdr->type)) )
1361 fprintf (stderr, "Received malformed message\n");
1364 sendsize -= (sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) -
1365 sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame));
1366 if (MAXLINE < sendsize)
1368 fprintf (stderr, "Packet too big for buffer\n");
1371 header = (const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) hdr;
1372 memcpy (&write_pout.buf, &header->frame, sendsize);
1373 blueheader = (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *) &write_pout.buf;
1375 /* payload contains MAC address, but we don't trust it, so we'll
1376 * overwrite it with OUR MAC address to prevent mischief */
1377 mac_set (blueheader, dev);
1378 memcpy (&blueheader->addr1, &header->frame.addr1,
1379 sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
1380 write_pout.size = sendsize;
1385 * Broadcast a HELLO message for peer discovery
1387 * @param dev pointer to the device struct
1388 * @param dev pointer to the socket which was added to the set
1389 * @return 0 on success
1392 send_broadcast (struct HardwareInfos *dev, int *sendsocket)
1398 if ((neighbours.size == neighbours.pos && new_device == 1) || neighbours.size == 0)
1400 inquiry_devices: //skip the conditions and force a inquiry for new devices
1403 * It means that I sent HELLO messages to all the devices from the list and I should search
1404 * for new ones or that this is the first time when I do a search.
1406 inquiry_info *devices = NULL;
1407 int i, responses, max_responses = MAX_PORTS;
1410 if (neighbours.size >= MAX_PORTS)
1412 fprintf (stderr, "%.*s reached the top limit for the discovarable devices\n", IFNAMSIZ, dev->iface);
1416 /* Get the device id */
1417 if (neighbours.dev_id == -1)
1419 char addr[19] = { 0 }; //the device MAC address
1421 ba2str ((bdaddr_t *) &dev->pl_mac, addr);
1422 neighbours.dev_id = hci_devid (addr);
1423 if (neighbours.dev_id < 0)
1425 fprintf (stderr, "Failed to get the device id for interface %.*s : %s\n", IFNAMSIZ,
1426 dev->iface, strerror (errno));
1431 devices = malloc (max_responses * sizeof (inquiry_info));
1432 if (devices == NULL)
1434 fprintf (stderr, "Failed to allocate memory for inquiry info list on interface %.*s\n", IFNAMSIZ,
1439 responses = hci_inquiry (neighbours.dev_id, 8, max_responses, NULL, &devices, IREQ_CACHE_FLUSH);
1442 fprintf (stderr, "Failed to inquiry on interface %.*s\n", IFNAMSIZ, dev->iface);
1446 fprintf (stderr, "LOG : Found %d devices\n", responses); //FIXME delete it after debugging stage
1450 fprintf (stderr, "LOG : No devices discoverable\n");
1454 for (i = 0; i < responses; i++)
1462 fprintf (stderr, "%.*s reached the top limit for the discoverable devices (after inquiry)\n", IFNAMSIZ,
1467 /* Search if the address already exists on the list */
1468 for (j = 0; j < neighbours.size; j++)
1470 if (memcmp (&(devices + i)->bdaddr, &(neighbours.devices[j]), sizeof (bdaddr_t)) == 0)
1473 fprintf (stderr, "LOG : the device already exists on the list\n"); //FIXME debugging message
1480 char addr[19] = { 0 };
1482 ba2str (&(devices +i)->bdaddr, addr);
1483 fprintf (stderr, "LOG : %s was added to the list\n", addr); //FIXME debugging message
1484 memcpy (&(neighbours.devices[neighbours.size++]), &(devices + i)->bdaddr, sizeof (bdaddr_t));
1492 int connection_successful = 0;
1493 struct sockaddr_rc addr_rc = { 0 };
1495 addr_rc.rc_family = AF_BLUETOOTH;
1497 /* Try to connect to a new device from the list */
1498 while (neighbours.pos < neighbours.size)
1500 /* Check if we are already connected to this device */
1501 if (neighbours.fds[neighbours.pos] == -1)
1504 memset (&addr_rc.rc_bdaddr, 0, sizeof (addr_rc.rc_bdaddr));
1505 memcpy (&addr_rc.rc_bdaddr, &(neighbours.devices[neighbours.pos]), sizeof (addr_rc.rc_bdaddr));
1507 addr_rc.rc_channel = get_channel (dev, addr_rc.rc_bdaddr);
1509 *sendsocket = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
1510 if (connect (*sendsocket, (struct sockaddr *)&addr_rc, sizeof (addr_rc)) == 0)
1512 neighbours.fds[neighbours.pos++] = *sendsocket;
1513 connection_successful = 1;
1514 char addr[19] = { 0 };
1515 ba2str (&(neighbours.devices[neighbours.pos - 1]), addr);
1516 fprintf (stderr, "LOG : Connected to %s\n", addr);
1522 char addr[19] = { 0 };
1523 errno_copy = errno; //Save a copy for later
1524 ba2str (&(neighbours.devices[neighbours.pos]), addr);
1525 fprintf (stderr, "LOG : Couldn't connect on device %s, error : %s\n", addr, strerror(errno));
1526 if (errno != ECONNREFUSED) //FIXME be sure that this works
1528 fprintf (stderr, "LOG : Removes %d device from the list\n", neighbours.pos);
1529 /* Remove the device from the list */
1530 memcpy (&neighbours.devices[neighbours.pos], &neighbours.devices[neighbours.size - 1], sizeof (bdaddr_t));
1531 memset (&neighbours.devices[neighbours.size - 1], 0, sizeof (bdaddr_t));
1532 neighbours.fds[neighbours.pos] = neighbours.fds[neighbours.size - 1];
1533 neighbours.fds[neighbours.size - 1] = -1;
1534 neighbours.size -= 1;
1537 neighbours.pos += 1;
1539 if (neighbours.pos >= neighbours.size)
1544 if (loops == MAX_LOOPS) //don't get stuck trying to connect to one device
1550 fprintf (stderr, "LOG : Search for a new device\n"); //FIXME debugging message
1551 neighbours.pos += 1;
1555 /* Cycle on the list */
1556 if (neighbours.pos == neighbours.size)
1559 searching_devices_count += 1;
1561 if (searching_devices_count == MAX_LOOPS)
1563 fprintf (stderr, "LOG : Force to inquiry for new devices\n");
1564 searching_devices_count = 0;
1565 goto inquiry_devices;
1568 /* If a new device wasn't found, search an old one */
1569 if (connection_successful == 0)
1571 int loop_check = neighbours.pos;
1572 while (neighbours.fds[neighbours.pos] == -1)
1574 if (neighbours.pos == neighbours.size)
1577 if (neighbours.pos == loop_check)
1579 if (errno_copy == ECONNREFUSED)
1581 fprintf (stderr, "LOG : No device found. Go back and search again\n"); //FIXME debugging message
1584 goto search_for_devices;
1588 return 1; // Skip the broadcast message
1592 neighbours.pos += 1;
1595 *sendsocket = neighbours.fds[neighbours.pos++];
1603 * Main function of the helper. This code accesses a bluetooth interface
1604 * forwards traffic in both directions between the bluetooth interface and
1605 * stdin/stdout of this process. Error messages are written to stderr.
1607 * @param argc number of arguments, must be 2
1608 * @param argv arguments only argument is the name of the interface (i.e. 'hci0')
1609 * @return 0 on success (never happens, as we don't return unless aborted), 1 on error
1611 **** similar to gnunet-helper-transport-wlan.c ****
1614 main (int argc, char *argv[])
1617 struct HardwareInfos dev;
1618 char readbuf[MAXLINE];
1623 struct MessageStreamTokenizer *stdin_mst;
1626 int crt_rfds = 0, rfds_list[MAX_PORTS];
1627 int broadcast, sendsocket;
1628 /* Assert privs so we can modify the firewall rules! */
1630 #ifdef HAVE_SETRESUID
1631 if (0 != setresuid (uid, 0, 0))
1633 fprintf (stderr, "Failed to setresuid to root: %s\n", strerror (errno));
1637 if (0 != seteuid (0))
1639 fprintf (stderr, "Failed to seteuid back to root: %s\n", strerror (errno));
1644 /* Make use of SGID capabilities on POSIX */
1645 memset (&dev, 0, sizeof (dev));
1646 dev.fd_rfcomm = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
1647 raw_eno = errno; /* remember for later */
1649 /* Now that we've dropped root rights, we can do error checking */
1652 fprintf (stderr, "You must specify the name of the interface as the first \
1653 and only argument to this program.\n");
1654 if (-1 != dev.fd_rfcomm)
1655 (void) close (dev.fd_rfcomm);
1659 if (-1 == dev.fd_rfcomm)
1661 fprintf (stderr, "Failed to create a HCI socket: %s\n", strerror (raw_eno));
1664 if (dev.fd_rfcomm >= FD_SETSIZE)
1666 fprintf (stderr, "File descriptor too large for select (%d > %d)\n",
1667 dev.fd_rfcomm, FD_SETSIZE);
1668 (void) close (dev.fd_rfcomm);
1671 if (0 != test_bluetooth_interface (argv[1]))
1673 (void) close (dev.fd_rfcomm);
1676 strncpy (dev.iface, argv[1], IFNAMSIZ);
1677 if (0 != open_device (&dev))
1679 (void) close (dev.fd_rfcomm);
1685 uid_t uid = getuid ();
1686 #ifdef HAVE_SETRESUID
1687 if (0 != setresuid (uid, uid, uid))
1689 fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno));
1690 if (-1 != dev.fd_rfcomm)
1691 (void) close (dev.fd_rfcomm);
1695 if (0 != (setuid (uid) | seteuid (uid)))
1697 fprintf (stderr, "Failed to setuid: %s\n", strerror (errno));
1698 if (-1 != dev.fd_rfcomm)
1699 (void) close (dev.fd_rfcomm);
1705 /* Send MAC address of the bluetooth interface to STDOUT first */
1707 struct GNUNET_TRANSPORT_WLAN_HelperControlMessage macmsg;
1709 macmsg.hdr.size = htons (sizeof (macmsg));
1710 macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL);
1711 memcpy (&macmsg.mac, &dev.pl_mac, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
1712 memcpy (write_std.buf, &macmsg, sizeof (macmsg));
1713 write_std.size = sizeof (macmsg);
1717 stdin_mst = mst_create (&stdin_send_hw, &dev);
1720 fprintf (stderr, "\n-----------------------------------------------\n Check if the program exits\n-----------------------------------------------\n");
1722 * TODO : When a connection fails I should ignore only the CONTROL messages.
1723 * For DATA messages I should retry to send the message until it doesn't fail
1724 * Also I should make the time out of a mac endpoint smaller and check if the rate
1725 * from get_wlan_header (plugin_transport_bluetooth.c) is correct.
1734 if ((0 == write_pout.size) && (1 == stdin_open))
1736 FD_SET (STDIN_FILENO, &rfds);
1737 maxfd = MAX (maxfd, STDIN_FILENO);
1739 if (0 == write_std.size)
1741 FD_SET (dev.fd_rfcomm, &rfds);
1742 maxfd = MAX (maxfd, dev.fd_rfcomm);
1745 for (i = 0; i < crt_rfds; i++) // it can receive messages from multiple devices
1747 FD_SET (rfds_list[i], &rfds);
1748 maxfd = MAX (maxfd, rfds_list[i]);
1751 if (0 < write_std.size)
1753 FD_SET (STDOUT_FILENO, &wfds);
1754 maxfd = MAX (maxfd, STDOUT_FILENO);
1756 if (0 < write_pout.size) //it can send messages only to one device per loop
1758 struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *frame;
1759 /* Get the destination address */
1760 frame = (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *) write_pout.buf;
1762 if (memcmp (&frame->addr1, &dev.pl_mac,
1763 sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)
1766 memset (&write_pout, 0, sizeof (write_pout)); //clear the buffer
1768 else if (memcmp (&frame->addr1, &broadcast_address,
1769 sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)
1771 fprintf (stderr, "LOG : %s has a broadcast message (pos %d, size %d)\n", dev.iface, neighbours.pos, neighbours.size); //FIXME: debugging message
1772 // broadcast = 1; // IF I HAVE A BROADCAST MESSAGE I skip.
1773 // memset (&write_pout, 0, sizeof (write_pout));
1775 if (send_broadcast(&dev, &sendsocket) != 0) //if the searching wasn't successful don't get stuck on the select stage
1778 memset (&write_pout, 0, sizeof (write_pout)); //remove the message
1779 fprintf (stderr, "LOG : Skip the broadcast message (pos %d, size %d)\n", neighbours.pos, neighbours.size);
1783 FD_SET (sendsocket, &wfds);
1784 maxfd = MAX (maxfd, sendsocket);
1791 /* Search if the address already exists on the list */
1792 for (i = 0; i < neighbours.size; i++)
1794 if (memcmp (&frame->addr1, &(neighbours.devices[i]), sizeof (bdaddr_t)) == 0)
1797 if (neighbours.fds[i] != -1)
1799 found = 1; //save the position where it was found
1800 FD_SET (neighbours.fds[i], &wfds);
1801 maxfd = MAX (maxfd, neighbours.fds[i]);
1802 sendsocket = neighbours.fds[i];
1803 fprintf (stderr, "LOG: the address was found in the list\n");
1811 struct sockaddr_rc addr = { 0 };
1813 fprintf (stderr, "LOG : %s has a new message for %.2X:%.2X:%.2X:%.2X:%.2X:%.2X which isn't on the broadcast list\n", dev.iface,
1814 frame->addr1.mac[5], frame->addr1.mac[4], frame->addr1.mac[3],
1815 frame->addr1.mac[2], frame->addr1.mac[1], frame->addr1.mac[0]); //FIXME: debugging message
1817 sendsocket = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
1821 fprintf (stderr, "Failed to create a RFCOMM socket (sending stage): %s\n",
1826 memcpy (&addr.rc_bdaddr, &frame->addr1, sizeof (bdaddr_t));
1827 addr.rc_family = AF_BLUETOOTH;
1828 addr.rc_channel = get_channel (&dev, addr.rc_bdaddr);
1832 status = connect (sendsocket, (struct sockaddr *) &addr, sizeof (addr));
1833 if (0 != status && errno != EAGAIN)
1835 if (errno == ECONNREFUSED && tries < 2)
1837 fprintf (stderr, "LOG : %.*s failed to connect. Trying again!\n", IFNAMSIZ, dev.iface);
1841 else if (errno == EBADF)
1843 fprintf (stderr, "LOG : %s failed to connect : %s. Skip it!\n", dev.iface, strerror (errno));
1844 memset (&write_pout, 0, sizeof (write_pout));
1849 fprintf (stderr, "LOG : %s failed to connect : %s. Try again later!\n", dev.iface, strerror (errno));
1850 memset (&write_pout, 0, sizeof (write_pout));
1857 FD_SET (sendsocket, &wfds);
1858 maxfd = MAX (maxfd, sendsocket);
1859 fprintf (stderr, "LOG : Connection successful\n");
1860 if (pos != 0) // save the socket
1862 neighbours.fds[pos] = sendsocket;
1866 /* Add the new device to the discovered devices list */
1867 if (neighbours.size < MAX_PORTS)
1869 neighbours.fds[neighbours.size] = sendsocket;
1870 memcpy (&(neighbours.devices[neighbours.size++]), &addr.rc_bdaddr, sizeof (bdaddr_t));
1874 fprintf (stderr, "The top limit for the discovarable devices' list was reached\n");
1884 /* Select a fd which is ready for action :) */
1886 int retval = select (maxfd + 1, &rfds, &wfds, NULL, NULL);
1887 if ((-1 == retval) && (EINTR == errno))
1889 if (0 > retval && errno != EBADF) // we handle BADF errors later
1891 fprintf (stderr, "select failed: %s\n", strerror (errno));
1895 if (FD_ISSET (STDOUT_FILENO , &wfds))
1898 write (STDOUT_FILENO, write_std.buf + write_std.pos,
1899 write_std.size - write_std.pos);
1902 fprintf (stderr, "Failed to write to STDOUT: %s\n", strerror (errno));
1905 write_std.pos += ret;
1906 if (write_std.pos == write_std.size)
1911 fprintf (stderr, "LOG : %s sends a message to STDOUT\n", dev.iface); //FIXME: debugging message
1914 if (sendsocket != -1)
1916 if (FD_ISSET (sendsocket , &wfds))
1919 write (sendsocket, write_pout.buf + write_std.pos,
1920 write_pout.size - write_pout.pos);
1921 if (0 > ret) //FIXME should I first check the error type?
1923 fprintf (stderr, "Failed to write to bluetooth device: %s. Closing the socket!\n",
1925 for (i = 0; i < neighbours.size; i++)
1927 if (neighbours.fds[i] == sendsocket)
1929 (void) close(sendsocket);
1930 neighbours.fds[i] = -1;
1934 /* Remove the message */
1935 memset (&write_pout.buf + write_std.pos, 0, (write_pout.size - write_pout.pos));
1936 write_pout.pos = 0 ;
1937 write_pout.size = 0;
1941 write_pout.pos += ret;
1942 if ((write_pout.pos != write_pout.size) && (0 != ret))
1944 /* We should not get partial sends with packet-oriented devices... */
1945 fprintf (stderr, "Write error, partial send: %u/%u\n",
1946 (unsigned int) write_pout.pos,
1947 (unsigned int) write_pout.size);
1951 if (write_pout.pos == write_pout.size)
1954 write_pout.size = 0;
1956 fprintf (stderr, "LOG : %s sends a message to a DEVICE\n", dev.iface); //FIXME: debugging message
1960 for (i = 0; i <= maxfd; i++)
1962 if (FD_ISSET (i, &rfds))
1964 if (i == STDIN_FILENO)
1967 read (i, readbuf, sizeof (readbuf));
1970 fprintf (stderr, "Read error from STDIN: %s\n", strerror (errno));
1975 /* stop reading... */
1980 mst_receive (stdin_mst, readbuf, ret);
1981 fprintf (stderr, "LOG : %s receives a message from STDIN\n", dev.iface); //FIXME: debugging message
1984 else if (i == dev.fd_rfcomm)
1987 struct sockaddr_rc addr = { 0 };
1988 unsigned int opt = sizeof (addr);
1990 readsocket = accept (dev.fd_rfcomm, (struct sockaddr *) &addr, &opt);
1991 fprintf(stderr, "LOG : %s accepts a message\n", dev.iface); //FIXME: debugging message
1992 if (readsocket == -1)
1994 fprintf (stderr, "Failed to accept a connection on interface: %.*s\n", IFNAMSIZ,
2000 FD_SET (readsocket, &rfds);
2001 maxfd = MAX (maxfd, readsocket);
2003 if (crt_rfds < MAX_PORTS)
2004 rfds_list[crt_rfds++] = readsocket;
2007 fprintf (stderr, "The limit for the read file descriptors list was \
2016 struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm;
2018 fprintf (stderr, "LOG : %s reads something from the socket\n", dev.iface);//FIXME : debugging message
2019 rrm = (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) write_std.buf;
2021 read_from_the_socket ((void *)&i, (unsigned char *) &rrm->frame,
2022 sizeof (write_std.buf)
2023 - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
2024 + sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame),
2031 /* Remove the socket from the list */
2032 for (j = 0; j < crt_rfds; j++)
2034 if (rfds_list[j] == i)
2036 rfds_list[j] ^= rfds_list[crt_rfds - 1];
2037 rfds_list[crt_rfds - 1] ^= rfds_list[j];
2038 rfds_list[j] ^= rfds_list[crt_rfds - 1];
2044 fprintf (stderr, "Read error from raw socket: %s\n", strerror (errno));
2047 if ((0 < ret) && (0 == mac_test (&rrm->frame, &dev)))
2049 write_std.size = ret
2050 + sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
2051 - sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame);
2052 rrm->header.size = htons (write_std.size);
2053 rrm->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER);
2060 /* Error handling, try to clean up a bit at least */
2061 mst_destroy (stdin_mst);
2063 sdp_close (dev.session);
2064 (void) close (dev.fd_rfcomm);
2065 (void) close (sendsocket);
2067 for (i = 0; i < crt_rfds; i++)
2068 (void) close (rfds_list[i]);
2070 for (i = 0; i < neighbours.size; i++)
2071 (void) close (neighbours.fds[i]);
2073 struct HardwareInfos dev;
2074 struct GNUNET_NETWORK_Handle *sendsocket;
2075 struct GNUNET_NETWORK_FDSet *rfds;
2076 struct GNUNET_NETWORK_FDSet *wfds;
2077 struct GNUNET_NETWORK_Handle *rfds_list[MAX_PORTS];
2078 char readbuf[MAXLINE] = { 0 };
2079 SOCKADDR_BTH acc_addr = { 0 };
2080 int addr_len = sizeof (SOCKADDR_BTH);
2081 int broadcast, i, stdin_open, crt_rfds = 0;
2082 HANDLE stdin_handle = GetStdHandle (STD_INPUT_HANDLE);
2083 HANDLE stdout_handle = GetStdHandle (STD_OUTPUT_HANDLE);
2084 struct MessageStreamTokenizer *stdin_mst;
2086 /* check the handles */
2087 if (stdin_handle == INVALID_HANDLE_VALUE)
2089 fprintf (stderr, "Failed to get the stdin handle\n");
2093 if (stdout_handle == INVALID_HANDLE_VALUE)
2095 fprintf (stderr, "Failed to get the stdout handle\n");
2099 /* initialize windows sockets */
2100 initialize_windows_sockets();
2102 // /* test bluetooth socket family support */ --> it return false because the GNUNET_NETWORK_test_pf should also receive the type of socket (BTHPROTO_RFCOMM)
2103 // if (GNUNET_NETWORK_test_pf (AF_BTH) != GNUNET_OK)
2105 // fprintf (stderr, "AF_BTH family is not supported\n");
2109 /* create the socket */
2110 dev.handle = GNUNET_NETWORK_socket_create (AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
2111 if (dev.handle == NULL)
2113 fprintf (stderr, "Failed to create RFCOMM socket: ");
2119 if (open_device (&dev) == -1)
2121 fprintf (stderr, "Failed to open the device\n");
2123 if (GNUNET_NETWORK_socket_close (dev.handle) != GNUNET_OK)
2125 fprintf (stderr, "Failed to close the socket!\n");
2131 if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking (dev.handle, 1) )
2133 fprintf (stderr, "Failed to change the socket mode\n");
2137 memset (&write_std, 0, sizeof (write_std));
2138 memset (&write_pout, 0, sizeof (write_pout));
2141 rfds = GNUNET_NETWORK_fdset_create ();
2142 wfds = GNUNET_NETWORK_fdset_create ();
2144 /* Send MAC address of the bluetooth interface to STDOUT first */
2146 struct GNUNET_TRANSPORT_WLAN_HelperControlMessage macmsg;
2148 macmsg.hdr.size = htons (sizeof (macmsg));
2149 macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL);
2150 memcpy (&macmsg.mac, &dev.pl_mac, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress_Copy));
2151 memcpy (write_std.buf, &macmsg, sizeof (macmsg));
2152 write_std.size = sizeof (macmsg);
2156 stdin_mst = mst_create (&stdin_send_hw, &dev);
2159 fprintf (stderr, "\n-----------------------------------------------\n Check if the program exits\n-----------------------------------------------\n");
2163 int stdout_pos = -1;
2170 sendsocket = NULL; //FIXME memleaks
2171 fprintf (stderr, "---------------------------------------------------\n");
2173 GNUNET_NETWORK_fdset_zero (rfds);
2174 if ((0 == write_pout.size) && (1 == stdin_open))
2178 fprintf (stderr, "LOG: set STDIN_FILENO\n");
2179 GNUNET_NETWORK_fdset_handle_set (rfds, (struct GNUNET_DISK_FileHandle*) &stdin_handle); //FIXME create a GNUNET_STRUCT handle for stdin
2182 if (0 == write_std.size)
2185 fprintf (stderr, "LOG: set the listening socket %d\n", GNUNET_NETWORK_get_fd (dev.handle));
2186 GNUNET_NETWORK_fdset_set (rfds, dev.handle);
2189 for (i = 0; i < crt_rfds; i++)
2192 fprintf (stderr, "LOG: adding %d read socket\n", i);
2193 GNUNET_NETWORK_fdset_set (rfds, rfds_list[i]);
2196 GNUNET_NETWORK_fdset_zero (wfds);
2197 if (0 < write_std.size)
2200 fprintf (stderr, "LOG: set STDOUT_FILENO\n");
2201 GNUNET_NETWORK_fdset_handle_set (wfds, (struct GNUNET_DISK_FileHandle*) &stdout_handle);
2202 fprintf (stderr, "LOG: after setting STDOUT_FILENO\n");
2203 // printf ("%s\n", write_std.buf);
2204 // memset (write_std.buf, 0, write_std.size);
2205 // write_std.size = 0;
2208 if (0 < write_pout.size)
2210 if (strcmp (argv[1], "ff:ff:ff:ff:ff:ff") == 0) {
2211 fprintf(stderr, "BROADCAST\n");
2214 memset (write_pout.buf, 0, write_pout.size);
2215 write_pout.size = 0;
2220 fprintf (stderr, "LOG : has a new message for %s\n", argv[1]);
2221 sendsocket = GNUNET_NETWORK_socket_create (AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
2223 if (sendsocket == NULL)
2225 fprintf (stderr, "Failed to create RFCOMM socket: \n");
2230 memset (&addr, 0, sizeof (addr));
2231 //addr.addressFamily = AF_BTH;
2233 WSAStringToAddress (argv[1], AF_BTH, NULL, (LPSOCKADDR) &addr, &addr_len))
2235 fprintf (stderr, "Failed to translate the address: ");
2239 addr.port = get_channel (argv[1]); //crapa aici
2240 if (addr.port == -1)
2242 fprintf (stderr, "Couldn't find the sdp service for the address: %s\n", argv[1]);
2243 memset (write_pout.buf, 0, write_pout.size);
2244 write_pout.size = 0;
2245 broadcast = 1; //skipping the select part
2249 fprintf (stderr, "got the channel %d\n", addr.port);
2251 if (GNUNET_OK != GNUNET_NETWORK_socket_connect (sendsocket, (LPSOCKADDR)&addr, addr_len))
2253 fprintf (stderr, "Failed to connect: ");
2258 if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking (sendsocket, 1) )
2260 fprintf (stderr, "Failed to change the socket mode\n");
2264 GNUNET_NETWORK_fdset_set (wfds, sendsocket);
2271 fprintf (stderr, "before select\n");
2272 int retval = GNUNET_NETWORK_socket_select (rfds, wfds, NULL, GNUNET_TIME_relative_get_forever_());
2273 fprintf (stderr, "after select %d\n", retval);
2276 fprintf (stderr, "select error\n");
2279 //if (GNUNET_NETWORK_fdset_isset (wfds, (struct GNUNET_NETWORK_Handle*)&stdout_handle))
2280 if (retval == stdout_pos)
2282 fprintf (stderr, "-------------STDOUT------------\n");
2283 fprintf(stderr, "LOG : sends a message to STDOUT\n"); //FIXME: debugging message
2285 //ret = GNUNET_NETWORK_socket_send ((struct GNUNET_NETWORK_Handle *)&stdout_handle, write_std.buf + write_std.pos, write_std.size - write_std.pos);
2286 //ret = write (STDOUT_FILENO, write_std.buf + write_std.pos, write_std.size - write_std.pos);
2288 if (FALSE == WriteFile (stdout_handle, write_std.buf + write_std.pos, write_std.size - write_std.pos, &ret, NULL))
2290 fprintf (stderr, "Failed to write to STDOUT: ");
2294 fprintf (stderr, "--->sended: %d\n", ret);
2298 fprintf (stderr, "Failed to write to STDOUT\n");
2302 write_std.pos += ret;
2303 if (write_std.pos == write_std.size)
2309 if (sendsocket != NULL)
2311 if (GNUNET_NETWORK_fdset_isset (wfds, sendsocket))
2313 fprintf (stderr, "-------------SEND------------\n");
2315 ret = GNUNET_NETWORK_socket_send (sendsocket, write_pout.buf + write_pout.pos,
2316 write_pout.size - write_pout.pos);
2318 if (GNUNET_SYSERR == ret)
2320 fprintf (stderr, "Failed to send to the socket. Closing the socket. Error: \n");
2322 if (GNUNET_NETWORK_socket_close (sendsocket) != GNUNET_OK)
2324 fprintf (stderr, "Failed to close the sendsocket!\n");
2332 write_pout.pos += ret;
2333 if ((write_pout.pos != write_pout.size) && (0 != ret))
2335 /* we should not get partial sends with packet-oriented devices... */
2336 fprintf (stderr, "Write error, partial send: %u/%u\n",
2337 (unsigned int) write_pout.pos,
2338 (unsigned int) write_pout.size);
2342 if (write_pout.pos == write_pout.size)
2345 write_pout.size = 0;
2348 fprintf(stderr, "LOG : sends a message to a DEVICE\n"); //FIXME: debugging message
2353 //if (GNUNET_NETWORK_fdset_isset (rfds, (struct GNUNET_NETWORK_Handle*)&stdin_handle))
2354 if (retval == stdin_pos) //FALSEEE!!!! NUUUUU EEE VOOIEE!!_----------------------------------------------------------?
2356 fprintf (stderr, "-------------STDIN------------\n");
2358 //ret = GNUNET_NETWORK_socket_recv ((struct GNUNET_NETWORK_Handle *)&stdin_handle, readbuf, sizeof (write_pout.buf));
2359 //ret = read (STDIN_FILENO, readbuf, sizeof (readbuf));
2361 if (FALSE == ReadFile (stdin_handle, readbuf, sizeof (readbuf), &ret, NULL)) /* do nothing asynchronous */
2363 fprintf (stderr, "Read error from STDIN: ");
2369 /* stop reading... */
2372 mst_receive (stdin_mst, readbuf, ret);
2373 fprintf (stderr, "LOG : receives a message from STDIN\n"); //FIXME: debugging message
2377 if (GNUNET_NETWORK_fdset_isset (rfds, dev.handle))
2379 fprintf (stderr, "-------------ACCEPT------------\n");
2380 fprintf (stderr, "LOG: accepting connection\n");
2381 struct GNUNET_NETWORK_Handle *readsocket;
2382 readsocket = GNUNET_NETWORK_socket_accept (dev.handle, (LPSOCKADDR)&acc_addr, &addr_len);
2383 if (readsocket == NULL)
2385 fprintf (stderr, "Accept error %d: ", GetLastError());
2391 if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking (readsocket, 1) )
2393 fprintf (stderr, "Failed to change the socket mode\n");
2396 GNUNET_NETWORK_fdset_set (rfds, readsocket);
2398 if (crt_rfds < MAX_PORTS)
2399 rfds_list[crt_rfds++] = readsocket;
2402 fprintf (stderr, "The limit for the read file descriptors list was reached\n");
2408 for (i = 0; i < crt_rfds; i++)
2410 if (GNUNET_NETWORK_fdset_isset (rfds, rfds_list[i]))
2412 struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm;
2414 fprintf (stderr, "LOG: reading something from the socket\n");//FIXME : debugging message
2415 rrm = (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) write_std.buf;
2416 ret = read_from_the_socket (rfds_list[i], (unsigned char *) &rrm->frame,
2417 sizeof (write_std.buf)
2418 - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
2419 + sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame),
2421 fprintf (stderr, "MESSAGE: %s\n", readbuf);
2425 //TODO remove the socket from the list
2426 if (GNUNET_NETWORK_socket_close (rfds_list[i]) != GNUNET_OK)
2428 fprintf (stderr, "Failed to close the sendsocket!\n");
2432 fprintf (stderr, "Read error from raw socket: ");
2437 if ((0 < ret) && (0 == mac_test (&rrm->frame, &dev)))
2439 write_std.size = ret
2440 + sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
2441 - sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame);
2442 rrm->header.size = htons (write_std.size);
2443 rrm->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER);
2451 mst_destroy (stdin_mst);
2454 if (GNUNET_NETWORK_socket_close (dev.handle) != GNUNET_OK)
2456 fprintf (stderr, "Failed to close the socket!\n");
2460 for (i = 0; i < crt_rfds; i++)
2462 if (GNUNET_NETWORK_socket_close (rfds_list[i]) != GNUNET_OK)
2464 fprintf (stderr, "Failed to close the socket!\n");
2471 return 1; /* we never exit 'normally' */