src/transport/gnunet-helper-transport-bluetooth.c

   1 /*
   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
   6
   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.
  11
  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.
  16
  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.
  21 */
  22 #include "gnunet_config.h"
  23 #include "plugin_transport_wlan.h"
  24 #include "gnunet_protocols.h"
  25
  26 #ifdef MINGW
  27   #include "platform.h"
  28   #include "gnunet_util_lib.h"
  29   #include <bthdef.h>
  30   #include <ws2bth.h>
  31   #include "gnunet_protocols.h"
  32 #else
  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>
  39   #include <errno.h>
  40   #include <linux/if.h>
  41   #include <stdio.h>
  42   #include <stdlib.h>
  43   #include <sys/ioctl.h>
  44   #include <sys/param.h>
  45   #include <sys/socket.h>
  46   #include <sys/stat.h>
  47   #include <sys/types.h>
  48   #include <unistd.h>
  49 #endif
  50
  51
  52
  53 /**
  54  * Maximum number of ports assignable for RFCOMMM protocol.
  55  */
  56 #define MAX_PORTS 30
  57
  58 /**
  59  * Maximum size of a message allowed in either direction
  60  * (used for our receive and sent buffers).
  61  */
  62 #define MAXLINE 4096
  63
  64
  65 /**
  66  * Maximum number of loops without inquiring for new devices.
  67  */
  68 #define MAX_LOOPS 5
  69
  70 #ifdef MINGW
  71   /* Maximum size of the interface's name */
  72   #define IFNAMSIZ 16
  73
  74   #ifndef NS_BTH
  75     #define NS_BTH 16
  76   #endif
  77   /**
  78    * A copy of the MAC Address.
  79    */
  80   struct GNUNET_TRANSPORT_WLAN_MacAddress_Copy
  81   {
  82     UINT8 mac[MAC_ADDR_SIZE];
  83   };
  84
  85   // {31191E56-FA7E-4517-870E-71B86BBCC52F}
  86   #define GNUNET_BLUETOOTH_SDP_UUID \
  87     { \
  88       0x31, 0x19, 0x1E, 0x56, \
  89       0xFA, 0x7E, \
  90       0x45, 0x17, \
  91       0x87, 0x0E, \
  92       0x71, 0xB8, 0x6B, 0xBC, 0xC5, 0x2F \
  93     }
  94 #endif
  95
  96 /**
  97  * struct for storing the information of the hardware.  There is only
  98  * one of these.
  99  */
 100 struct HardwareInfos
 101 {
 102   /**
 103    * Name of the interface, not necessarily 0-terminated (!).
 104    */
 105   char iface[IFNAMSIZ];
 106
 107  #ifdef MINGW
 108   /**
 109    * socket handle
 110    */
 111   struct GNUNET_NETWORK_Handle *handle;
 112
 113   /**
 114    * MAC address of our own bluetooth interface.
 115    */
 116   struct GNUNET_TRANSPORT_WLAN_MacAddress_Copy pl_mac;
 117  #else
 118   /**
 119    * file descriptor for the rfcomm socket
 120    */
 121   int fd_rfcomm;
 122
 123   /**
 124    * MAC address of our own bluetooth interface.
 125    */
 126   struct GNUNET_TRANSPORT_WLAN_MacAddress pl_mac;
 127
 128   /**
 129    * SDP session
 130    */
 131    sdp_session_t *session ;
 132  #endif
 133 };
 134
 135 /**
 136  * IO buffer used for buffering data in transit (to wireless or to stdout).
 137  */
 138 struct SendBuffer
 139 {
 140   /**
 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'.
 143    */
 144   size_t size;
 145
 146   /**
 147    * How many bytes that were stored in 'buf' did we already write to the
 148    * destination?  Always smaller than 'size'.
 149    */
 150   size_t pos;
 151
 152   /**
 153    * Buffered data; twice the maximum allowed message size as we add some
 154    * headers.
 155    */
 156   char buf[MAXLINE * 2];
 157 };
 158
 159 #ifdef LINUX
 160  /**
 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.
 163   */
 164  struct BroadcastMessages
 165  {
 166    /* List with the discoverable devices' addresses */
 167    bdaddr_t devices[MAX_PORTS];
 168
 169    /* List with the open sockets */
 170    int fds[MAX_PORTS];
 171
 172
 173    /* The number of the devices */
 174    int size;
 175
 176    /* The current position */
 177    int pos;
 178
 179    /* The device id */
 180    int dev_id;
 181  };
 182
 183  /**
 184   * Address used to identify the broadcast messages.
 185   */
 186  static struct GNUNET_TRANSPORT_WLAN_MacAddress broadcast_address = {{255, 255, 255, 255, 255, 255}};
 187
 188  /**
 189   * Buffer with the discoverable devices.
 190   */
 191  static struct BroadcastMessages neighbours;
 192
 193  static int searching_devices_count = 0;
 194 #endif
 195
 196 /**
 197  * Buffer for data read from stdin to be transmitted to the bluetooth device
 198  */
 199 static struct SendBuffer write_pout;
 200
 201 /**
 202  * Buffer for data read from the bluetooth device to be transmitted to stdout.
 203  */
 204 static struct SendBuffer write_std;
 205
 206
 207 /* ****** this are the same functions as the ones used in gnunet-helper-transport-wlan.c ****** */
 208
 209 /**
 210  * To what multiple do we align messages?  8 byte should suffice for everyone
 211  * for now.
 212  */
 213 #define ALIGN_FACTOR 8
 214
 215 /**
 216  * Smallest supported message.
 217  */
 218 #define MIN_BUFFER_SIZE sizeof (struct GNUNET_MessageHeader)
 219
 220
 221 /**
 222  * Functions with this signature are called whenever a
 223  * complete message is received by the tokenizer.
 224  *
 225  * @param cls closure
 226  * @param message the actual message
 227  */
 228 typedef void (*MessageTokenizerCallback) (void *cls,
 229             const struct
 230             GNUNET_MessageHeader *
 231             message);
 232
 233 /**
 234  * Handle to a message stream tokenizer.
 235  */
 236 struct MessageStreamTokenizer
 237 {
 238
 239   /**
 240    * Function to call on completed messages.
 241    */
 242   MessageTokenizerCallback cb;
 243
 244   /**
 245    * Closure for cb.
 246    */
 247   void *cb_cls;
 248
 249   /**
 250    * Size of the buffer (starting at 'hdr').
 251    */
 252   size_t curr_buf;
 253
 254   /**
 255    * How many bytes in buffer have we already processed?
 256    */
 257   size_t off;
 258
 259   /**
 260    * How many bytes in buffer are valid right now?
 261    */
 262   size_t pos;
 263
 264   /**
 265    * Beginning of the buffer.  Typed like this to force alignment.
 266    */
 267   struct GNUNET_MessageHeader *hdr;
 268
 269 };
 270
 271
 272 /**
 273  * Create a message stream tokenizer.
 274  *
 275  * @param cb function to call on completed messages
 276  * @param cb_cls closure for cb
 277  * @return handle to tokenizer
 278  */
 279 static struct MessageStreamTokenizer *
 280 mst_create (MessageTokenizerCallback cb,
 281       void *cb_cls)
 282 {
 283   struct MessageStreamTokenizer *ret;
 284
 285   ret = malloc (sizeof (struct MessageStreamTokenizer));
 286   if (NULL == ret)
 287   {
 288     fprintf (stderr, "Failed to allocate buffer for tokenizer\n");
 289     exit (1);
 290   }
 291   ret->hdr = malloc (MIN_BUFFER_SIZE);
 292   if (NULL == ret->hdr)
 293   {
 294     fprintf (stderr, "Failed to allocate buffer for alignment\n");
 295     exit (1);
 296   }
 297   ret->curr_buf = MIN_BUFFER_SIZE;
 298   ret->cb = cb;
 299   ret->cb_cls = cb_cls;
 300   ret->pos = 0;
 301
 302   return ret;
 303 }
 304
 305
 306 /**
 307  * Add incoming data to the receive buffer and call the
 308  * callback for all complete messages.
 309  *
 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
 315  */
 316 static int
 317 mst_receive (struct MessageStreamTokenizer *mst,
 318        const char *buf, size_t size)
 319 {
 320   const struct GNUNET_MessageHeader *hdr;
 321   size_t delta;
 322   uint16_t want;
 323   char *ibuf;
 324   int need_align;
 325   unsigned long offset;
 326   int ret;
 327
 328   ret = GNUNET_OK;
 329   ibuf = (char *) mst->hdr;
 330   while (mst->pos > 0)
 331   {
 332 do_align:
 333     if (mst->pos < mst->off)
 334     {
 335       //fprintf (stderr, "We processed too many bytes!\n");
 336       return GNUNET_SYSERR;
 337     }
 338     if ((mst->curr_buf - mst->off < sizeof (struct GNUNET_MessageHeader)) ||
 339         (0 != (mst->off % ALIGN_FACTOR)))
 340     {
 341       /* need to align or need more space */
 342       mst->pos -= mst->off;
 343       memmove (ibuf, &ibuf[mst->off], mst->pos);
 344       mst->off = 0;
 345     }
 346     if (mst->pos - mst->off < sizeof (struct GNUNET_MessageHeader))
 347     {
 348       delta =
 349           GNUNET_MIN (sizeof (struct GNUNET_MessageHeader) -
 350                       (mst->pos - mst->off), size);
 351       memcpy (&ibuf[mst->pos], buf, delta);
 352       mst->pos += delta;
 353       buf += delta;
 354       size -= delta;
 355     }
 356     if (mst->pos - mst->off < sizeof (struct GNUNET_MessageHeader))
 357     {
 358       //FIXME should I reset ??
 359       // mst->off = 0;
 360       // mst->pos = 0;
 361       return GNUNET_OK;
 362     }
 363     hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
 364     want = ntohs (hdr->size);
 365     if (want < sizeof (struct GNUNET_MessageHeader))
 366     {
 367       fprintf (stderr,
 368          "Received invalid message from stdin\n");
 369       return GNUNET_SYSERR;
 370     }
 371     if ((mst->curr_buf - mst->off < want) &&
 372        (mst->off > 0))
 373     {
 374       /* need more space */
 375       mst->pos -= mst->off;
 376       memmove (ibuf, &ibuf[mst->off], mst->pos);
 377       mst->off = 0;
 378     }
 379     if (want > mst->curr_buf)
 380     {
 381       if (mst->off != 0)
 382       {
 383         fprintf (stderr, "Error! We should proceeded 0 bytes\n");
 384         return GNUNET_SYSERR;
 385       }
 386       mst->hdr = realloc (mst->hdr, want);
 387       if (NULL == mst->hdr)
 388       {
 389   fprintf (stderr, "Failed to allocate buffer for alignment\n");
 390   exit (1);
 391       }
 392       ibuf = (char *) mst->hdr;
 393       mst->curr_buf = want;
 394     }
 395     hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
 396     if (mst->pos - mst->off < want)
 397     {
 398       delta = GNUNET_MIN (want - (mst->pos - mst->off), size);
 399       if (mst->pos + delta > mst->curr_buf)
 400       {
 401         fprintf (stderr, "The size of the buffer will be exceeded!\n");
 402         return GNUNET_SYSERR;
 403       }
 404       memcpy (&ibuf[mst->pos], buf, delta);
 405       mst->pos += delta;
 406       buf += delta;
 407       size -= delta;
 408     }
 409     if (mst->pos - mst->off < want)
 410     {
 411       //FIXME should I use this?
 412       // mst->off = 0;
 413       // mst->pos = 0;
 414       return GNUNET_OK;
 415     }
 416     mst->cb (mst->cb_cls, hdr);
 417     mst->off += want;
 418     if (mst->off == mst->pos)
 419     {
 420       /* reset to beginning of buffer, it's free right now! */
 421       mst->off = 0;
 422       mst->pos = 0;
 423     }
 424   }
 425   if (0 != mst->pos)
 426   {
 427     fprintf (stderr, "There should some valid bytes in the buffer on this stage\n");
 428     return GNUNET_SYSERR;
 429   }
 430   while (size > 0)
 431   {
 432     if (size < sizeof (struct GNUNET_MessageHeader))
 433       break;
 434     offset = (unsigned long) buf;
 435     need_align = (0 != offset % ALIGN_FACTOR) ? GNUNET_YES : GNUNET_NO;
 436     if (GNUNET_NO == need_align)
 437     {
 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))
 442       {
 443   fprintf (stderr,
 444      "Received invalid message from stdin\n");
 445   //exit (1);
 446         mst->off = 0;
 447         return GNUNET_SYSERR;
 448       }
 449       if (size < want)
 450         break;                  /* or not, buffer incomplete, so copy to private buffer... */
 451       mst->cb (mst->cb_cls, hdr);
 452       buf += want;
 453       size -= want;
 454     }
 455     else
 456     {
 457       /* need to copy to private buffer to align;
 458        * yes, we go a bit more spagetti than usual here */
 459       goto do_align;
 460     }
 461   }
 462   if (size > 0)
 463   {
 464     if (size + mst->pos > mst->curr_buf)
 465     {
 466       mst->hdr = realloc (mst->hdr, size + mst->pos);
 467       if (NULL == mst->hdr)
 468       {
 469   fprintf (stderr, "Failed to allocate buffer for alignment\n");
 470   exit (1);
 471       }
 472       ibuf = (char *) mst->hdr;
 473       mst->curr_buf = size + mst->pos;
 474     }
 475     if (mst->pos + size > mst->curr_buf)
 476     {
 477       fprintf (stderr,
 478          "Assertion failed\n");
 479       exit (1);
 480     }
 481     memcpy (&ibuf[mst->pos], buf, size);
 482     mst->pos += size;
 483   }
 484   return ret;
 485 }
 486
 487 /**
 488  * Destroys a tokenizer.
 489  *
 490  * @param mst tokenizer to destroy
 491  */
 492 static void
 493 mst_destroy (struct MessageStreamTokenizer *mst)
 494 {
 495   free (mst->hdr);
 496   free (mst);
 497 }
 498
 499 /**
 500  * Calculate crc32, the start of the calculation
 501  *
 502  * @param buf buffer to calc the crc
 503  * @param len len of the buffer
 504  * @return crc sum
 505  */
 506 static unsigned long
 507 calc_crc_osdep (const unsigned char *buf, size_t len)
 508 {
 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
 574   };
 575
 576   unsigned long crc = 0xFFFFFFFF;
 577
 578   for (; len > 0; len--, buf++)
 579     crc = crc_tbl_osdep[(crc ^ *buf) & 0xFF] ^ (crc >> 8);
 580   return (~crc);
 581 }
 582
 583
 584 /**
 585  * Calculate and check crc of the bluetooth packet
 586  *
 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
 591  */
 592 static int
 593 check_crc_buf_osdep (const unsigned char *buf, size_t len)
 594 {
 595   unsigned long crc;
 596
 597   crc = calc_crc_osdep (buf, len);
 598   buf += len;
 599   if (((crc) & 0xFF) == buf[0] && ((crc >> 8) & 0xFF) == buf[1] &&
 600       ((crc >> 16) & 0xFF) == buf[2] && ((crc >> 24) & 0xFF) == buf[3])
 601     return 0;
 602   return 1;
 603 }
 604
 605
 606
 607 /* ************** end of clone  ***************** */
 608
 609 #ifdef MINGW
 610   /**
 611    * Function used to get the code of last error and to print the type of error.
 612    */
 613   static void
 614   print_last_error()
 615   {
 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) ;
 620     //FIXME : it crashes
 621     // if (lpMsgBuf)
 622     //   free (lpMsgBuf);
 623   }
 624
 625   /**
 626    * Function used to initialize the Windows Sockets
 627    */
 628   static void
 629   initialize_windows_sockets()
 630   {
 631     WSADATA wsaData ;
 632     WORD wVersionRequested = MAKEWORD (2, 0);
 633     if (WSAStartup (wVersionRequested, &wsaData) != NO_ERROR)
 634     {
 635       fprintf (stderr , "Error initializing window sockets!\n");
 636       print_last_error();
 637       ExitProcess (2) ;
 638     }
 639   }
 640
 641   /**
 642    * Function used to convert the GUID.
 643    * @param bytes the GUID represented as a char array
 644    * @param uuid pointer to the GUID
 645    */
 646   static void
 647   convert_guid(char *bytes, GUID * uuid)
 648   {
 649     int i;
 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);
 653
 654     for (i = 0; i < 8; i++)
 655     {
 656       uuid->Data4[i] = bytes[i + 8];
 657     }
 658   }
 659 #endif
 660
 661 #ifdef LINUX
 662   /**
 663    * Function for assigning a port number
 664    *
 665    * @param socket the socket used to bind
 666    * @param addr pointer to the rfcomm address
 667    * @return 0 on success
 668    */
 669   static int
 670   bind_socket (int socket, struct sockaddr_rc *addr)
 671   {
 672     int port, status;
 673
 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++)
 677     {
 678       addr->rc_channel = port;
 679       status = bind (socket, (struct sockaddr *) addr, sizeof (struct sockaddr_rc));
 680       if (status == 0)
 681         return 0;
 682     }
 683
 684     return -1;
 685   }
 686 #endif
 687
 688 #ifdef MINGW
 689   /**
 690    * Function used for creating the service record and registering it.
 691    *
 692    * @param dev pointer to the device struct
 693    * @return 0 on success
 694    */
 695   static int
 696   register_service (struct HardwareInfos *dev)
 697   {
 698     // advertise the service
 699     CSADDR_INFO addr_info;
 700     WSAQUERYSET wqs;
 701     GUID guid;
 702     unsigned char uuid[] = GNUNET_BLUETOOTH_SDP_UUID;
 703     SOCKADDR_BTH addr;
 704     int addr_len = sizeof (SOCKADDR_BTH);
 705     int fd;
 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);
 709     if (fd <= 0)
 710     {
 711       fprintf (stderr, "Failed to get the file descriptor\n");
 712       return -1;
 713     }
 714     if (SOCKET_ERROR == getsockname (fd, (SOCKADDR*)&addr, &addr_len))
 715     {
 716       fprintf (stderr, "Failed to get the port on which we are listening on: \n");
 717       print_last_error();
 718       return -1;
 719     }
 720
 721     /* save the device address */
 722     memcpy (&dev->pl_mac, &addr.btAddr, sizeof (BTH_ADDR));
 723
 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);
 732
 733     convert_guid((char *) uuid, &guid);
 734
 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
 745
 746     if (SOCKET_ERROR == WSASetService (&wqs , RNRSERVICE_REGISTER, 0))
 747     {
 748       fprintf (stderr, "Failed to register the SDP service: ");
 749       print_last_error();
 750       return -1;
 751     }
 752     else
 753     {
 754       fprintf (stderr, "The SDP service was registered\n");
 755     }
 756
 757     return 0;
 758   }
 759 #else
 760   /**
 761    * Function used for creating the service record and registering it.
 762    *
 763    * @param dev pointer to the device struct
 764    * @param rc_channel the rfcomm channel
 765    * @return 0 on success
 766    */
 767   static int
 768   register_service (struct HardwareInfos *dev, int rc_channel)
 769   {
 770     /**
 771      * 1. initializations
 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
 777      * 7. cleanup
 778      */
 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;
 789
 790     record = sdp_record_alloc();
 791
 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);
 797
 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);
 802
 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);
 809
 810     /* Set protocol information */
 811     access_proto_list = sdp_list_append (0, proto_list);
 812     sdp_set_access_protos (record, access_proto_list);
 813
 814     /* Set the name, provider, and description */
 815     sdp_set_info_attr (record, dev->iface, service_prov, service_dsc);
 816
 817     /* Connect to the local SDP server */
 818     dev->session = sdp_connect (BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY);
 819
 820     if (!dev->session)
 821     {
 822       fprintf (stderr, "Failed to connect to the SDP server on interface `%.*s': %s\n",
 823                IFNAMSIZ, dev->iface, strerror (errno));
 824       //FIXME exit?
 825       return 1;
 826     }
 827
 828     /* Register the service record */
 829     if (sdp_record_register (dev->session, record, 0) < 0)
 830     {
 831       fprintf (stderr, "Failed to register a service record on interface `%.*s': %s\n",
 832                IFNAMSIZ, dev->iface, strerror (errno));
 833       //FIXME exit?
 834       return 1;
 835     }
 836
 837     /* Cleanup */
 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);
 845
 846     return 0;
 847   }
 848 #endif
 849
 850 #ifdef MINGW
 851   /**
 852    * Function for searching and browsing for a service. This will return the
 853    * port number on which the service is running.
 854    *
 855    * @param dest target address
 856    * @return channel
 857    */
 858   static int
 859   get_channel(const char *dest)
 860   {
 861     HANDLE h;
 862     WSAQUERYSET *wqs;
 863     DWORD wqs_len = sizeof (WSAQUERYSET);
 864     int done = 0;
 865     int channel = -1;
 866     GUID guid;
 867     unsigned char uuid[] = GNUNET_BLUETOOTH_SDP_UUID;
 868     convert_guid ((char *) uuid, &guid);
 869
 870     wqs = (WSAQUERYSET*)malloc (wqs_len);
 871     ZeroMemory (wqs, wqs_len);
 872
 873     wqs->dwSize = sizeof (WSAQUERYSET) ;
 874     wqs->lpServiceClassId = &guid;
 875     wqs->dwNameSpace = NS_BTH;
 876     wqs->dwNumberOfCsAddrs = 0;
 877     wqs->lpszContext = (LPSTR)dest;
 878
 879     if (SOCKET_ERROR == WSALookupServiceBegin (wqs,  LUP_FLUSHCACHE | LUP_RETURN_ALL, &h))
 880     {
 881       if (GetLastError() == WSASERVICE_NOT_FOUND)
 882       {
 883         fprintf (stderr, "WARNING! The device with address %s wasn't found. Skipping the message!", dest);
 884         return -1;
 885       }
 886       else
 887       {
 888         fprintf (stderr, "Failed to find the port number: ");
 889         print_last_error();
 890         ExitProcess (2);
 891         return -1;
 892       }
 893     }
 894
 895     /* search the sdp service */
 896     while (!done)
 897     {
 898       if (SOCKET_ERROR == WSALookupServiceNext (h, LUP_FLUSHCACHE | LUP_RETURN_ALL, &wqs_len, wqs))
 899       {
 900         int error = WSAGetLastError();
 901
 902         switch (error)
 903         {
 904         case WSAEFAULT:
 905           free (wqs);
 906           //fprintf (stderr, "WSAFAULT error! (the memory allocated wasn't enought\n");
 907           wqs = (WSAQUERYSET*)malloc (wqs_len);
 908           break;
 909         case WSANO_DATA:
 910           fprintf (stderr, "Failed! The address was valid but there was no data record of requested type\n");
 911           done = 1;
 912           break;
 913         case WSA_E_NO_MORE:
 914           done = 1;
 915           // fprintf (stderr, "No matching service found\n");
 916           break;
 917         default:
 918           fprintf (stderr, "Failed to look over the services: ");
 919           print_last_error();
 920           WSALookupServiceEnd (h);
 921           ExitProcess (2);
 922         }
 923       }
 924       else
 925       {
 926         channel = ((SOCKADDR_BTH*)wqs->lpcsaBuffer->RemoteAddr.lpSockaddr)->port;
 927       }
 928     }
 929
 930     free (wqs) ;
 931     WSALookupServiceEnd (h);
 932
 933     return channel;
 934   }
 935 #else
 936   /**
 937    * Function used for searching and browsing for a service. This will return the
 938    * port number on which the service is running.
 939    *
 940    * @param dev pointer to the device struct
 941    * @param dest target address
 942    * @return channel
 943    */
 944   static int
 945   get_channel(struct HardwareInfos *dev, bdaddr_t dest)
 946   {
 947     /**
 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
 953      *       the port number
 954      */
 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;
 960     uuid_t svc_uuid;
 961     uint32_t range = 0x0000ffff;
 962     uint8_t channel = -1;
 963
 964     /* Connect to the local SDP server */
 965     session = sdp_connect (BDADDR_ANY, &dest, 0);
 966     if (!session)
 967     {
 968      fprintf (stderr, "Failed to connect to the SDP server on interface `%.*s': %s\n",
 969               IFNAMSIZ, dev->iface, strerror (errno));
 970      //FIXME exit?
 971      return -1;
 972     }
 973
 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);
 977
 978     if (sdp_service_search_attr_req (session, search_list,
 979                     SDP_ATTR_REQ_RANGE, attrid_list, &response_list) == 0)
 980     {
 981       for (it = response_list; it; it = it->next)
 982       {
 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)
 987         {
 988           channel = sdp_get_proto_port (proto_list, RFCOMM_UUID);
 989           sdp_list_free (proto_list, 0);
 990         }
 991         sdp_record_free (record);
 992       }
 993     }
 994
 995     sdp_list_free (search_list, 0);
 996     sdp_list_free (attrid_list, 0);
 997     sdp_list_free (response_list, 0);
 998
 999     sdp_close (session);
1000
1001     if (channel == -1)
1002       fprintf (stderr, "Failed to find the listening channel for interface `%.*s': %s\n",
1003               IFNAMSIZ, dev->iface, strerror (errno));
1004
1005     return channel;
1006   }
1007 #endif
1008
1009 /**
1010  * Read from the socket and put the result into the buffer for transmission to 'stdout'.
1011  *
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'
1018  */
1019 static ssize_t
1020 read_from_the_socket (void *sock,
1021       unsigned char *buf, size_t buf_size,
1022             struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *ri)
1023 {
1024   unsigned char tmpbuf[buf_size];
1025   ssize_t count;
1026
1027   #ifdef MINGW
1028    count = GNUNET_NETWORK_socket_recv ((struct GNUNET_NETWORK_Handle *)sock, tmpbuf, buf_size);
1029   #else
1030    count = read (*((int *)sock), tmpbuf, buf_size);
1031   #endif
1032
1033   if (0 > count)
1034   {
1035     if (EAGAIN == errno)
1036       return 0;
1037     #if MINGW
1038      print_last_error();
1039     #else
1040      fprintf (stderr, "Failed to read from the HCI socket: %s\n", strerror (errno));
1041     #endif
1042
1043     return -1;
1044   }
1045
1046   #ifdef LINUX
1047    /* Get the channel used */ //FIXME probably not needed anymore
1048    int len;
1049    struct sockaddr_rc  rc_addr = { 0 };
1050
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))
1054    {
1055      fprintf (stderr, "getsockname() call failed : %s\n", strerror (errno));
1056      return -1;
1057    }
1058
1059    memset (ri, 0, sizeof (*ri));
1060    ri->ri_channel = rc_addr.rc_channel;
1061   #endif
1062
1063   /* Detect CRC32 at the end */
1064   if (0 == check_crc_buf_osdep (tmpbuf, count - sizeof (uint32_t)))
1065   {
1066     count -= sizeof(uint32_t);
1067   }
1068
1069   memcpy (buf, tmpbuf, count);
1070
1071   return count;
1072 }
1073
1074 /**
1075  * Open the bluetooth interface for reading/writing
1076  *
1077  * @param dev pointer to the device struct
1078  * @return 0 on success
1079  */
1080 static int
1081 open_device (struct HardwareInfos *dev)
1082 {
1083   #ifdef MINGW
1084     SOCKADDR_BTH addr;
1085
1086     /* bind the hci socket to the interface */
1087     addr.addressFamily = AF_BTH;
1088     addr.btAddr = 0;
1089     addr.port = BT_PORT_ANY;
1090
1091     //FIXME flags parameter
1092     if (GNUNET_NETWORK_socket_bind (dev->handle, (const SOCKADDR*)&addr, sizeof (SOCKADDR_BTH), 0) != GNUNET_OK)
1093     {
1094       fprintf (stderr, "Failed to bind the socket: ");
1095       if (GetLastError() == WSAENETDOWN)
1096       {
1097         fprintf (stderr, "Please make sure that your Bluetooth device is ON!\n");
1098         ExitProcess (2);
1099       }
1100       print_last_error();
1101       return -1;
1102     }
1103
1104     /* start listening on the socket */
1105     if (GNUNET_NETWORK_socket_listen (dev->handle, 4) != GNUNET_OK)
1106     {
1107       fprintf (stderr, "Failed to listen on the socket: ");
1108       print_last_error();
1109       return -1;
1110     }
1111
1112     /* register the sdp service */
1113     if (register_service(dev) != 0)
1114     {
1115       fprintf (stderr, "Failed to register a service: ");
1116       print_last_error();
1117       return 1;
1118     }
1119   #else
1120     int i, dev_id = -1, fd_hci;
1121     struct
1122     {
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
1127
1128     /* Initialize the neighbour structure */
1129     neighbours.dev_id = -1;
1130     for (i = 0; i < MAX_PORTS; i++)
1131       neighbours.fds[i] = -1;
1132
1133     /* Open a HCI socket */
1134     fd_hci = socket (AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
1135
1136     if (fd_hci < 0)
1137     {
1138       fprintf (stderr, "Failed to create HCI socket: %s\n", strerror (errno));
1139       return -1;
1140     }
1141
1142     memset (&request, 0, sizeof(request));
1143     request.list.dev_num = HCI_MAX_DEV;
1144
1145     if (ioctl (fd_hci, HCIGETDEVLIST, (void *) &request) < 0)
1146     {
1147       fprintf (stderr, "ioctl(HCIGETDEVLIST) on interface `%.*s' failed: %s\n",
1148               IFNAMSIZ, dev->iface, strerror (errno));
1149       return 1;
1150     }
1151
1152     /* Search for a device with dev->iface name */
1153     for (i = 0; i < request.list.dev_num; i++)
1154     {
1155       struct hci_dev_info dev_info;
1156
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);
1160
1161       if (ioctl (fd_hci, HCIGETDEVINFO, (void *) &dev_info))
1162       {
1163         fprintf (stderr, "ioctl(HCIGETDEVINFO) on interface `%.*s' failed: %s\n",
1164                IFNAMSIZ, dev->iface, strerror (errno));
1165         return 1;
1166       }
1167
1168       if (strcmp (dev_info.name, dev->iface) == 0)
1169       {
1170
1171         dev_id = dev_info.dev_id; //the device was found
1172         /**
1173          * Copy the MAC address to the device structure
1174          */
1175         memcpy (&dev->pl_mac, &dev_info.bdaddr, sizeof (bdaddr_t));
1176
1177         /* Check if the interface is up */
1178         if (hci_test_bit (HCI_UP, (void *) &dev_info.flags) == 0)
1179         {
1180           /* Bring the interface up */
1181           if (ioctl (fd_hci, HCIDEVUP, dev_info.dev_id))
1182           {
1183             fprintf (stderr, "ioctl(HCIDEVUP) on interface `%.*s' failed: %s\n",
1184                IFNAMSIZ, dev->iface, strerror (errno));
1185             return 1;
1186           }
1187         }
1188
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)
1192         {
1193           /* Set interface Page Scan and Inqury Scan ON */
1194           struct hci_dev_req dev_req;
1195
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;
1199
1200           if (ioctl (fd_hci, HCISETSCAN, (unsigned long) &dev_req))
1201           {
1202             fprintf (stderr, "ioctl(HCISETSCAN) on interface `%.*s' failed: %s\n",
1203                IFNAMSIZ, dev->iface, strerror (errno));
1204             return 1;
1205           }
1206
1207         }
1208         break;
1209       }
1210
1211     }
1212
1213     /* Check if the interface was not found */
1214     if (dev_id == -1)
1215     {
1216       fprintf (stderr, "The interface %s was not found\n", dev->iface);
1217       return 1;
1218     }
1219
1220     /* Close the hci socket */
1221     (void) close(fd_hci);
1222
1223
1224
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;
1229
1230     if (bind_socket (dev->fd_rfcomm, &rc_addr) != 0)
1231     {
1232       fprintf (stderr, "Failed to bind interface `%.*s': %s\n", IFNAMSIZ,
1233                dev->iface, strerror (errno));
1234       return 1;
1235     }
1236
1237     /* Register a SDP service */
1238     if (register_service (dev, rc_addr.rc_channel) != 0)
1239     {
1240       fprintf (stderr, "Failed to register a service on interface `%.*s': %s\n", IFNAMSIZ,
1241                dev->iface, strerror (errno));
1242       return 1;
1243     }
1244
1245     /* Switch socket in listening mode */
1246     if (listen (dev->fd_rfcomm, 5) == -1) //FIXME: probably we need a bigger number
1247     {
1248       fprintf (stderr, "Failed to listen on socket for interface `%.*s': %s\n", IFNAMSIZ,
1249                dev->iface, strerror (errno));
1250       return 1;
1251     }
1252
1253   #endif
1254
1255   return 0;
1256 }
1257
1258
1259 /**
1260  * Set the header to sane values to make attacks more difficult
1261  *
1262  * @param taIeeeHeader pointer to the header of the packet
1263  * @param dev pointer to the Hardware_Infos struct
1264  *
1265  **** copy from gnunet-helper-transport-wlan.c ****
1266  */
1267 static void
1268 mac_set (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader,
1269          const struct HardwareInfos *dev)
1270 {
1271   taIeeeHeader->frame_control = htons (IEEE80211_FC0_TYPE_DATA);
1272   taIeeeHeader->addr3 = mac_bssid_gnunet;
1273
1274   #ifdef MINGW
1275     memcpy (&taIeeeHeader->addr2, &dev->pl_mac, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
1276   #else
1277     taIeeeHeader->addr2 = dev->pl_mac;
1278   #endif
1279 }
1280
1281 #ifdef LINUX
1282   /**
1283    * Test if the given interface name really corresponds to a bluetooth
1284    * device.
1285    *
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 ****
1289    */
1290   static int
1291   test_bluetooth_interface (const char *iface)
1292   {
1293     char strbuf[512];
1294     struct stat sbuf;
1295     int ret;
1296
1297     ret = snprintf (strbuf, sizeof (strbuf),
1298         "/sys/class/bluetooth/%s/subsystem",
1299         iface);
1300     if ((ret < 0) || (ret >= sizeof (strbuf)) || (0 != stat (strbuf, &sbuf)))
1301     {
1302       fprintf (stderr,
1303          "Did not find 802.15.1 interface `%s'. Exiting.\n",
1304          iface);
1305       exit (1);
1306     }
1307     return 0;
1308   }
1309 #endif
1310
1311 /**
1312  * Test incoming packets mac for being our own.
1313  *
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
1317  *
1318  **** same as the one from gnunet-helper-transport-wlan.c ****
1319  */
1320 static int
1321 mac_test (const struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader,
1322           const struct HardwareInfos *dev)
1323 {
1324   static struct GNUNET_TRANSPORT_WLAN_MacAddress all_zeros;
1325
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! */
1329
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 */
1336 }
1337
1338
1339 /**
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.
1342  *
1343  * @param cls pointer to the device struct ('struct HardwareInfos*')
1344  * @param hdr pointer to the start of the packet
1345  *
1346  **** same as the one from gnunet-helper-transport-wlan.c ****
1347  */
1348 static void
1349 stdin_send_hw (void *cls, const struct GNUNET_MessageHeader *hdr)
1350 {
1351   struct HardwareInfos *dev = cls;
1352   const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header;
1353   struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *blueheader;
1354   size_t sendsize;
1355
1356   sendsize = ntohs (hdr->size);
1357   if ( (sendsize <
1358   sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage)) ||
1359        (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER != ntohs (hdr->type)) )
1360   {
1361     fprintf (stderr, "Received malformed message\n");
1362     exit (1);
1363   }
1364   sendsize -= (sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) -
1365                sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame));
1366   if (MAXLINE < sendsize)
1367   {
1368     fprintf (stderr, "Packet too big for buffer\n");
1369     exit (1);
1370   }
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;
1374
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;
1381 }
1382
1383 #ifdef LINUX
1384   /**
1385    * Broadcast a HELLO message for peer discovery
1386    *
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
1390    */
1391   static int
1392   send_broadcast (struct HardwareInfos *dev, int *sendsocket)
1393   {
1394     int new_device = 0;
1395     int loops = 0;
1396
1397    search_for_devices:
1398     if ((neighbours.size == neighbours.pos && new_device == 1) || neighbours.size == 0)
1399     {
1400    inquiry_devices:   //skip the conditions and force a inquiry for new devices
1401       {
1402       /**
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.
1405        */
1406       inquiry_info *devices = NULL;
1407       int i, responses, max_responses = MAX_PORTS;
1408
1409       /* sanity checks */
1410       if (neighbours.size >= MAX_PORTS)
1411       {
1412         fprintf (stderr, "%.*s reached the top limit for the discovarable devices\n", IFNAMSIZ, dev->iface);
1413         return 2;
1414       }
1415
1416       /* Get the device id */
1417       if (neighbours.dev_id == -1)
1418       {
1419         char addr[19] = { 0 }; //the device MAC address
1420
1421         ba2str ((bdaddr_t *) &dev->pl_mac, addr);
1422         neighbours.dev_id = hci_devid (addr);
1423         if (neighbours.dev_id < 0)
1424         {
1425           fprintf (stderr, "Failed to get the device id for interface %.*s : %s\n", IFNAMSIZ,
1426                   dev->iface, strerror (errno));
1427           return 1;
1428         }
1429       }
1430
1431       devices = malloc (max_responses * sizeof (inquiry_info));
1432       if (devices == NULL)
1433       {
1434         fprintf (stderr, "Failed to allocate memory for inquiry info list on interface %.*s\n", IFNAMSIZ,
1435                 dev->iface);
1436         return 1;
1437       }
1438
1439       responses = hci_inquiry (neighbours.dev_id, 8, max_responses, NULL, &devices, IREQ_CACHE_FLUSH);
1440       if (responses < 0)
1441       {
1442         fprintf (stderr, "Failed to inquiry on interface %.*s\n", IFNAMSIZ, dev->iface);
1443         return 1;
1444       }
1445
1446       fprintf (stderr, "LOG : Found %d devices\n", responses); //FIXME delete it after debugging stage
1447
1448       if (responses == 0)
1449       {
1450         fprintf (stderr, "LOG : No devices discoverable\n");
1451         return 1;
1452       }
1453
1454       for (i = 0; i < responses; i++)
1455       {
1456         int j;
1457         int found = 0;
1458
1459         /* sanity check */
1460         if (i >= MAX_PORTS)
1461         {
1462           fprintf (stderr, "%.*s reached the top limit for the discoverable devices (after inquiry)\n", IFNAMSIZ,
1463                   dev->iface);
1464           return 2;
1465         }
1466
1467         /* Search if the address already exists on the list */
1468         for (j = 0; j < neighbours.size; j++)
1469         {
1470           if (memcmp (&(devices + i)->bdaddr, &(neighbours.devices[j]), sizeof (bdaddr_t)) == 0)
1471           {
1472             found = 1;
1473             fprintf (stderr, "LOG : the device already exists on the list\n"); //FIXME debugging message
1474             break;
1475           }
1476         }
1477
1478         if (found == 0)
1479         {
1480           char addr[19] = { 0 };
1481
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));
1485         }
1486       }
1487
1488       free (devices);
1489       }
1490     }
1491
1492     int connection_successful = 0;
1493     struct sockaddr_rc addr_rc = { 0 };
1494     int errno_copy = 0;
1495     addr_rc.rc_family = AF_BLUETOOTH;
1496
1497     /* Try to connect to a new device from the list */
1498     while (neighbours.pos < neighbours.size)
1499     {
1500       /* Check if we are already connected to this device */
1501       if (neighbours.fds[neighbours.pos] == -1)
1502       {
1503
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));
1506
1507         addr_rc.rc_channel = get_channel (dev, addr_rc.rc_bdaddr);
1508
1509         *sendsocket = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
1510         if (connect (*sendsocket, (struct sockaddr *)&addr_rc, sizeof (addr_rc)) == 0)
1511         {
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);
1517
1518           break;
1519         }
1520         else
1521         {
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
1527           {
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;
1535           }
1536
1537           neighbours.pos += 1;
1538
1539           if (neighbours.pos >= neighbours.size)
1540               neighbours.pos = 0;
1541
1542           loops += 1;
1543
1544           if (loops == MAX_LOOPS) //don't get stuck trying to connect to one device
1545             return 1;
1546         }
1547       }
1548       else
1549       {
1550         fprintf (stderr, "LOG : Search for a new device\n"); //FIXME debugging message
1551         neighbours.pos += 1;
1552       }
1553     }
1554
1555     /* Cycle on the list */
1556     if (neighbours.pos == neighbours.size)
1557     {
1558       neighbours.pos = 0;
1559       searching_devices_count += 1;
1560
1561       if (searching_devices_count == MAX_LOOPS)
1562       {
1563         fprintf (stderr, "LOG : Force to inquiry for new devices\n");
1564         searching_devices_count = 0;
1565         goto inquiry_devices;
1566       }
1567     }
1568    /* If a new device wasn't found, search an old one */
1569     if (connection_successful == 0)
1570     {
1571       int loop_check = neighbours.pos;
1572       while (neighbours.fds[neighbours.pos] == -1)
1573       {
1574         if (neighbours.pos == neighbours.size)
1575           neighbours.pos = 0;
1576
1577         if (neighbours.pos == loop_check)
1578         {
1579           if (errno_copy == ECONNREFUSED)
1580           {
1581             fprintf (stderr, "LOG : No device found. Go back and search again\n"); //FIXME debugging message
1582             new_device = 1;
1583             loops += 1;
1584             goto search_for_devices;
1585           }
1586           else
1587           {
1588             return 1; // Skip the broadcast message
1589           }
1590         }
1591
1592         neighbours.pos += 1;
1593       }
1594
1595       *sendsocket = neighbours.fds[neighbours.pos++];
1596     }
1597
1598     return 0;
1599   }
1600 #endif
1601
1602 /**
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.
1606  *
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
1610  *
1611  **** similar to gnunet-helper-transport-wlan.c ****
1612  */
1613 int
1614 main (int argc, char *argv[])
1615 {
1616 #ifdef LINUX
1617     struct HardwareInfos dev;
1618     char readbuf[MAXLINE];
1619     int maxfd;
1620     fd_set rfds;
1621     fd_set wfds;
1622     int stdin_open;
1623     struct MessageStreamTokenizer *stdin_mst;
1624     int raw_eno, i;
1625     uid_t uid;
1626     int crt_rfds = 0, rfds_list[MAX_PORTS];
1627     int broadcast, sendsocket;
1628     /* Assert privs so we can modify the firewall rules! */
1629     uid = getuid ();
1630   #ifdef HAVE_SETRESUID
1631     if (0 != setresuid (uid, 0, 0))
1632     {
1633       fprintf (stderr, "Failed to setresuid to root: %s\n", strerror (errno));
1634       return 254;
1635     }
1636   #else
1637     if (0 != seteuid (0))
1638     {
1639       fprintf (stderr, "Failed to seteuid back to root: %s\n", strerror (errno));
1640       return 254;
1641     }
1642   #endif
1643
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 */
1648
1649     /* Now that we've dropped root rights, we can do error checking */
1650     if (2 != argc)
1651     {
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);
1656       return 1;
1657     }
1658
1659     if (-1 == dev.fd_rfcomm)
1660     {
1661       fprintf (stderr, "Failed to create a HCI socket: %s\n", strerror (raw_eno));
1662       return 1;
1663     }
1664     if (dev.fd_rfcomm >= FD_SETSIZE)
1665     {
1666       fprintf (stderr, "File descriptor too large for select (%d > %d)\n",
1667                dev.fd_rfcomm, FD_SETSIZE);
1668       (void) close (dev.fd_rfcomm);
1669       return 1;
1670     }
1671     if (0 != test_bluetooth_interface (argv[1]))
1672     {
1673       (void) close (dev.fd_rfcomm);
1674       return 1;
1675     }
1676     strncpy (dev.iface, argv[1], IFNAMSIZ);
1677     if (0 != open_device (&dev))
1678     {
1679       (void) close (dev.fd_rfcomm);
1680       return 1;
1681     }
1682
1683     /* Drop privs */
1684     {
1685       uid_t uid = getuid ();
1686   #ifdef HAVE_SETRESUID
1687       if (0 != setresuid (uid, uid, uid))
1688       {
1689         fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno));
1690         if (-1 != dev.fd_rfcomm)
1691     (void) close (dev.fd_rfcomm);
1692         return 1;
1693       }
1694   #else
1695       if (0 != (setuid (uid) | seteuid (uid)))
1696       {
1697         fprintf (stderr, "Failed to setuid: %s\n", strerror (errno));
1698         if (-1 != dev.fd_rfcomm)
1699     (void) close (dev.fd_rfcomm);
1700         return 1;
1701       }
1702   #endif
1703     }
1704
1705    /* Send MAC address of the bluetooth interface to STDOUT first */
1706     {
1707       struct GNUNET_TRANSPORT_WLAN_HelperControlMessage macmsg;
1708
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);
1714     }
1715
1716
1717     stdin_mst = mst_create (&stdin_send_hw, &dev);
1718     stdin_open = 1;
1719
1720     fprintf (stderr, "\n-----------------------------------------------\n      Check if the program exits\n-----------------------------------------------\n");
1721    /**
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.
1726     */
1727    while (1)
1728     {
1729       maxfd = -1;
1730       broadcast = 0;
1731       sendsocket = -1;
1732
1733       FD_ZERO (&rfds);
1734       if ((0 == write_pout.size) && (1 == stdin_open))
1735       {
1736         FD_SET (STDIN_FILENO, &rfds);
1737         maxfd = MAX (maxfd, STDIN_FILENO);
1738       }
1739       if (0 == write_std.size)
1740       {
1741         FD_SET (dev.fd_rfcomm, &rfds);
1742         maxfd = MAX (maxfd, dev.fd_rfcomm);
1743       }
1744
1745       for (i = 0; i < crt_rfds; i++)  // it can receive messages from multiple devices
1746       {
1747         FD_SET (rfds_list[i], &rfds);
1748         maxfd = MAX (maxfd, rfds_list[i]);
1749       }
1750       FD_ZERO (&wfds);
1751       if (0 < write_std.size)
1752       {
1753         FD_SET (STDOUT_FILENO, &wfds);
1754         maxfd = MAX (maxfd, STDOUT_FILENO);
1755       }
1756       if (0 < write_pout.size) //it can send messages only to one device per loop
1757       {
1758         struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *frame;
1759         /* Get the destination address */
1760         frame = (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *) write_pout.buf;
1761
1762         if (memcmp (&frame->addr1, &dev.pl_mac,
1763                     sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)
1764         {
1765           broadcast = 1;
1766           memset (&write_pout, 0, sizeof (write_pout)); //clear the buffer
1767         }
1768         else if (memcmp (&frame->addr1, &broadcast_address,
1769                   sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)
1770         {
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));
1774
1775           if (send_broadcast(&dev, &sendsocket) != 0) //if the searching wasn't successful don't get stuck on the select stage
1776           {
1777             broadcast = 1;
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);
1780           }
1781           else
1782           {
1783             FD_SET (sendsocket, &wfds);
1784             maxfd = MAX (maxfd, sendsocket);
1785           }
1786         }
1787         else
1788         {
1789           int found = 0;
1790           int pos = 0;
1791           /* Search if the address already exists on the list */
1792           for (i = 0; i < neighbours.size; i++)
1793           {
1794             if (memcmp (&frame->addr1, &(neighbours.devices[i]), sizeof (bdaddr_t)) == 0)
1795             {
1796               pos = i;
1797               if (neighbours.fds[i] != -1)
1798               {
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");
1804                 break;
1805               }
1806             }
1807           }
1808           if (found == 0)
1809           {
1810             int status;
1811             struct sockaddr_rc addr = { 0 };
1812
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
1816
1817             sendsocket = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
1818
1819             if (sendsocket < 0)
1820             {
1821               fprintf (stderr, "Failed to create a RFCOMM socket (sending stage): %s\n",
1822                       strerror (errno));
1823               return -1;
1824             }
1825
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);
1829
1830             int tries = 0;
1831             connect_retry:
1832             status = connect (sendsocket, (struct sockaddr *) &addr, sizeof (addr));
1833             if (0 != status && errno != EAGAIN)
1834             {
1835               if (errno == ECONNREFUSED && tries < 2)
1836               {
1837                 fprintf (stderr, "LOG : %.*s failed to connect. Trying again!\n", IFNAMSIZ, dev.iface);
1838                 tries++;
1839                 goto connect_retry;
1840               }
1841               else if (errno == EBADF)
1842               {
1843                 fprintf (stderr, "LOG : %s failed to connect : %s. Skip it!\n", dev.iface, strerror (errno));
1844                 memset (&write_pout, 0, sizeof (write_pout));
1845                 broadcast = 1;
1846               }
1847               else
1848               {
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));
1851                 broadcast = 1;
1852               }
1853
1854             }
1855             else
1856             {
1857               FD_SET (sendsocket, &wfds);
1858               maxfd = MAX (maxfd, sendsocket);
1859               fprintf (stderr, "LOG : Connection successful\n");
1860               if (pos != 0) // save the socket
1861               {
1862                 neighbours.fds[pos] = sendsocket;
1863               }
1864               else
1865               {
1866                 /* Add the new device to the discovered devices list */
1867                 if (neighbours.size < MAX_PORTS)
1868                 {
1869                   neighbours.fds[neighbours.size] = sendsocket;
1870                   memcpy (&(neighbours.devices[neighbours.size++]), &addr.rc_bdaddr, sizeof (bdaddr_t));
1871                 }
1872                 else
1873                 {
1874                   fprintf (stderr, "The top limit for the discovarable devices' list was reached\n");
1875                 }
1876               }
1877             }
1878           }
1879         }
1880       }
1881
1882       if (broadcast == 0)
1883       {
1884         /* Select a fd which is ready for action :) */
1885         {
1886           int retval = select (maxfd + 1, &rfds, &wfds, NULL, NULL);
1887           if ((-1 == retval) && (EINTR == errno))
1888       continue;
1889           if (0 > retval && errno != EBADF)   // we handle BADF errors later
1890           {
1891       fprintf (stderr, "select failed: %s\n", strerror (errno));
1892       break;
1893           }
1894         }
1895         if (FD_ISSET (STDOUT_FILENO , &wfds))
1896         {
1897           ssize_t ret =
1898               write (STDOUT_FILENO, write_std.buf + write_std.pos,
1899                      write_std.size - write_std.pos);
1900           if (0 > ret)
1901           {
1902             fprintf (stderr, "Failed to write to STDOUT: %s\n", strerror (errno));
1903             break;
1904           }
1905           write_std.pos += ret;
1906           if (write_std.pos == write_std.size)
1907           {
1908             write_std.pos = 0;
1909             write_std.size = 0;
1910           }
1911           fprintf (stderr, "LOG : %s sends a message to STDOUT\n", dev.iface); //FIXME: debugging message
1912
1913         }
1914         if (sendsocket != -1)
1915         {
1916           if (FD_ISSET (sendsocket , &wfds))
1917           {
1918             ssize_t ret =
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?
1922             {
1923               fprintf (stderr, "Failed to write to bluetooth device: %s. Closing the socket!\n",
1924                        strerror (errno));
1925               for (i = 0; i < neighbours.size; i++)
1926               {
1927                 if (neighbours.fds[i] == sendsocket)
1928                 {
1929                   (void) close(sendsocket);
1930                   neighbours.fds[i] = -1;
1931                   break;
1932                 }
1933               }
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;
1938             }
1939             else
1940             {
1941               write_pout.pos += ret;
1942               if ((write_pout.pos != write_pout.size) && (0 != ret))
1943               {
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);
1948                 break;
1949               }
1950
1951               if (write_pout.pos == write_pout.size)
1952               {
1953                 write_pout.pos = 0;
1954                 write_pout.size = 0;
1955               }
1956               fprintf (stderr, "LOG : %s sends a message to a DEVICE\n", dev.iface); //FIXME: debugging message
1957             }
1958           }
1959         }
1960         for (i = 0; i <= maxfd; i++)
1961         {
1962           if (FD_ISSET (i, &rfds))
1963           {
1964             if (i == STDIN_FILENO)
1965             {
1966               ssize_t ret =
1967           read (i, readbuf, sizeof (readbuf));
1968               if (0 > ret)
1969               {
1970                 fprintf (stderr, "Read error from STDIN: %s\n", strerror (errno));
1971                 break; break;
1972               }
1973               if (0 == ret)
1974               {
1975                 /* stop reading... */
1976                 stdin_open = 0;
1977               }
1978               else
1979               {
1980                 mst_receive (stdin_mst, readbuf, ret);
1981                 fprintf (stderr, "LOG : %s receives a message from STDIN\n", dev.iface); //FIXME: debugging message
1982               }
1983             }
1984             else if (i == dev.fd_rfcomm)
1985             {
1986               int readsocket;
1987               struct sockaddr_rc addr = { 0 };
1988               unsigned int opt = sizeof (addr);
1989
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)
1993               {
1994                 fprintf (stderr, "Failed to accept a connection on interface: %.*s\n", IFNAMSIZ,
1995                     strerror (errno));
1996                 break;
1997               }
1998               else
1999               {
2000                 FD_SET (readsocket, &rfds);
2001                 maxfd = MAX (maxfd, readsocket);
2002
2003                 if (crt_rfds < MAX_PORTS)
2004                   rfds_list[crt_rfds++] = readsocket;
2005                 else
2006                 {
2007                   fprintf (stderr, "The limit for the read file descriptors list was \
2008                                   reached\n");
2009                   break;
2010                 }
2011               }
2012
2013             }
2014             else
2015             {
2016               struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm;
2017               ssize_t ret;
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;
2020               ret =
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),
2025                   rrm);
2026               if (0 >= ret)
2027               {
2028                 int j;
2029                 FD_CLR (i, &rfds);
2030                 close (i);
2031                  /* Remove the socket from the list */
2032                 for (j = 0; j < crt_rfds; j++)
2033                 {
2034                   if (rfds_list[j] == i)
2035                   {
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];
2039                     crt_rfds -= 1;
2040                     break;
2041                   }
2042                 }
2043
2044                 fprintf (stderr, "Read error from raw socket: %s\n", strerror (errno));
2045                 break;
2046               }
2047               if ((0 < ret) && (0 == mac_test (&rrm->frame, &dev)))
2048               {
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);
2054               }
2055             }
2056           }
2057         }
2058       }
2059     }
2060     /* Error handling, try to clean up a bit at least */
2061     mst_destroy (stdin_mst);
2062     stdin_mst = NULL;
2063     sdp_close (dev.session);
2064     (void) close (dev.fd_rfcomm);
2065     (void) close (sendsocket);
2066
2067     for (i = 0; i < crt_rfds; i++)
2068       (void) close (rfds_list[i]);
2069
2070     for (i = 0; i < neighbours.size; i++)
2071       (void) close (neighbours.fds[i]);
2072   #else
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;
2085
2086     /* check the handles */
2087     if (stdin_handle == INVALID_HANDLE_VALUE)
2088     {
2089       fprintf (stderr, "Failed to get the stdin handle\n");
2090       ExitProcess (2);
2091     }
2092
2093     if (stdout_handle == INVALID_HANDLE_VALUE)
2094     {
2095       fprintf (stderr, "Failed to get the stdout handle\n");
2096       ExitProcess (2);
2097     }
2098
2099     /* initialize windows sockets */
2100     initialize_windows_sockets();
2101
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)
2104     // {
2105     //   fprintf (stderr, "AF_BTH family is not supported\n");
2106     //   ExitProcess (2);
2107     // }
2108
2109      /* create the socket */
2110     dev.handle = GNUNET_NETWORK_socket_create (AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
2111     if (dev.handle == NULL)
2112     {
2113       fprintf (stderr, "Failed to create RFCOMM socket: ");
2114       print_last_error();
2115       ExitProcess (2);
2116     }
2117
2118
2119     if (open_device (&dev) == -1)
2120     {
2121       fprintf (stderr, "Failed to open the device\n");
2122       print_last_error();
2123       if (GNUNET_NETWORK_socket_close (dev.handle) != GNUNET_OK)
2124       {
2125         fprintf (stderr, "Failed to close the socket!\n");
2126         print_last_error();
2127       }
2128       ExitProcess (2);
2129     }
2130
2131     if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking (dev.handle, 1) )
2132     {
2133       fprintf (stderr, "Failed to change the socket mode\n");
2134       ExitProcess (2);
2135     }
2136
2137     memset (&write_std, 0, sizeof (write_std));
2138     memset (&write_pout, 0, sizeof (write_pout));
2139     stdin_open = 1;
2140
2141     rfds = GNUNET_NETWORK_fdset_create ();
2142     wfds = GNUNET_NETWORK_fdset_create ();
2143
2144   /* Send MAC address of the bluetooth interface to STDOUT first */
2145     {
2146       struct GNUNET_TRANSPORT_WLAN_HelperControlMessage macmsg;
2147
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);
2153     }
2154
2155
2156     stdin_mst = mst_create (&stdin_send_hw, &dev);
2157     stdin_open = 1;
2158
2159     fprintf (stderr, "\n-----------------------------------------------\n      Check if the program exits\n-----------------------------------------------\n");
2160
2161     int pos = 0;
2162     int stdin_pos = -1;
2163     int stdout_pos = -1;
2164     while (1)
2165     {
2166       broadcast = 0;
2167       pos = 0;
2168       stdin_pos = -1;
2169       stdout_pos = -1;
2170       sendsocket = NULL; //FIXME memleaks
2171       fprintf (stderr, "---------------------------------------------------\n");
2172
2173       GNUNET_NETWORK_fdset_zero (rfds);
2174       if ((0 == write_pout.size) && (1 == stdin_open))
2175       {
2176         stdin_pos = pos;
2177         pos +=1;
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
2180       }
2181
2182       if (0 == write_std.size)
2183       {
2184         pos += 1;
2185         fprintf (stderr, "LOG: set the listening socket %d\n", GNUNET_NETWORK_get_fd (dev.handle));
2186         GNUNET_NETWORK_fdset_set (rfds, dev.handle);
2187       }
2188
2189       for (i = 0; i < crt_rfds; i++)
2190       {
2191         pos += 1;
2192         fprintf (stderr, "LOG: adding %d read socket\n", i);
2193         GNUNET_NETWORK_fdset_set (rfds, rfds_list[i]);
2194       }
2195
2196       GNUNET_NETWORK_fdset_zero (wfds);
2197       if (0 < write_std.size)
2198       {
2199         stdout_pos = pos;
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;
2206       }
2207
2208       if (0 < write_pout.size)
2209       {
2210         if (strcmp (argv[1], "ff:ff:ff:ff:ff:ff") == 0) {
2211           fprintf(stderr, "BROADCAST\n");
2212           // skip the message
2213           broadcast = 1;
2214           memset (write_pout.buf, 0, write_pout.size);
2215           write_pout.size = 0;
2216         }
2217         else
2218         {
2219           SOCKADDR_BTH addr;
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);
2222
2223           if (sendsocket == NULL)
2224           {
2225             fprintf (stderr, "Failed to create RFCOMM socket: \n");
2226             print_last_error();
2227             ExitProcess (2);
2228           }
2229
2230           memset (&addr, 0, sizeof (addr));
2231           //addr.addressFamily = AF_BTH;
2232           if (SOCKET_ERROR ==
2233              WSAStringToAddress (argv[1], AF_BTH, NULL, (LPSOCKADDR) &addr, &addr_len))
2234           {
2235             fprintf (stderr, "Failed to translate the address: ");
2236             print_last_error();
2237             ExitProcess ( 2 ) ;
2238           }
2239           addr.port = get_channel (argv[1]); //crapa aici
2240           if (addr.port == -1)
2241           {
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
2246           }
2247           else
2248           {
2249             fprintf (stderr, "got the channel %d\n", addr.port);
2250
2251             if (GNUNET_OK != GNUNET_NETWORK_socket_connect (sendsocket, (LPSOCKADDR)&addr, addr_len))
2252             {
2253               fprintf (stderr, "Failed to connect: ");
2254               print_last_error();
2255               ExitProcess (2);
2256             }
2257
2258             if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking (sendsocket, 1) )
2259             {
2260               fprintf (stderr, "Failed to change the socket mode\n");
2261               ExitProcess (2);
2262             }
2263
2264             GNUNET_NETWORK_fdset_set (wfds, sendsocket);
2265           }
2266         }
2267       }
2268
2269       if (broadcast == 0)
2270       {
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);
2274         if (retval < 0)
2275         {
2276           fprintf (stderr, "select error\n");
2277           ExitProcess (2);
2278         }
2279         //if (GNUNET_NETWORK_fdset_isset (wfds, (struct GNUNET_NETWORK_Handle*)&stdout_handle))
2280         if (retval == stdout_pos)
2281         {
2282           fprintf (stderr, "-------------STDOUT------------\n");
2283           fprintf(stderr, "LOG : sends a message to STDOUT\n"); //FIXME: debugging message
2284           //ssize_t ret;
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);
2287           DWORD ret;
2288           if (FALSE == WriteFile (stdout_handle,  write_std.buf + write_std.pos, write_std.size - write_std.pos, &ret, NULL))
2289           {
2290             fprintf (stderr, "Failed to write to STDOUT: ");
2291             print_last_error();
2292             break;
2293           }
2294           fprintf (stderr, "--->sended: %d\n", ret);
2295           Sleep(5000);
2296           if (ret <= 0)
2297           {
2298             fprintf (stderr, "Failed to write to STDOUT\n");
2299             ExitProcess (2);
2300           }
2301
2302           write_std.pos += ret;
2303           if (write_std.pos == write_std.size)
2304           {
2305             write_std.pos = 0;
2306             write_std.size = 0;
2307           }
2308         }
2309         if (sendsocket != NULL)
2310         {
2311           if (GNUNET_NETWORK_fdset_isset (wfds, sendsocket))
2312           {
2313             fprintf (stderr, "-------------SEND------------\n");
2314             ssize_t ret;
2315             ret = GNUNET_NETWORK_socket_send (sendsocket, write_pout.buf + write_pout.pos,
2316                  write_pout.size - write_pout.pos);
2317
2318             if (GNUNET_SYSERR == ret)
2319             {
2320               fprintf (stderr, "Failed to send to the socket. Closing the socket. Error: \n");
2321               print_last_error();
2322               if (GNUNET_NETWORK_socket_close (sendsocket) != GNUNET_OK)
2323               {
2324                 fprintf (stderr, "Failed to close the sendsocket!\n");
2325                 print_last_error();
2326               }
2327               ExitProcess (2);
2328               //break;
2329             }
2330             else
2331             {
2332               write_pout.pos += ret;
2333               if ((write_pout.pos != write_pout.size) && (0 != ret))
2334               {
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);
2339                 break;
2340               }
2341
2342               if (write_pout.pos == write_pout.size)
2343               {
2344                 write_pout.pos = 0;
2345                 write_pout.size = 0;
2346
2347               }
2348               fprintf(stderr, "LOG : sends a message to a DEVICE\n"); //FIXME: debugging message
2349             }
2350           }
2351         }
2352
2353         //if (GNUNET_NETWORK_fdset_isset (rfds, (struct GNUNET_NETWORK_Handle*)&stdin_handle))
2354         if (retval == stdin_pos) //FALSEEE!!!! NUUUUU EEE VOOIEE!!_----------------------------------------------------------?
2355         {
2356           fprintf (stderr, "-------------STDIN------------\n");
2357           //ssize_t ret;
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));
2360           DWORD ret;
2361           if (FALSE == ReadFile (stdin_handle, readbuf, sizeof (readbuf), &ret, NULL))  /* do nothing asynchronous */
2362           {
2363             fprintf (stderr, "Read error from STDIN: ");
2364             print_last_error();
2365             break;
2366           }
2367           if (0 == ret)
2368           {
2369             /* stop reading... */
2370             stdin_open = 0;
2371           } else {
2372             mst_receive (stdin_mst, readbuf, ret);
2373             fprintf (stderr, "LOG : receives a message from STDIN\n"); //FIXME: debugging message
2374           }
2375         }
2376         else
2377         if (GNUNET_NETWORK_fdset_isset (rfds, dev.handle))
2378         {
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)
2384           {
2385             fprintf (stderr, "Accept error %d: ", GetLastError());
2386             print_last_error();
2387             ExitProcess (2);
2388           }
2389           else
2390           {
2391             if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking (readsocket, 1) )
2392             {
2393               fprintf (stderr, "Failed to change the socket mode\n");
2394               ExitProcess (2);
2395             }
2396             GNUNET_NETWORK_fdset_set (rfds, readsocket);
2397
2398             if (crt_rfds < MAX_PORTS)
2399               rfds_list[crt_rfds++] = readsocket;
2400             else
2401             {
2402               fprintf (stderr, "The limit for the read file descriptors list was reached\n");
2403               break;
2404             }
2405           }
2406         }
2407         else
2408         for (i = 0; i < crt_rfds; i++)
2409         {
2410           if (GNUNET_NETWORK_fdset_isset (rfds, rfds_list[i]))
2411           {
2412             struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm;
2413             ssize_t ret;
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),
2420                   rrm);
2421             fprintf (stderr, "MESSAGE: %s\n", readbuf);
2422             if (0 >= ret)
2423             {
2424
2425               //TODO remove the socket from the list
2426               if (GNUNET_NETWORK_socket_close (rfds_list[i]) != GNUNET_OK)
2427               {
2428                 fprintf (stderr, "Failed to close the sendsocket!\n");
2429                 print_last_error();
2430               }
2431
2432               fprintf (stderr, "Read error from raw socket: ");
2433               print_last_error();
2434               break;
2435
2436             }
2437             if ((0 < ret) && (0 == mac_test (&rrm->frame, &dev)))
2438             {
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);
2444             }
2445             break;
2446           }
2447         }
2448       }
2449     }
2450
2451     mst_destroy (stdin_mst);
2452     stdin_mst = NULL;
2453
2454     if (GNUNET_NETWORK_socket_close (dev.handle) != GNUNET_OK)
2455     {
2456       fprintf (stderr, "Failed to close the socket!\n");
2457       print_last_error();
2458     }
2459
2460     for (i = 0; i < crt_rfds; i++)
2461     {
2462       if (GNUNET_NETWORK_socket_close (rfds_list[i]) != GNUNET_OK)
2463       {
2464         fprintf (stderr, "Failed to close the socket!\n");
2465         print_last_error();
2466       }
2467     }
2468
2469     WSACleanup();
2470   #endif
2471   return 1;                     /* we never exit 'normally' */
2472 }