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];
86 * The UUID used for the SDP service.
87 * {31191E56-FA7E-4517-870E-71B86BBCC52F}
89 #define GNUNET_BLUETOOTH_SDP_UUID \
91 0x31, 0x19, 0x1E, 0x56, \
95 0x71, 0xB8, 0x6B, 0xBC, 0xC5, 0x2F \
100 * struct for storing the information of the hardware. There is only
106 * Name of the interface, not necessarily 0-terminated (!).
108 char iface[IFNAMSIZ];
114 struct GNUNET_NETWORK_Handle *handle;
117 * MAC address of our own bluetooth interface.
119 struct GNUNET_TRANSPORT_WLAN_MacAddress_Copy pl_mac;
122 * file descriptor for the rfcomm socket
127 * MAC address of our own bluetooth interface.
129 struct GNUNET_TRANSPORT_WLAN_MacAddress pl_mac;
134 sdp_session_t *session ;
139 * IO buffer used for buffering data in transit (to wireless or to stdout).
144 * How many bytes of data are stored in 'buf' for transmission right now?
145 * Data always starts at offset 0 and extends to 'size'.
150 * How many bytes that were stored in 'buf' did we already write to the
151 * destination? Always smaller than 'size'.
156 * Buffered data; twice the maximum allowed message size as we add some
159 char buf[MAXLINE * 2];
164 * Devices buffer used to keep a list with all the discoverable devices in
165 * order to send them HELLO messages one by one when it receive a broadcast message.
167 struct BroadcastMessages
169 /* List with the discoverable devices' addresses */
170 bdaddr_t devices[MAX_PORTS];
172 /* List with the open sockets */
176 /* The number of the devices */
179 /* The current position */
187 * Address used to identify the broadcast messages.
189 static struct GNUNET_TRANSPORT_WLAN_MacAddress broadcast_address = {{255, 255, 255, 255, 255, 255}};
192 * Buffer with the discoverable devices.
194 static struct BroadcastMessages neighbours;
196 static int searching_devices_count = 0;
200 * Buffer for data read from stdin to be transmitted to the bluetooth device
202 static struct SendBuffer write_pout;
205 * Buffer for data read from the bluetooth device to be transmitted to stdout.
207 static struct SendBuffer write_std;
210 /* ****** this are the same functions as the ones used in gnunet-helper-transport-wlan.c ****** */
213 * To what multiple do we align messages? 8 byte should suffice for everyone
216 #define ALIGN_FACTOR 8
219 * Smallest supported message.
221 #define MIN_BUFFER_SIZE sizeof (struct GNUNET_MessageHeader)
225 * Functions with this signature are called whenever a
226 * complete message is received by the tokenizer.
229 * @param message the actual message
231 typedef void (*MessageTokenizerCallback) (void *cls,
233 GNUNET_MessageHeader *
237 * Handle to a message stream tokenizer.
239 struct MessageStreamTokenizer
243 * Function to call on completed messages.
245 MessageTokenizerCallback cb;
253 * Size of the buffer (starting at 'hdr').
258 * How many bytes in buffer have we already processed?
263 * How many bytes in buffer are valid right now?
268 * Beginning of the buffer. Typed like this to force alignment.
270 struct GNUNET_MessageHeader *hdr;
276 * Create a message stream tokenizer.
278 * @param cb function to call on completed messages
279 * @param cb_cls closure for cb
280 * @return handle to tokenizer
282 static struct MessageStreamTokenizer *
283 mst_create (MessageTokenizerCallback cb,
286 struct MessageStreamTokenizer *ret;
288 ret = malloc (sizeof (struct MessageStreamTokenizer));
291 fprintf (stderr, "Failed to allocate buffer for tokenizer\n");
294 ret->hdr = malloc (MIN_BUFFER_SIZE);
295 if (NULL == ret->hdr)
297 fprintf (stderr, "Failed to allocate buffer for alignment\n");
300 ret->curr_buf = MIN_BUFFER_SIZE;
302 ret->cb_cls = cb_cls;
310 * Add incoming data to the receive buffer and call the
311 * callback for all complete messages.
313 * @param mst tokenizer to use
314 * @param buf input data to add
315 * @param size number of bytes in buf
316 * @return GNUNET_OK if we are done processing (need more data)
317 * GNUNET_SYSERR if the data stream is corrupt
320 mst_receive (struct MessageStreamTokenizer *mst,
321 const char *buf, size_t size)
323 const struct GNUNET_MessageHeader *hdr;
328 unsigned long offset;
332 ibuf = (char *) mst->hdr;
336 if (mst->pos < mst->off)
338 //fprintf (stderr, "We processed too many bytes!\n");
339 return GNUNET_SYSERR;
341 if ((mst->curr_buf - mst->off < sizeof (struct GNUNET_MessageHeader)) ||
342 (0 != (mst->off % ALIGN_FACTOR)))
344 /* need to align or need more space */
345 mst->pos -= mst->off;
346 memmove (ibuf, &ibuf[mst->off], mst->pos);
349 if (mst->pos - mst->off < sizeof (struct GNUNET_MessageHeader))
352 GNUNET_MIN (sizeof (struct GNUNET_MessageHeader) -
353 (mst->pos - mst->off), size);
354 memcpy (&ibuf[mst->pos], buf, delta);
359 if (mst->pos - mst->off < sizeof (struct GNUNET_MessageHeader))
361 //FIXME should I reset ??
366 hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
367 want = ntohs (hdr->size);
368 if (want < sizeof (struct GNUNET_MessageHeader))
371 "Received invalid message from stdin\n");
372 return GNUNET_SYSERR;
374 if ((mst->curr_buf - mst->off < want) &&
377 /* need more space */
378 mst->pos -= mst->off;
379 memmove (ibuf, &ibuf[mst->off], mst->pos);
382 if (want > mst->curr_buf)
386 fprintf (stderr, "Error! We should proceeded 0 bytes\n");
387 return GNUNET_SYSERR;
389 mst->hdr = realloc (mst->hdr, want);
390 if (NULL == mst->hdr)
392 fprintf (stderr, "Failed to allocate buffer for alignment\n");
395 ibuf = (char *) mst->hdr;
396 mst->curr_buf = want;
398 hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
399 if (mst->pos - mst->off < want)
401 delta = GNUNET_MIN (want - (mst->pos - mst->off), size);
402 if (mst->pos + delta > mst->curr_buf)
404 fprintf (stderr, "The size of the buffer will be exceeded!\n");
405 return GNUNET_SYSERR;
407 memcpy (&ibuf[mst->pos], buf, delta);
412 if (mst->pos - mst->off < want)
414 //FIXME should I use this?
419 mst->cb (mst->cb_cls, hdr);
421 if (mst->off == mst->pos)
423 /* reset to beginning of buffer, it's free right now! */
430 fprintf (stderr, "There should some valid bytes in the buffer on this stage\n");
431 return GNUNET_SYSERR;
435 if (size < sizeof (struct GNUNET_MessageHeader))
437 offset = (unsigned long) buf;
438 need_align = (0 != offset % ALIGN_FACTOR) ? GNUNET_YES : GNUNET_NO;
439 if (GNUNET_NO == need_align)
441 /* can try to do zero-copy and process directly from original buffer */
442 hdr = (const struct GNUNET_MessageHeader *) buf;
443 want = ntohs (hdr->size);
444 if (want < sizeof (struct GNUNET_MessageHeader))
447 "Received invalid message from stdin\n");
450 return GNUNET_SYSERR;
453 break; /* or not, buffer incomplete, so copy to private buffer... */
454 mst->cb (mst->cb_cls, hdr);
460 /* need to copy to private buffer to align;
461 * yes, we go a bit more spagetti than usual here */
467 if (size + mst->pos > mst->curr_buf)
469 mst->hdr = realloc (mst->hdr, size + mst->pos);
470 if (NULL == mst->hdr)
472 fprintf (stderr, "Failed to allocate buffer for alignment\n");
475 ibuf = (char *) mst->hdr;
476 mst->curr_buf = size + mst->pos;
478 if (mst->pos + size > mst->curr_buf)
481 "Assertion failed\n");
484 memcpy (&ibuf[mst->pos], buf, size);
491 * Destroys a tokenizer.
493 * @param mst tokenizer to destroy
496 mst_destroy (struct MessageStreamTokenizer *mst)
503 * Calculate crc32, the start of the calculation
505 * @param buf buffer to calc the crc
506 * @param len len of the buffer
510 calc_crc_osdep (const unsigned char *buf, size_t len)
512 static const unsigned long int crc_tbl_osdep[256] = {
513 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
514 0xE963A535, 0x9E6495A3,
515 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD,
516 0xE7B82D07, 0x90BF1D91,
517 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB,
518 0xF4D4B551, 0x83D385C7,
519 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
520 0xFA0F3D63, 0x8D080DF5,
521 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447,
522 0xD20D85FD, 0xA50AB56B,
523 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75,
524 0xDCD60DCF, 0xABD13D59,
525 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
526 0xCFBA9599, 0xB8BDA50F,
527 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11,
528 0xC1611DAB, 0xB6662D3D,
529 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
530 0x9FBFE4A5, 0xE8B8D433,
531 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
532 0x91646C97, 0xE6635C01,
533 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B,
534 0x8208F4C1, 0xF50FC457,
535 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49,
536 0x8CD37CF3, 0xFBD44C65,
537 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
538 0xA4D1C46D, 0xD3D6F4FB,
539 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5,
540 0xAA0A4C5F, 0xDD0D7CC9,
541 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3,
542 0xB966D409, 0xCE61E49F,
543 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
544 0xB7BD5C3B, 0xC0BA6CAD,
545 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF,
546 0x04DB2615, 0x73DC1683,
547 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D,
548 0x0A00AE27, 0x7D079EB1,
549 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
550 0x196C3671, 0x6E6B06E7,
551 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9,
552 0x17B7BE43, 0x60B08ED5,
553 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767,
554 0x3FB506DD, 0x48B2364B,
555 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
556 0x316E8EEF, 0x4669BE79,
557 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703,
558 0x220216B9, 0x5505262F,
559 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31,
560 0x2CD99E8B, 0x5BDEAE1D,
561 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
562 0x72076785, 0x05005713,
563 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D,
564 0x7CDCEFB7, 0x0BDBDF21,
565 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B,
566 0x6FB077E1, 0x18B74777,
567 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
568 0x616BFFD3, 0x166CCF45,
569 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7,
570 0x4969474D, 0x3E6E77DB,
571 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5,
572 0x47B2CF7F, 0x30B5FFE9,
573 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
574 0x54DE5729, 0x23D967BF,
575 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1,
576 0x5A05DF1B, 0x2D02EF8D
579 unsigned long crc = 0xFFFFFFFF;
581 for (; len > 0; len--, buf++)
582 crc = crc_tbl_osdep[(crc ^ *buf) & 0xFF] ^ (crc >> 8);
588 * Calculate and check crc of the bluetooth packet
590 * @param buf buffer of the packet, with len + 4 bytes of data,
591 * the last 4 bytes being the checksum
592 * @param len length of the payload in data
593 * @return 0 on success (checksum matches), 1 on error
596 check_crc_buf_osdep (const unsigned char *buf, size_t len)
600 crc = calc_crc_osdep (buf, len);
602 if (((crc) & 0xFF) == buf[0] && ((crc >> 8) & 0xFF) == buf[1] &&
603 ((crc >> 16) & 0xFF) == buf[2] && ((crc >> 24) & 0xFF) == buf[3])
610 /* ************** end of clone ***************** */
614 * Function used to get the code of last error and to print the type of error.
619 LPVOID lpMsgBuf = NULL;
621 if (FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
622 NULL, GetLastError(), 0, (LPTSTR) &lpMsgBuf, 0, NULL))
623 fprintf (stderr, "%s\n", (char *)lpMsgBuf);
625 fprintf (stderr, "Failed to format the message for the last error! Error number : %d\n", GetLastError());
629 * Function used to initialize the Windows Sockets
632 initialize_windows_sockets()
635 WORD wVersionRequested = MAKEWORD (2, 0);
636 if (WSAStartup (wVersionRequested, &wsaData) != NO_ERROR)
638 fprintf (stderr , "Error initializing window sockets!\n");
645 * Function used to convert the GUID.
646 * @param bytes the GUID represented as a char array
647 * @param uuid pointer to the GUID
650 convert_guid(char *bytes, GUID * uuid)
653 uuid->Data1 = ((bytes[0] << 24) & 0xff000000) | ((bytes[1] << 16) & 0x00ff0000) | ((bytes[2] << 8) & 0x0000ff00) | (bytes[3] & 0x000000ff);
654 uuid->Data2 = ((bytes[4] << 8) & 0xff00) | (bytes[5] & 0x00ff);
655 uuid->Data3 = ((bytes[6] << 8) & 0xff00) | (bytes[7] & 0x00ff);
657 for (i = 0; i < 8; i++)
659 uuid->Data4[i] = bytes[i + 8];
666 * Function for assigning a port number
668 * @param socket the socket used to bind
669 * @param addr pointer to the rfcomm address
670 * @return 0 on success
673 bind_socket (int socket, struct sockaddr_rc *addr)
677 /* Bind every possible port (from 0 to 30) and stop when binding doesn't fail */
678 //FIXME : it should start from port 1, but on my computer it doesn't work :)
679 for (port = 3; port <= 30; port++)
681 addr->rc_channel = port;
682 status = bind (socket, (struct sockaddr *) addr, sizeof (struct sockaddr_rc));
693 * Function used for creating the service record and registering it.
695 * @param dev pointer to the device struct
696 * @return 0 on success
699 register_service (struct HardwareInfos *dev)
701 // advertise the service
702 CSADDR_INFO addr_info;
705 unsigned char uuid[] = GNUNET_BLUETOOTH_SDP_UUID;
707 int addr_len = sizeof (SOCKADDR_BTH);
709 /* get the port on which we are listening on */
710 memset (& addr, 0, sizeof (SOCKADDR_BTH));
711 fd = GNUNET_NETWORK_get_fd (dev->handle);
714 fprintf (stderr, "Failed to get the file descriptor\n");
717 if (SOCKET_ERROR == getsockname (fd, (SOCKADDR*)&addr, &addr_len))
719 fprintf (stderr, "Failed to get the port on which we are listening on: \n");
724 /* save the device address */
725 memcpy (&dev->pl_mac, &addr.btAddr, sizeof (BTH_ADDR));
727 /* set the address information */
728 memset (&addr_info, 0, sizeof (CSADDR_INFO));
729 addr_info.iProtocol = BTHPROTO_RFCOMM;
730 addr_info.iSocketType = SOCK_STREAM;
731 addr_info.LocalAddr.lpSockaddr = (LPSOCKADDR)&addr;
732 addr_info.LocalAddr.iSockaddrLength = sizeof (addr);
733 addr_info.RemoteAddr.lpSockaddr = (LPSOCKADDR)&addr;
734 addr_info.RemoteAddr.iSockaddrLength = sizeof (addr);
736 convert_guid((char *) uuid, &guid);
738 /* register the service */
739 memset (&wqs, 0, sizeof (WSAQUERYSET));
740 wqs.dwSize = sizeof (WSAQUERYSET);
741 wqs.dwNameSpace = NS_BTH;
742 wqs.lpszServiceInstanceName = "GNUnet Bluetooth Service";
743 wqs.lpszComment = "This is the service used by the GNUnnet plugin transport";
744 wqs.lpServiceClassId = &guid;
745 wqs.dwNumberOfCsAddrs = 1;
746 wqs.lpcsaBuffer = &addr_info ;
747 wqs.lpBlob = 0; //FIXME it should be 0 for a new entry
749 if (SOCKET_ERROR == WSASetService (&wqs , RNRSERVICE_REGISTER, 0))
751 fprintf (stderr, "Failed to register the SDP service: ");
757 fprintf (stderr, "The SDP service was registered\n");
764 * Function used for creating the service record and registering it.
766 * @param dev pointer to the device struct
767 * @param rc_channel the rfcomm channel
768 * @return 0 on success
771 register_service (struct HardwareInfos *dev, int rc_channel)
775 * 2. set the service ID, class, profile information
776 * 3. make the service record publicly browsable
777 * 4. register the RFCOMM channel
778 * 5. set the name, provider and description
779 * 6. register the service record to the local SDP server
782 uint8_t svc_uuid_int[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
783 dev->pl_mac.mac[5], dev->pl_mac.mac[4], dev->pl_mac.mac[3],
784 dev->pl_mac.mac[2], dev->pl_mac.mac[1], dev->pl_mac.mac[0]};
785 const char *service_dsc = "Bluetooth plugin services";
786 const char *service_prov = "GNUnet provider";
787 uuid_t root_uuid, rfcomm_uuid, svc_uuid;
788 sdp_list_t *root_list = 0, *rfcomm_list = 0, *proto_list = 0,
789 *access_proto_list = 0, *svc_list = 0;
790 sdp_record_t *record = 0;
791 sdp_data_t *channel = 0;
793 record = sdp_record_alloc();
795 /* Set the general service ID */
796 sdp_uuid128_create (&svc_uuid, &svc_uuid_int);
797 svc_list = sdp_list_append (0, &svc_uuid);
798 sdp_set_service_classes (record, svc_list);
799 sdp_set_service_id (record, svc_uuid);
801 /* Make the service record publicly browsable */
802 sdp_uuid16_create (&root_uuid, PUBLIC_BROWSE_GROUP);
803 root_list = sdp_list_append (0, &root_uuid);
804 sdp_set_browse_groups (record, root_list);
806 /* Register the RFCOMM channel */
807 sdp_uuid16_create (&rfcomm_uuid, RFCOMM_UUID);
808 channel = sdp_data_alloc (SDP_UINT8, &rc_channel);
809 rfcomm_list = sdp_list_append (0, &rfcomm_uuid);
810 sdp_list_append (rfcomm_list, channel);
811 proto_list = sdp_list_append (0, rfcomm_list);
813 /* Set protocol information */
814 access_proto_list = sdp_list_append (0, proto_list);
815 sdp_set_access_protos (record, access_proto_list);
817 /* Set the name, provider, and description */
818 sdp_set_info_attr (record, dev->iface, service_prov, service_dsc);
820 /* Connect to the local SDP server */
821 dev->session = sdp_connect (BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY);
825 fprintf (stderr, "Failed to connect to the SDP server on interface `%.*s': %s\n",
826 IFNAMSIZ, dev->iface, strerror (errno));
831 /* Register the service record */
832 if (sdp_record_register (dev->session, record, 0) < 0)
834 fprintf (stderr, "Failed to register a service record on interface `%.*s': %s\n",
835 IFNAMSIZ, dev->iface, strerror (errno));
841 sdp_data_free (channel);
842 sdp_list_free (root_list, 0);
843 sdp_list_free (rfcomm_list, 0);
844 sdp_list_free (proto_list, 0);
845 sdp_list_free (access_proto_list, 0);
846 sdp_list_free (svc_list, 0);
847 sdp_record_free (record);
855 * Function for searching and browsing for a service. This will return the
856 * port number on which the service is running.
858 * @param dest target address
862 get_channel(const char *dest)
866 DWORD wqs_len = sizeof (WSAQUERYSET);
870 unsigned char uuid[] = GNUNET_BLUETOOTH_SDP_UUID;
871 convert_guid ((char *) uuid, &guid);
873 wqs = (WSAQUERYSET*)malloc (wqs_len);
874 ZeroMemory (wqs, wqs_len);
876 wqs->dwSize = sizeof (WSAQUERYSET) ;
877 wqs->lpServiceClassId = &guid;
878 wqs->dwNameSpace = NS_BTH;
879 wqs->dwNumberOfCsAddrs = 0;
880 wqs->lpszContext = (LPSTR)dest;
882 if (SOCKET_ERROR == WSALookupServiceBegin (wqs, LUP_FLUSHCACHE | LUP_RETURN_ALL, &h))
884 if (GetLastError() == WSASERVICE_NOT_FOUND)
886 fprintf (stderr, "WARNING! The device with address %s wasn't found. Skipping the message!", dest);
891 fprintf (stderr, "Failed to find the port number: ");
898 /* search the sdp service */
901 if (SOCKET_ERROR == WSALookupServiceNext (h, LUP_FLUSHCACHE | LUP_RETURN_ALL, &wqs_len, wqs))
903 int error = WSAGetLastError();
909 //fprintf (stderr, "WSAFAULT error! (the memory allocated wasn't enought\n");
910 wqs = (WSAQUERYSET*)malloc (wqs_len);
913 fprintf (stderr, "Failed! The address was valid but there was no data record of requested type\n");
918 // fprintf (stderr, "No matching service found\n");
921 fprintf (stderr, "Failed to look over the services: ");
923 WSALookupServiceEnd (h);
929 channel = ((SOCKADDR_BTH*)wqs->lpcsaBuffer->RemoteAddr.lpSockaddr)->port;
934 WSALookupServiceEnd (h);
940 * Function used for searching and browsing for a service. This will return the
941 * port number on which the service is running.
943 * @param dev pointer to the device struct
944 * @param dest target address
948 get_channel(struct HardwareInfos *dev, bdaddr_t dest)
951 * 1. detect all nearby devices
952 * 2. for each device:
953 * 2.1. connect to the SDP server running
954 * 2.2. get a list of service records with the specific UUID
955 * 2.3. for each service record get a list of the protocol sequences and get
958 uint8_t svc_uuid_int[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
959 dest.b[5], dest.b[4], dest.b[3],
960 dest.b[2], dest.b[1], dest.b[0]};
961 sdp_session_t *session = 0;
962 sdp_list_t *search_list = 0, *attrid_list = 0, *response_list = 0, *it = 0;
964 uint32_t range = 0x0000ffff;
965 uint8_t channel = -1;
967 /* Connect to the local SDP server */
968 session = sdp_connect (BDADDR_ANY, &dest, 0);
971 fprintf (stderr, "Failed to connect to the SDP server on interface `%.*s': %s\n",
972 IFNAMSIZ, dev->iface, strerror (errno));
977 sdp_uuid128_create (&svc_uuid, &svc_uuid_int);
978 search_list = sdp_list_append (0, &svc_uuid);
979 attrid_list = sdp_list_append (0, &range);
981 if (sdp_service_search_attr_req (session, search_list,
982 SDP_ATTR_REQ_RANGE, attrid_list, &response_list) == 0)
984 for (it = response_list; it; it = it->next)
986 sdp_record_t *record = (sdp_record_t*) it->data;
987 //TODO print some record informations to be sure everything is good
988 sdp_list_t *proto_list = 0;
989 if (sdp_get_access_protos (record, &proto_list) == 0)
991 channel = sdp_get_proto_port (proto_list, RFCOMM_UUID);
992 sdp_list_free (proto_list, 0);
994 sdp_record_free (record);
998 sdp_list_free (search_list, 0);
999 sdp_list_free (attrid_list, 0);
1000 sdp_list_free (response_list, 0);
1002 sdp_close (session);
1005 fprintf (stderr, "Failed to find the listening channel for interface `%.*s': %s\n",
1006 IFNAMSIZ, dev->iface, strerror (errno));
1013 * Read from the socket and put the result into the buffer for transmission to 'stdout'.
1015 * @param sock file descriptor for reading
1016 * @param buf buffer to read to; first bytes will be the 'struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame',
1017 * followed by the actual payload
1018 * @param buf_size size of the buffer
1019 * @param ri where to write radiotap_rx info
1020 * @return number of bytes written to 'buf'
1023 read_from_the_socket (void *sock,
1024 unsigned char *buf, size_t buf_size,
1025 struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *ri)
1027 unsigned char tmpbuf[buf_size];
1031 count = GNUNET_NETWORK_socket_recv ((struct GNUNET_NETWORK_Handle *)sock, tmpbuf, buf_size);
1033 count = read (*((int *)sock), tmpbuf, buf_size);
1038 if (EAGAIN == errno)
1043 fprintf (stderr, "Failed to read from the HCI socket: %s\n", strerror (errno));
1050 /* Get the channel used */ //FIXME probably not needed anymore
1052 struct sockaddr_rc rc_addr = { 0 };
1054 memset (&rc_addr, 0, sizeof (rc_addr));
1055 len = sizeof (rc_addr);
1056 if (0 > getsockname (*((int *)sock), (struct sockaddr *) &rc_addr, (socklen_t *) &len))
1058 fprintf (stderr, "getsockname() call failed : %s\n", strerror (errno));
1062 memset (ri, 0, sizeof (*ri));
1063 ri->ri_channel = rc_addr.rc_channel;
1066 /* Detect CRC32 at the end */
1067 if (0 == check_crc_buf_osdep (tmpbuf, count - sizeof (uint32_t)))
1069 count -= sizeof(uint32_t);
1072 memcpy (buf, tmpbuf, count);
1078 * Open the bluetooth interface for reading/writing
1080 * @param dev pointer to the device struct
1081 * @return 0 on success
1084 open_device (struct HardwareInfos *dev)
1089 /* bind the hci socket to the interface */
1090 addr.addressFamily = AF_BTH;
1092 addr.port = BT_PORT_ANY;
1094 //FIXME flags parameter
1095 if (GNUNET_NETWORK_socket_bind (dev->handle, (const SOCKADDR*)&addr, sizeof (SOCKADDR_BTH), 0) != GNUNET_OK)
1097 fprintf (stderr, "Failed to bind the socket: ");
1098 if (GetLastError() == WSAENETDOWN)
1100 fprintf (stderr, "Please make sure that your Bluetooth device is ON!\n");
1107 /* start listening on the socket */
1108 if (GNUNET_NETWORK_socket_listen (dev->handle, 4) != GNUNET_OK)
1110 fprintf (stderr, "Failed to listen on the socket: ");
1115 /* register the sdp service */
1116 if (register_service(dev) != 0)
1118 fprintf (stderr, "Failed to register a service: ");
1123 int i, dev_id = -1, fd_hci;
1126 struct hci_dev_list_req list;
1127 struct hci_dev_req dev[HCI_MAX_DEV];
1128 } request; //used for detecting the local devices
1129 struct sockaddr_rc rc_addr = { 0 }; //used for binding
1131 /* Initialize the neighbour structure */
1132 neighbours.dev_id = -1;
1133 for (i = 0; i < MAX_PORTS; i++)
1134 neighbours.fds[i] = -1;
1136 /* Open a HCI socket */
1137 fd_hci = socket (AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
1141 fprintf (stderr, "Failed to create HCI socket: %s\n", strerror (errno));
1145 memset (&request, 0, sizeof(request));
1146 request.list.dev_num = HCI_MAX_DEV;
1148 if (ioctl (fd_hci, HCIGETDEVLIST, (void *) &request) < 0)
1150 fprintf (stderr, "ioctl(HCIGETDEVLIST) on interface `%.*s' failed: %s\n",
1151 IFNAMSIZ, dev->iface, strerror (errno));
1155 /* Search for a device with dev->iface name */
1156 for (i = 0; i < request.list.dev_num; i++)
1158 struct hci_dev_info dev_info;
1160 memset (&dev_info, 0, sizeof(struct hci_dev_info));
1161 dev_info.dev_id = request.dev[i].dev_id;
1162 strncpy (dev_info.name, dev->iface, IFNAMSIZ);
1164 if (ioctl (fd_hci, HCIGETDEVINFO, (void *) &dev_info))
1166 fprintf (stderr, "ioctl(HCIGETDEVINFO) on interface `%.*s' failed: %s\n",
1167 IFNAMSIZ, dev->iface, strerror (errno));
1171 if (strcmp (dev_info.name, dev->iface) == 0)
1174 dev_id = dev_info.dev_id; //the device was found
1176 * Copy the MAC address to the device structure
1178 memcpy (&dev->pl_mac, &dev_info.bdaddr, sizeof (bdaddr_t));
1180 /* Check if the interface is up */
1181 if (hci_test_bit (HCI_UP, (void *) &dev_info.flags) == 0)
1183 /* Bring the interface up */
1184 if (ioctl (fd_hci, HCIDEVUP, dev_info.dev_id))
1186 fprintf (stderr, "ioctl(HCIDEVUP) on interface `%.*s' failed: %s\n",
1187 IFNAMSIZ, dev->iface, strerror (errno));
1192 /* Check if the device is discoverable */
1193 if (hci_test_bit (HCI_PSCAN, (void *) &dev_info.flags) == 0 ||
1194 hci_test_bit (HCI_ISCAN, (void *) &dev_info.flags) == 0)
1196 /* Set interface Page Scan and Inqury Scan ON */
1197 struct hci_dev_req dev_req;
1199 memset (&dev_req, 0, sizeof (dev_req));
1200 dev_req.dev_id = dev_info.dev_id;
1201 dev_req.dev_opt = SCAN_PAGE | SCAN_INQUIRY;
1203 if (ioctl (fd_hci, HCISETSCAN, (unsigned long) &dev_req))
1205 fprintf (stderr, "ioctl(HCISETSCAN) on interface `%.*s' failed: %s\n",
1206 IFNAMSIZ, dev->iface, strerror (errno));
1216 /* Check if the interface was not found */
1219 fprintf (stderr, "The interface %s was not found\n", dev->iface);
1223 /* Close the hci socket */
1224 (void) close(fd_hci);
1228 /* Bind the rfcomm socket to the interface */
1229 memset (&rc_addr, 0, sizeof (rc_addr));
1230 rc_addr.rc_family = AF_BLUETOOTH;
1231 rc_addr.rc_bdaddr = *BDADDR_ANY;
1233 if (bind_socket (dev->fd_rfcomm, &rc_addr) != 0)
1235 fprintf (stderr, "Failed to bind interface `%.*s': %s\n", IFNAMSIZ,
1236 dev->iface, strerror (errno));
1240 /* Register a SDP service */
1241 if (register_service (dev, rc_addr.rc_channel) != 0)
1243 fprintf (stderr, "Failed to register a service on interface `%.*s': %s\n", IFNAMSIZ,
1244 dev->iface, strerror (errno));
1248 /* Switch socket in listening mode */
1249 if (listen (dev->fd_rfcomm, 5) == -1) //FIXME: probably we need a bigger number
1251 fprintf (stderr, "Failed to listen on socket for interface `%.*s': %s\n", IFNAMSIZ,
1252 dev->iface, strerror (errno));
1263 * Set the header to sane values to make attacks more difficult
1265 * @param taIeeeHeader pointer to the header of the packet
1266 * @param dev pointer to the Hardware_Infos struct
1268 **** copy from gnunet-helper-transport-wlan.c ****
1271 mac_set (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader,
1272 const struct HardwareInfos *dev)
1274 taIeeeHeader->frame_control = htons (IEEE80211_FC0_TYPE_DATA);
1275 taIeeeHeader->addr3 = mac_bssid_gnunet;
1278 memcpy (&taIeeeHeader->addr2, &dev->pl_mac, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
1280 taIeeeHeader->addr2 = dev->pl_mac;
1286 * Test if the given interface name really corresponds to a bluetooth
1289 * @param iface name of the interface
1290 * @return 0 on success, 1 on error
1291 **** similar with the one from gnunet-helper-transport-wlan.c ****
1294 test_bluetooth_interface (const char *iface)
1300 ret = snprintf (strbuf, sizeof (strbuf),
1301 "/sys/class/bluetooth/%s/subsystem",
1303 if ((ret < 0) || (ret >= sizeof (strbuf)) || (0 != stat (strbuf, &sbuf)))
1306 "Did not find 802.15.1 interface `%s'. Exiting.\n",
1315 * Test incoming packets mac for being our own.
1317 * @param taIeeeHeader buffer of the packet
1318 * @param dev the Hardware_Infos struct
1319 * @return 0 if mac belongs to us, 1 if mac is for another target
1321 **** same as the one from gnunet-helper-transport-wlan.c ****
1324 mac_test (const struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader,
1325 const struct HardwareInfos *dev)
1327 static struct GNUNET_TRANSPORT_WLAN_MacAddress all_zeros;
1329 if ( (0 == memcmp (&taIeeeHeader->addr3, &all_zeros, MAC_ADDR_SIZE)) ||
1330 (0 == memcmp (&taIeeeHeader->addr1, &all_zeros, MAC_ADDR_SIZE)) )
1331 return 0; /* some drivers set no Macs, then assume it is all for us! */
1333 if (0 != memcmp (&taIeeeHeader->addr3, &mac_bssid_gnunet, MAC_ADDR_SIZE))
1334 return 1; /* not a GNUnet ad-hoc package */
1335 if ( (0 == memcmp (&taIeeeHeader->addr1, &dev->pl_mac, MAC_ADDR_SIZE)) ||
1336 (0 == memcmp (&taIeeeHeader->addr1, &bc_all_mac, MAC_ADDR_SIZE)) )
1337 return 0; /* for us, or broadcast */
1338 return 1; /* not for us */
1343 * Process data from the stdin. Takes the message, forces the sender MAC to be correct
1344 * and puts it into our buffer for transmission to the receiver.
1346 * @param cls pointer to the device struct ('struct HardwareInfos*')
1347 * @param hdr pointer to the start of the packet
1349 **** same as the one from gnunet-helper-transport-wlan.c ****
1352 stdin_send_hw (void *cls, const struct GNUNET_MessageHeader *hdr)
1354 struct HardwareInfos *dev = cls;
1355 const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header;
1356 struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *blueheader;
1359 sendsize = ntohs (hdr->size);
1361 sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage)) ||
1362 (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER != ntohs (hdr->type)) )
1364 fprintf (stderr, "Received malformed message\n");
1367 sendsize -= (sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) -
1368 sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame));
1369 if (MAXLINE < sendsize)
1371 fprintf (stderr, "Packet too big for buffer\n");
1374 header = (const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) hdr;
1375 memcpy (&write_pout.buf, &header->frame, sendsize);
1376 blueheader = (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *) &write_pout.buf;
1378 /* payload contains MAC address, but we don't trust it, so we'll
1379 * overwrite it with OUR MAC address to prevent mischief */
1380 mac_set (blueheader, dev);
1381 memcpy (&blueheader->addr1, &header->frame.addr1,
1382 sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
1383 write_pout.size = sendsize;
1388 * Broadcast a HELLO message for peer discovery
1390 * @param dev pointer to the device struct
1391 * @param dev pointer to the socket which was added to the set
1392 * @return 0 on success
1395 send_broadcast (struct HardwareInfos *dev, int *sendsocket)
1401 if ((neighbours.size == neighbours.pos && new_device == 1) || neighbours.size == 0)
1403 inquiry_devices: //skip the conditions and force a inquiry for new devices
1406 * It means that I sent HELLO messages to all the devices from the list and I should search
1407 * for new ones or that this is the first time when I do a search.
1409 inquiry_info *devices = NULL;
1410 int i, responses, max_responses = MAX_PORTS;
1413 if (neighbours.size >= MAX_PORTS)
1415 fprintf (stderr, "%.*s reached the top limit for the discovarable devices\n", IFNAMSIZ, dev->iface);
1419 /* Get the device id */
1420 if (neighbours.dev_id == -1)
1422 char addr[19] = { 0 }; //the device MAC address
1424 ba2str ((bdaddr_t *) &dev->pl_mac, addr);
1425 neighbours.dev_id = hci_devid (addr);
1426 if (neighbours.dev_id < 0)
1428 fprintf (stderr, "Failed to get the device id for interface %.*s : %s\n", IFNAMSIZ,
1429 dev->iface, strerror (errno));
1434 devices = malloc (max_responses * sizeof (inquiry_info));
1435 if (devices == NULL)
1437 fprintf (stderr, "Failed to allocate memory for inquiry info list on interface %.*s\n", IFNAMSIZ,
1442 responses = hci_inquiry (neighbours.dev_id, 8, max_responses, NULL, &devices, IREQ_CACHE_FLUSH);
1445 fprintf (stderr, "Failed to inquiry on interface %.*s\n", IFNAMSIZ, dev->iface);
1449 fprintf (stderr, "LOG : Found %d devices\n", responses); //FIXME delete it after debugging stage
1453 fprintf (stderr, "LOG : No devices discoverable\n");
1457 for (i = 0; i < responses; i++)
1465 fprintf (stderr, "%.*s reached the top limit for the discoverable devices (after inquiry)\n", IFNAMSIZ,
1470 /* Search if the address already exists on the list */
1471 for (j = 0; j < neighbours.size; j++)
1473 if (memcmp (&(devices + i)->bdaddr, &(neighbours.devices[j]), sizeof (bdaddr_t)) == 0)
1476 fprintf (stderr, "LOG : the device already exists on the list\n"); //FIXME debugging message
1483 char addr[19] = { 0 };
1485 ba2str (&(devices +i)->bdaddr, addr);
1486 fprintf (stderr, "LOG : %s was added to the list\n", addr); //FIXME debugging message
1487 memcpy (&(neighbours.devices[neighbours.size++]), &(devices + i)->bdaddr, sizeof (bdaddr_t));
1495 int connection_successful = 0;
1496 struct sockaddr_rc addr_rc = { 0 };
1498 addr_rc.rc_family = AF_BLUETOOTH;
1500 /* Try to connect to a new device from the list */
1501 while (neighbours.pos < neighbours.size)
1503 /* Check if we are already connected to this device */
1504 if (neighbours.fds[neighbours.pos] == -1)
1507 memset (&addr_rc.rc_bdaddr, 0, sizeof (addr_rc.rc_bdaddr));
1508 memcpy (&addr_rc.rc_bdaddr, &(neighbours.devices[neighbours.pos]), sizeof (addr_rc.rc_bdaddr));
1510 addr_rc.rc_channel = get_channel (dev, addr_rc.rc_bdaddr);
1512 *sendsocket = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
1513 if (connect (*sendsocket, (struct sockaddr *)&addr_rc, sizeof (addr_rc)) == 0)
1515 neighbours.fds[neighbours.pos++] = *sendsocket;
1516 connection_successful = 1;
1517 char addr[19] = { 0 };
1518 ba2str (&(neighbours.devices[neighbours.pos - 1]), addr);
1519 fprintf (stderr, "LOG : Connected to %s\n", addr);
1525 char addr[19] = { 0 };
1526 errno_copy = errno; //Save a copy for later
1527 ba2str (&(neighbours.devices[neighbours.pos]), addr);
1528 fprintf (stderr, "LOG : Couldn't connect on device %s, error : %s\n", addr, strerror(errno));
1529 if (errno != ECONNREFUSED) //FIXME be sure that this works
1531 fprintf (stderr, "LOG : Removes %d device from the list\n", neighbours.pos);
1532 /* Remove the device from the list */
1533 memcpy (&neighbours.devices[neighbours.pos], &neighbours.devices[neighbours.size - 1], sizeof (bdaddr_t));
1534 memset (&neighbours.devices[neighbours.size - 1], 0, sizeof (bdaddr_t));
1535 neighbours.fds[neighbours.pos] = neighbours.fds[neighbours.size - 1];
1536 neighbours.fds[neighbours.size - 1] = -1;
1537 neighbours.size -= 1;
1540 neighbours.pos += 1;
1542 if (neighbours.pos >= neighbours.size)
1547 if (loops == MAX_LOOPS) //don't get stuck trying to connect to one device
1553 fprintf (stderr, "LOG : Search for a new device\n"); //FIXME debugging message
1554 neighbours.pos += 1;
1558 /* Cycle on the list */
1559 if (neighbours.pos == neighbours.size)
1562 searching_devices_count += 1;
1564 if (searching_devices_count == MAX_LOOPS)
1566 fprintf (stderr, "LOG : Force to inquiry for new devices\n");
1567 searching_devices_count = 0;
1568 goto inquiry_devices;
1571 /* If a new device wasn't found, search an old one */
1572 if (connection_successful == 0)
1574 int loop_check = neighbours.pos;
1575 while (neighbours.fds[neighbours.pos] == -1)
1577 if (neighbours.pos == neighbours.size)
1580 if (neighbours.pos == loop_check)
1582 if (errno_copy == ECONNREFUSED)
1584 fprintf (stderr, "LOG : No device found. Go back and search again\n"); //FIXME debugging message
1587 goto search_for_devices;
1591 return 1; // Skip the broadcast message
1595 neighbours.pos += 1;
1598 *sendsocket = neighbours.fds[neighbours.pos++];
1606 * Main function of the helper. This code accesses a bluetooth interface
1607 * forwards traffic in both directions between the bluetooth interface and
1608 * stdin/stdout of this process. Error messages are written to stderr.
1610 * @param argc number of arguments, must be 2
1611 * @param argv arguments only argument is the name of the interface (i.e. 'hci0')
1612 * @return 0 on success (never happens, as we don't return unless aborted), 1 on error
1614 **** similar to gnunet-helper-transport-wlan.c ****
1617 main (int argc, char *argv[])
1620 struct HardwareInfos dev;
1621 char readbuf[MAXLINE];
1626 struct MessageStreamTokenizer *stdin_mst;
1629 int crt_rfds = 0, rfds_list[MAX_PORTS];
1630 int broadcast, sendsocket;
1631 /* Assert privs so we can modify the firewall rules! */
1633 #ifdef HAVE_SETRESUID
1634 if (0 != setresuid (uid, 0, 0))
1636 fprintf (stderr, "Failed to setresuid to root: %s\n", strerror (errno));
1640 if (0 != seteuid (0))
1642 fprintf (stderr, "Failed to seteuid back to root: %s\n", strerror (errno));
1647 /* Make use of SGID capabilities on POSIX */
1648 memset (&dev, 0, sizeof (dev));
1649 dev.fd_rfcomm = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
1650 raw_eno = errno; /* remember for later */
1652 /* Now that we've dropped root rights, we can do error checking */
1655 fprintf (stderr, "You must specify the name of the interface as the first \
1656 and only argument to this program.\n");
1657 if (-1 != dev.fd_rfcomm)
1658 (void) close (dev.fd_rfcomm);
1662 if (-1 == dev.fd_rfcomm)
1664 fprintf (stderr, "Failed to create a HCI socket: %s\n", strerror (raw_eno));
1667 if (dev.fd_rfcomm >= FD_SETSIZE)
1669 fprintf (stderr, "File descriptor too large for select (%d > %d)\n",
1670 dev.fd_rfcomm, FD_SETSIZE);
1671 (void) close (dev.fd_rfcomm);
1674 if (0 != test_bluetooth_interface (argv[1]))
1676 (void) close (dev.fd_rfcomm);
1679 strncpy (dev.iface, argv[1], IFNAMSIZ);
1680 if (0 != open_device (&dev))
1682 (void) close (dev.fd_rfcomm);
1688 uid_t uid = getuid ();
1689 #ifdef HAVE_SETRESUID
1690 if (0 != setresuid (uid, uid, uid))
1692 fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno));
1693 if (-1 != dev.fd_rfcomm)
1694 (void) close (dev.fd_rfcomm);
1698 if (0 != (setuid (uid) | seteuid (uid)))
1700 fprintf (stderr, "Failed to setuid: %s\n", strerror (errno));
1701 if (-1 != dev.fd_rfcomm)
1702 (void) close (dev.fd_rfcomm);
1708 /* Send MAC address of the bluetooth interface to STDOUT first */
1710 struct GNUNET_TRANSPORT_WLAN_HelperControlMessage macmsg;
1712 macmsg.hdr.size = htons (sizeof (macmsg));
1713 macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL);
1714 memcpy (&macmsg.mac, &dev.pl_mac, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
1715 memcpy (write_std.buf, &macmsg, sizeof (macmsg));
1716 write_std.size = sizeof (macmsg);
1720 stdin_mst = mst_create (&stdin_send_hw, &dev);
1723 fprintf (stderr, "\n-----------------------------------------------\n Check if the program exits\n-----------------------------------------------\n");
1725 * TODO : When a connection fails I should ignore only the CONTROL messages.
1726 * For DATA messages I should retry to send the message until it doesn't fail
1727 * Also I should make the time out of a mac endpoint smaller and check if the rate
1728 * from get_wlan_header (plugin_transport_bluetooth.c) is correct.
1737 if ((0 == write_pout.size) && (1 == stdin_open))
1739 FD_SET (STDIN_FILENO, &rfds);
1740 maxfd = MAX (maxfd, STDIN_FILENO);
1742 if (0 == write_std.size)
1744 FD_SET (dev.fd_rfcomm, &rfds);
1745 maxfd = MAX (maxfd, dev.fd_rfcomm);
1748 for (i = 0; i < crt_rfds; i++) // it can receive messages from multiple devices
1750 FD_SET (rfds_list[i], &rfds);
1751 maxfd = MAX (maxfd, rfds_list[i]);
1754 if (0 < write_std.size)
1756 FD_SET (STDOUT_FILENO, &wfds);
1757 maxfd = MAX (maxfd, STDOUT_FILENO);
1759 if (0 < write_pout.size) //it can send messages only to one device per loop
1761 struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *frame;
1762 /* Get the destination address */
1763 frame = (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *) write_pout.buf;
1765 if (memcmp (&frame->addr1, &dev.pl_mac,
1766 sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)
1769 memset (&write_pout, 0, sizeof (write_pout)); //clear the buffer
1771 else if (memcmp (&frame->addr1, &broadcast_address,
1772 sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)
1774 fprintf (stderr, "LOG : %s has a broadcast message (pos %d, size %d)\n", dev.iface, neighbours.pos, neighbours.size); //FIXME: debugging message
1775 // broadcast = 1; // IF I HAVE A BROADCAST MESSAGE I skip.
1776 // memset (&write_pout, 0, sizeof (write_pout));
1778 if (send_broadcast(&dev, &sendsocket) != 0) //if the searching wasn't successful don't get stuck on the select stage
1781 memset (&write_pout, 0, sizeof (write_pout)); //remove the message
1782 fprintf (stderr, "LOG : Skip the broadcast message (pos %d, size %d)\n", neighbours.pos, neighbours.size);
1786 FD_SET (sendsocket, &wfds);
1787 maxfd = MAX (maxfd, sendsocket);
1794 /* Search if the address already exists on the list */
1795 for (i = 0; i < neighbours.size; i++)
1797 if (memcmp (&frame->addr1, &(neighbours.devices[i]), sizeof (bdaddr_t)) == 0)
1800 if (neighbours.fds[i] != -1)
1802 found = 1; //save the position where it was found
1803 FD_SET (neighbours.fds[i], &wfds);
1804 maxfd = MAX (maxfd, neighbours.fds[i]);
1805 sendsocket = neighbours.fds[i];
1806 fprintf (stderr, "LOG: the address was found in the list\n");
1814 struct sockaddr_rc addr = { 0 };
1816 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,
1817 frame->addr1.mac[5], frame->addr1.mac[4], frame->addr1.mac[3],
1818 frame->addr1.mac[2], frame->addr1.mac[1], frame->addr1.mac[0]); //FIXME: debugging message
1820 sendsocket = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
1824 fprintf (stderr, "Failed to create a RFCOMM socket (sending stage): %s\n",
1829 memcpy (&addr.rc_bdaddr, &frame->addr1, sizeof (bdaddr_t));
1830 addr.rc_family = AF_BLUETOOTH;
1831 addr.rc_channel = get_channel (&dev, addr.rc_bdaddr);
1835 status = connect (sendsocket, (struct sockaddr *) &addr, sizeof (addr));
1836 if (0 != status && errno != EAGAIN)
1838 if (errno == ECONNREFUSED && tries < 2)
1840 fprintf (stderr, "LOG : %.*s failed to connect. Trying again!\n", IFNAMSIZ, dev.iface);
1844 else if (errno == EBADF)
1846 fprintf (stderr, "LOG : %s failed to connect : %s. Skip it!\n", dev.iface, strerror (errno));
1847 memset (&write_pout, 0, sizeof (write_pout));
1852 fprintf (stderr, "LOG : %s failed to connect : %s. Try again later!\n", dev.iface, strerror (errno));
1853 memset (&write_pout, 0, sizeof (write_pout));
1860 FD_SET (sendsocket, &wfds);
1861 maxfd = MAX (maxfd, sendsocket);
1862 fprintf (stderr, "LOG : Connection successful\n");
1863 if (pos != 0) // save the socket
1865 neighbours.fds[pos] = sendsocket;
1869 /* Add the new device to the discovered devices list */
1870 if (neighbours.size < MAX_PORTS)
1872 neighbours.fds[neighbours.size] = sendsocket;
1873 memcpy (&(neighbours.devices[neighbours.size++]), &addr.rc_bdaddr, sizeof (bdaddr_t));
1877 fprintf (stderr, "The top limit for the discovarable devices' list was reached\n");
1887 /* Select a fd which is ready for action :) */
1889 int retval = select (maxfd + 1, &rfds, &wfds, NULL, NULL);
1890 if ((-1 == retval) && (EINTR == errno))
1892 if (0 > retval && errno != EBADF) // we handle BADF errors later
1894 fprintf (stderr, "select failed: %s\n", strerror (errno));
1898 if (FD_ISSET (STDOUT_FILENO , &wfds))
1901 write (STDOUT_FILENO, write_std.buf + write_std.pos,
1902 write_std.size - write_std.pos);
1905 fprintf (stderr, "Failed to write to STDOUT: %s\n", strerror (errno));
1908 write_std.pos += ret;
1909 if (write_std.pos == write_std.size)
1914 fprintf (stderr, "LOG : %s sends a message to STDOUT\n", dev.iface); //FIXME: debugging message
1917 if (sendsocket != -1)
1919 if (FD_ISSET (sendsocket , &wfds))
1922 write (sendsocket, write_pout.buf + write_std.pos,
1923 write_pout.size - write_pout.pos);
1924 if (0 > ret) //FIXME should I first check the error type?
1926 fprintf (stderr, "Failed to write to bluetooth device: %s. Closing the socket!\n",
1928 for (i = 0; i < neighbours.size; i++)
1930 if (neighbours.fds[i] == sendsocket)
1932 (void) close(sendsocket);
1933 neighbours.fds[i] = -1;
1937 /* Remove the message */
1938 memset (&write_pout.buf + write_std.pos, 0, (write_pout.size - write_pout.pos));
1939 write_pout.pos = 0 ;
1940 write_pout.size = 0;
1944 write_pout.pos += ret;
1945 if ((write_pout.pos != write_pout.size) && (0 != ret))
1947 /* We should not get partial sends with packet-oriented devices... */
1948 fprintf (stderr, "Write error, partial send: %u/%u\n",
1949 (unsigned int) write_pout.pos,
1950 (unsigned int) write_pout.size);
1954 if (write_pout.pos == write_pout.size)
1957 write_pout.size = 0;
1959 fprintf (stderr, "LOG : %s sends a message to a DEVICE\n", dev.iface); //FIXME: debugging message
1963 for (i = 0; i <= maxfd; i++)
1965 if (FD_ISSET (i, &rfds))
1967 if (i == STDIN_FILENO)
1970 read (i, readbuf, sizeof (readbuf));
1973 fprintf (stderr, "Read error from STDIN: %s\n", strerror (errno));
1978 /* stop reading... */
1983 mst_receive (stdin_mst, readbuf, ret);
1984 fprintf (stderr, "LOG : %s receives a message from STDIN\n", dev.iface); //FIXME: debugging message
1987 else if (i == dev.fd_rfcomm)
1990 struct sockaddr_rc addr = { 0 };
1991 unsigned int opt = sizeof (addr);
1993 readsocket = accept (dev.fd_rfcomm, (struct sockaddr *) &addr, &opt);
1994 fprintf(stderr, "LOG : %s accepts a message\n", dev.iface); //FIXME: debugging message
1995 if (readsocket == -1)
1997 fprintf (stderr, "Failed to accept a connection on interface: %.*s\n", IFNAMSIZ,
2003 FD_SET (readsocket, &rfds);
2004 maxfd = MAX (maxfd, readsocket);
2006 if (crt_rfds < MAX_PORTS)
2007 rfds_list[crt_rfds++] = readsocket;
2010 fprintf (stderr, "The limit for the read file descriptors list was \
2019 struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm;
2021 fprintf (stderr, "LOG : %s reads something from the socket\n", dev.iface);//FIXME : debugging message
2022 rrm = (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) write_std.buf;
2024 read_from_the_socket ((void *)&i, (unsigned char *) &rrm->frame,
2025 sizeof (write_std.buf)
2026 - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
2027 + sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame),
2034 /* Remove the socket from the list */
2035 for (j = 0; j < crt_rfds; j++)
2037 if (rfds_list[j] == i)
2039 rfds_list[j] ^= rfds_list[crt_rfds - 1];
2040 rfds_list[crt_rfds - 1] ^= rfds_list[j];
2041 rfds_list[j] ^= rfds_list[crt_rfds - 1];
2047 fprintf (stderr, "Read error from raw socket: %s\n", strerror (errno));
2050 if ((0 < ret) && (0 == mac_test (&rrm->frame, &dev)))
2052 write_std.size = ret
2053 + sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
2054 - sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame);
2055 rrm->header.size = htons (write_std.size);
2056 rrm->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER);
2063 /* Error handling, try to clean up a bit at least */
2064 mst_destroy (stdin_mst);
2066 sdp_close (dev.session);
2067 (void) close (dev.fd_rfcomm);
2068 (void) close (sendsocket);
2070 for (i = 0; i < crt_rfds; i++)
2071 (void) close (rfds_list[i]);
2073 for (i = 0; i < neighbours.size; i++)
2074 (void) close (neighbours.fds[i]);
2076 struct HardwareInfos dev;
2077 struct GNUNET_NETWORK_Handle *sendsocket;
2078 struct GNUNET_NETWORK_FDSet *rfds;
2079 struct GNUNET_NETWORK_FDSet *wfds;
2080 struct GNUNET_NETWORK_Handle *rfds_list[MAX_PORTS];
2081 char readbuf[MAXLINE] = { 0 };
2082 SOCKADDR_BTH acc_addr = { 0 };
2083 int addr_len = sizeof (SOCKADDR_BTH);
2084 int broadcast, i, stdin_open, crt_rfds = 0;
2085 HANDLE stdin_handle = GetStdHandle (STD_INPUT_HANDLE);
2086 HANDLE stdout_handle = GetStdHandle (STD_OUTPUT_HANDLE);
2087 struct MessageStreamTokenizer *stdin_mst;
2089 /* check the handles */
2090 if (stdin_handle == INVALID_HANDLE_VALUE)
2092 fprintf (stderr, "Failed to get the stdin handle\n");
2096 if (stdout_handle == INVALID_HANDLE_VALUE)
2098 fprintf (stderr, "Failed to get the stdout handle\n");
2102 /* initialize windows sockets */
2103 initialize_windows_sockets();
2105 // /* test bluetooth socket family support */ --> it return false because the GNUNET_NETWORK_test_pf should also receive the type of socket (BTHPROTO_RFCOMM)
2106 // if (GNUNET_NETWORK_test_pf (AF_BTH) != GNUNET_OK)
2108 // fprintf (stderr, "AF_BTH family is not supported\n");
2112 /* create the socket */
2113 dev.handle = GNUNET_NETWORK_socket_create (AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
2114 if (dev.handle == NULL)
2116 fprintf (stderr, "Failed to create RFCOMM socket: ");
2122 if (open_device (&dev) == -1)
2124 fprintf (stderr, "Failed to open the device\n");
2126 if (GNUNET_NETWORK_socket_close (dev.handle) != GNUNET_OK)
2128 fprintf (stderr, "Failed to close the socket!\n");
2134 if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking (dev.handle, 1) )
2136 fprintf (stderr, "Failed to change the socket mode\n");
2140 memset (&write_std, 0, sizeof (write_std));
2141 memset (&write_pout, 0, sizeof (write_pout));
2144 rfds = GNUNET_NETWORK_fdset_create ();
2145 wfds = GNUNET_NETWORK_fdset_create ();
2147 /* Send MAC address of the bluetooth interface to STDOUT first */
2149 struct GNUNET_TRANSPORT_WLAN_HelperControlMessage macmsg;
2151 macmsg.hdr.size = htons (sizeof (macmsg));
2152 macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL);
2153 memcpy (&macmsg.mac, &dev.pl_mac, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress_Copy));
2154 memcpy (write_std.buf, &macmsg, sizeof (macmsg));
2155 write_std.size = sizeof (macmsg);
2159 stdin_mst = mst_create (&stdin_send_hw, &dev);
2162 fprintf (stderr, "\n-----------------------------------------------\n Check if the program exits\n-----------------------------------------------\n");
2166 int stdout_pos = -1;
2173 sendsocket = NULL; //FIXME memleaks
2174 fprintf (stderr, "---------------------------------------------------\n");
2176 GNUNET_NETWORK_fdset_zero (rfds);
2177 if ((0 == write_pout.size) && (1 == stdin_open))
2181 fprintf (stderr, "LOG: set STDIN_FILENO\n");
2182 GNUNET_NETWORK_fdset_handle_set (rfds, (struct GNUNET_DISK_FileHandle*) &stdin_handle); //FIXME create a GNUNET_STRUCT handle for stdin
2185 if (0 == write_std.size)
2188 fprintf (stderr, "LOG: set the listening socket %d\n", GNUNET_NETWORK_get_fd (dev.handle));
2189 GNUNET_NETWORK_fdset_set (rfds, dev.handle);
2192 for (i = 0; i < crt_rfds; i++)
2195 fprintf (stderr, "LOG: adding %d read socket\n", i);
2196 GNUNET_NETWORK_fdset_set (rfds, rfds_list[i]);
2199 GNUNET_NETWORK_fdset_zero (wfds);
2200 if (0 < write_std.size)
2203 fprintf (stderr, "LOG: set STDOUT_FILENO\n");
2204 GNUNET_NETWORK_fdset_handle_set (wfds, (struct GNUNET_DISK_FileHandle*) &stdout_handle);
2205 fprintf (stderr, "LOG: after setting STDOUT_FILENO\n");
2206 // printf ("%s\n", write_std.buf);
2207 // memset (write_std.buf, 0, write_std.size);
2208 // write_std.size = 0;
2211 if (0 < write_pout.size)
2213 if (strcmp (argv[1], "ff:ff:ff:ff:ff:ff") == 0) {
2214 fprintf(stderr, "BROADCAST\n");
2217 memset (write_pout.buf, 0, write_pout.size);
2218 write_pout.size = 0;
2223 fprintf (stderr, "LOG : has a new message for %s\n", argv[1]);
2224 sendsocket = GNUNET_NETWORK_socket_create (AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
2226 if (sendsocket == NULL)
2228 fprintf (stderr, "Failed to create RFCOMM socket: \n");
2233 memset (&addr, 0, sizeof (addr));
2234 //addr.addressFamily = AF_BTH;
2236 WSAStringToAddress (argv[1], AF_BTH, NULL, (LPSOCKADDR) &addr, &addr_len))
2238 fprintf (stderr, "Failed to translate the address: ");
2242 addr.port = get_channel (argv[1]); //crapa aici
2243 if (addr.port == -1)
2245 fprintf (stderr, "Couldn't find the sdp service for the address: %s\n", argv[1]);
2246 memset (write_pout.buf, 0, write_pout.size);
2247 write_pout.size = 0;
2248 broadcast = 1; //skipping the select part
2252 fprintf (stderr, "got the channel %d\n", addr.port);
2254 if (GNUNET_OK != GNUNET_NETWORK_socket_connect (sendsocket, (LPSOCKADDR)&addr, addr_len))
2256 fprintf (stderr, "Failed to connect: ");
2261 if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking (sendsocket, 1) )
2263 fprintf (stderr, "Failed to change the socket mode\n");
2267 GNUNET_NETWORK_fdset_set (wfds, sendsocket);
2274 fprintf (stderr, "before select\n");
2275 int retval = GNUNET_NETWORK_socket_select (rfds, wfds, NULL, GNUNET_TIME_relative_get_forever_());
2276 fprintf (stderr, "after select %d\n", retval);
2279 fprintf (stderr, "select error\n");
2282 //if (GNUNET_NETWORK_fdset_isset (wfds, (struct GNUNET_NETWORK_Handle*)&stdout_handle))
2283 if (retval == stdout_pos)
2285 fprintf (stderr, "-------------STDOUT------------\n");
2286 fprintf(stderr, "LOG : sends a message to STDOUT\n"); //FIXME: debugging message
2288 //ret = GNUNET_NETWORK_socket_send ((struct GNUNET_NETWORK_Handle *)&stdout_handle, write_std.buf + write_std.pos, write_std.size - write_std.pos);
2289 //ret = write (STDOUT_FILENO, write_std.buf + write_std.pos, write_std.size - write_std.pos);
2291 if (FALSE == WriteFile (stdout_handle, write_std.buf + write_std.pos, write_std.size - write_std.pos, &ret, NULL))
2293 fprintf (stderr, "Failed to write to STDOUT: ");
2297 fprintf (stderr, "--->sended: %d\n", ret);
2301 fprintf (stderr, "Failed to write to STDOUT\n");
2305 write_std.pos += ret;
2306 if (write_std.pos == write_std.size)
2312 if (sendsocket != NULL)
2314 if (GNUNET_NETWORK_fdset_isset (wfds, sendsocket))
2316 fprintf (stderr, "-------------SEND------------\n");
2318 ret = GNUNET_NETWORK_socket_send (sendsocket, write_pout.buf + write_pout.pos,
2319 write_pout.size - write_pout.pos);
2321 if (GNUNET_SYSERR == ret)
2323 fprintf (stderr, "Failed to send to the socket. Closing the socket. Error: \n");
2325 if (GNUNET_NETWORK_socket_close (sendsocket) != GNUNET_OK)
2327 fprintf (stderr, "Failed to close the sendsocket!\n");
2335 write_pout.pos += ret;
2336 if ((write_pout.pos != write_pout.size) && (0 != ret))
2338 /* we should not get partial sends with packet-oriented devices... */
2339 fprintf (stderr, "Write error, partial send: %u/%u\n",
2340 (unsigned int) write_pout.pos,
2341 (unsigned int) write_pout.size);
2345 if (write_pout.pos == write_pout.size)
2348 write_pout.size = 0;
2351 fprintf(stderr, "LOG : sends a message to a DEVICE\n"); //FIXME: debugging message
2356 //if (GNUNET_NETWORK_fdset_isset (rfds, (struct GNUNET_NETWORK_Handle*)&stdin_handle))
2357 if (retval == stdin_pos) //FALSEEE!!!! NUUUUU EEE VOOIEE!!_----------------------------------------------------------?
2359 fprintf (stderr, "-------------STDIN------------\n");
2361 //ret = GNUNET_NETWORK_socket_recv ((struct GNUNET_NETWORK_Handle *)&stdin_handle, readbuf, sizeof (write_pout.buf));
2362 //ret = read (STDIN_FILENO, readbuf, sizeof (readbuf));
2364 if (FALSE == ReadFile (stdin_handle, readbuf, sizeof (readbuf), &ret, NULL)) /* do nothing asynchronous */
2366 fprintf (stderr, "Read error from STDIN: ");
2372 /* stop reading... */
2375 mst_receive (stdin_mst, readbuf, ret);
2376 fprintf (stderr, "LOG : receives a message from STDIN\n"); //FIXME: debugging message
2380 if (GNUNET_NETWORK_fdset_isset (rfds, dev.handle))
2382 fprintf (stderr, "-------------ACCEPT------------\n");
2383 fprintf (stderr, "LOG: accepting connection\n");
2384 struct GNUNET_NETWORK_Handle *readsocket;
2385 readsocket = GNUNET_NETWORK_socket_accept (dev.handle, (LPSOCKADDR)&acc_addr, &addr_len);
2386 if (readsocket == NULL)
2388 fprintf (stderr, "Accept error %d: ", GetLastError());
2394 if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking (readsocket, 1) )
2396 fprintf (stderr, "Failed to change the socket mode\n");
2399 GNUNET_NETWORK_fdset_set (rfds, readsocket);
2401 if (crt_rfds < MAX_PORTS)
2402 rfds_list[crt_rfds++] = readsocket;
2405 fprintf (stderr, "The limit for the read file descriptors list was reached\n");
2411 for (i = 0; i < crt_rfds; i++)
2413 if (GNUNET_NETWORK_fdset_isset (rfds, rfds_list[i]))
2415 struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm;
2417 fprintf (stderr, "LOG: reading something from the socket\n");//FIXME : debugging message
2418 rrm = (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) write_std.buf;
2419 ret = read_from_the_socket (rfds_list[i], (unsigned char *) &rrm->frame,
2420 sizeof (write_std.buf)
2421 - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
2422 + sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame),
2424 fprintf (stderr, "MESSAGE: %s\n", readbuf);
2428 //TODO remove the socket from the list
2429 if (GNUNET_NETWORK_socket_close (rfds_list[i]) != GNUNET_OK)
2431 fprintf (stderr, "Failed to close the sendsocket!\n");
2435 fprintf (stderr, "Read error from raw socket: ");
2440 if ((0 < ret) && (0 == mac_test (&rrm->frame, &dev)))
2442 write_std.size = ret
2443 + sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
2444 - sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame);
2445 rrm->header.size = htons (write_std.size);
2446 rrm->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER);
2454 mst_destroy (stdin_mst);
2457 if (GNUNET_NETWORK_socket_close (dev.handle) != GNUNET_OK)
2459 fprintf (stderr, "Failed to close the socket!\n");
2463 for (i = 0; i < crt_rfds; i++)
2465 if (GNUNET_NETWORK_socket_close (rfds_list[i]) != GNUNET_OK)
2467 fprintf (stderr, "Failed to close the socket!\n");
2474 return 1; /* we never exit 'normally' */