/**
- * Maximum number of loops without inquiring for a new devices.
+ * Maximum number of loops without inquiring for new devices.
*/
-#define MAX_LOOPS 3
+#define MAX_LOOPS 5
/**
* struct for storing the information of the hardware. There is only
do_align:
if (mst->pos < mst->off)
{
- fprintf (stderr, "We processed too many bytes!\n");
+ //fprintf (stderr, "We processed too many bytes!\n");
return GNUNET_SYSERR;
}
if ((mst->curr_buf - mst->off < sizeof (struct GNUNET_MessageHeader)) ||
/**
* Function for assigning a port number
+ *
* @param socket the socket used to bind
* @param addr pointer to the rfcomm address
* @return 0 on success
{
int port, status;
- /* Bind every possible port (from 0 to 30) and stop when bind doesn't fail */
+ /* Bind every possible port (from 0 to 30) and stop when binding doesn't fail */
//FIXME : it should start from port 1, but on my computer it doesn't work :)
for (port = 3; port <= 30; port++)
{
/**
* Function used for creating the service record and registering it.
+ *
* @param dev pointer to the device struct
* @param rc_channel the rfcomm channel
* @return 0 on success
* 6. register the service record to the local SDP server
* 7. cleanup
*/
-
- //FIXME: probably this is not the best idea. I should find a different uuid
uint8_t svc_uuid_int[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
dev->pl_mac.mac[5], dev->pl_mac.mac[4], dev->pl_mac.mac[3],
dev->pl_mac.mac[2], dev->pl_mac.mac[1], dev->pl_mac.mac[0]};
-// const char *service_name = "GNUnet";
const char *service_dsc = "Bluetooth plugin services";
const char *service_prov = "GNUnet provider";
uuid_t root_uuid, rfcomm_uuid, svc_uuid;
/**
* Function for searching and browsing for a service. This will return the
* port number on which the service is running.
+ *
* @param dev pointer to the device struct
* @param dest target address
* @return channel
get_channel(struct HardwareInfos *dev, bdaddr_t dest)
{
/**
- * 1. detect all nearby devices //FIXME : Connect directly to the device with the service
+ * 1. detect all nearby devices
* 2. for each device:
* 2.1. connect to the SDP server running
* 2.2. get a list of service records with the specific UUID
/**
* Read from the socket and put the result into the buffer for transmission to 'stdout'.
+ *
* @param sock file descriptor for reading
* @param buf buffer to read to; first bytes will be the 'struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame',
* followed by the actual payload
unsigned char *buf, size_t buf_size,
struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *ri)
{
- /**
- * 1. Read from the socket in a temporary buffer (check for errors)
- * 2. Detect if the crc exists
- * 3. Write the result to the buffer
- */
unsigned char tmpbuf[buf_size];
ssize_t count;
int len;
return -1;
}
- /* Get the channel used */
+ /* Get the channel used */ //FIXME probably not needed anymore
memset (&rc_addr, 0, sizeof (rc_addr));
len = sizeof (rc_addr);
if (0 > getsockname (sock, (struct sockaddr *) &rc_addr, (socklen_t *) &len))
memset (ri, 0, sizeof (*ri));
ri->ri_channel = rc_addr.rc_channel;
- /* detect CRC32 at the end */
+ /* Detect CRC32 at the end */
if (0 == check_crc_buf_osdep (tmpbuf, count - sizeof (uint32_t)))
{
count -= sizeof(uint32_t);
*/
static int
open_device (struct HardwareInfos *dev)
-{
- /**
- * 1. Open a HCI socket (if RFCOMM protocol is used. If not, the HCI socket is
- * saved in dev->rfcomm).
- * 2. Find the device id (request a list with all the devices and find the one
- * with the dev->iface name)
- * 3. If the interface is down try to get it up
- * 4. Bind the RFCOMM socket to the interface using the bind_socket() method and register
- * a SDP service
- * 5. For now use a hard coded port number(channel) value
- * FIXME : if I use HCI sockets , should I enable RAW_SOCKET MODE?!?!?!
- */
-
+{
int i, dev_id = -1, fd_hci;
struct
{
struct hci_dev_list_req list;
struct hci_dev_req dev[HCI_MAX_DEV];
- } request; //used for detecting the local devices
+ } request; //used for detecting the local devices
struct sockaddr_rc rc_addr = { 0 }; //used for binding
/* Initialize the neighbour structure */
for (i = 0; i < MAX_PORTS; i++)
neighbours.fds[i] = -1;
+ /* Open a HCI socket */
fd_hci = socket (AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
if (fd_hci < 0)
dev_id = dev_info.dev_id; //the device was found
/**
* Copy the MAC address to the device structure
- * FIXME: probably this is not the best solution
*/
memcpy (&dev->pl_mac, &dev_info.bdaddr, sizeof (bdaddr_t));
- /* Check if the interface is UP */
+ /* Check if the interface is up */
if (hci_test_bit (HCI_UP, (void *) &dev_info.flags) == 0)
{
- /* Bring interface up */ //FIXME should I check if is HCI_RUNNING ?!?!??!
+ /* Bring the interface up */
if (ioctl (fd_hci, HCIDEVUP, dev_info.dev_id))
{
fprintf (stderr, "ioctl(HCIDEVUP) on interface `%.*s' failed: %s\n",
}
}
-
- //FIXME : Sniff mode!?!
- //FIXME : RAW MODE?!?
-
break;
}
{
fprintf (stderr, "Failed to listen on socket for interface `%.*s': %s\n", IFNAMSIZ,
dev->iface, strerror (errno));
- return 3;
+ return 1;
}
/**
- * Process data from the stdin. Takes the message forces the sender MAC to be correct
- * and puts it into our buffer for transmission to the kernel. (the other device).
+ * Process data from the stdin. Takes the message, forces the sender MAC to be correct
+ * and puts it into our buffer for transmission to the receiver.
*
* @param cls pointer to the device struct ('struct HardwareInfos*')
* @param hdr pointer to the start of the packet
* overwrite it with OUR MAC address to prevent mischief */
mac_set (blueheader, dev);
memcpy (&blueheader->addr1, &header->frame.addr1,
- sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); //FIXME is this correct?
+ sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
write_pout.size = sendsize;
}
/**
* Broadcast a HELLO message for peer discovery
+ *
* @param dev pointer to the device struct
* @param dev pointer to the socket which was added to the set
* @return 0 on success
inquiry_devices: //skip the conditions and force a inquiry for new devices
{
/**
- * It means that I sent HELLO message to all the devices from the list so I should search
- * for another devices or that this is the first time when I do a search for devices.
+ * It means that I sent HELLO messages to all the devices from the list and I should search
+ * for new ones or that this is the first time when I do a search.
*/
inquiry_info *devices = NULL;
int i, responses, max_responses = MAX_PORTS;
/* sanity checks */
if (neighbours.size >= MAX_PORTS)
{
- fprintf (stderr, "%s reached the top limit for the discovarable devices\n", dev->iface);
+ fprintf (stderr, "%.*s reached the top limit for the discovarable devices\n", IFNAMSIZ, dev->iface);
return 2;
}
neighbours.dev_id = hci_devid (addr);
if (neighbours.dev_id < 0)
{
- fprintf (stderr, "Failed to get the device id for interface %s : %s\n",
+ fprintf (stderr, "Failed to get the device id for interface %.*s : %s\n", IFNAMSIZ,
dev->iface, strerror (errno));
return 1;
}
devices = malloc (max_responses * sizeof (inquiry_info));
if (devices == NULL)
{
- fprintf (stderr, "Failed to allocate memory for inquiry info list on interface %s\n",
+ fprintf (stderr, "Failed to allocate memory for inquiry info list on interface %.*s\n", IFNAMSIZ,
dev->iface);
return 1;
}
responses = hci_inquiry (neighbours.dev_id, 8, max_responses, NULL, &devices, IREQ_CACHE_FLUSH);
if (responses < 0)
{
- fprintf (stderr, "Failed to inquiry on interface %s\n", dev->iface);
+ fprintf (stderr, "Failed to inquiry on interface %.*s\n", IFNAMSIZ, dev->iface);
return 1;
}
- fprintf (stderr, "Found %d devices\n", responses); //FIXME delete it after debugging stage
+ fprintf (stderr, "LOG : Found %d devices\n", responses); //FIXME delete it after debugging stage
if (responses == 0)
{
- fprintf (stderr, "No devices discoverable\n");
+ fprintf (stderr, "LOG : No devices discoverable\n");
return 1;
}
/* sanity check */
if (i >= MAX_PORTS)
{
- fprintf (stderr, "%s reached the top limit for the discoverable devices (after inquiry)\n", dev->iface);
+ fprintf (stderr, "%.*s reached the top limit for the discoverable devices (after inquiry)\n", IFNAMSIZ,
+ dev->iface);
return 2;
}
if (memcmp (&(devices + i)->bdaddr, &(neighbours.devices[j]), sizeof (bdaddr_t)) == 0)
{
found = 1;
- fprintf (stderr, "the device already exists on the list\n"); //FIXME debugging message
+ fprintf (stderr, "LOG : the device already exists on the list\n"); //FIXME debugging message
break;
}
}
char addr[19] = { 0 };
ba2str (&(devices +i)->bdaddr, addr);
- fprintf (stderr, "%s was added to the list\n", addr); //FIXME debugging message
+ fprintf (stderr, "LOG : %s was added to the list\n", addr); //FIXME debugging message
memcpy (&(neighbours.devices[neighbours.size++]), &(devices + i)->bdaddr, sizeof (bdaddr_t));
}
}
/* Try to connect to a new device from the list */
while (neighbours.pos < neighbours.size)
{
- /* Check if we are connected to this device */
+ /* Check if we are already connected to this device */
if (neighbours.fds[neighbours.pos] == -1)
{
addr_rc.rc_channel = get_channel (dev, addr_rc.rc_bdaddr);
*sendsocket = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
-
if (connect (*sendsocket, (struct sockaddr *)&addr_rc, sizeof (addr_rc)) == 0)
{
neighbours.fds[neighbours.pos++] = *sendsocket;
connection_successful = 1;
char addr[19] = { 0 };
ba2str (&(neighbours.devices[neighbours.pos - 1]), addr);
- fprintf (stderr, "Connected to %s\n", addr);
+ fprintf (stderr, "LOG : Connected to %s\n", addr);
break;
}
char addr[19] = { 0 };
errno_copy = errno; //Save a copy for later
ba2str (&(neighbours.devices[neighbours.pos]), addr);
- fprintf (stderr, "Couldn't connect on device %s, error : %s\n", addr, strerror(errno));
- if (errno != ECONNREFUSED) //FIXME nu merge!
+ fprintf (stderr, "LOG : Couldn't connect on device %s, error : %s\n", addr, strerror(errno));
+ if (errno != ECONNREFUSED) //FIXME be sure that this works
{
- fprintf (stderr, "Removes %d device from the list\n", neighbours.pos);
+ fprintf (stderr, "LOG : Removes %d device from the list\n", neighbours.pos);
/* Remove the device from the list */
memcpy (&neighbours.devices[neighbours.pos], &neighbours.devices[neighbours.size - 1], sizeof (bdaddr_t));
memset (&neighbours.devices[neighbours.size - 1], 0, sizeof (bdaddr_t));
}
else
{
- fprintf (stderr, "Search for a new device\n"); //FIXME debugging message
+ fprintf (stderr, "LOG : Search for a new device\n"); //FIXME debugging message
neighbours.pos += 1;
}
}
if (searching_devices_count == MAX_LOOPS)
{
- fprintf (stderr, "Force to inquiry for new devices\n");
+ fprintf (stderr, "LOG : Force to inquiry for new devices\n");
searching_devices_count = 0;
goto inquiry_devices;
}
{
if (errno_copy == ECONNREFUSED)
{
- fprintf (stderr, "No device found. Go back and search again\n"); //FIXME debugging message
+ fprintf (stderr, "LOG : No device found. Go back and search again\n"); //FIXME debugging message
new_device = 1;
loops += 1;
goto search_for_devices;
/**
* Main function of the helper. This code accesses a bluetooth interface
* forwards traffic in both directions between the bluetooth interface and
- * stdin/stdout of this process. Error messages are written to stdout.
+ * stdin/stdout of this process. Error messages are written to stderr.
*
* @param argc number of arguments, must be 2
* @param argv arguments only argument is the name of the interface (i.e. 'hci0')
* @return 0 on success (never happens, as we don't return unless aborted), 1 on error
*
- **** same as the one from gnunet-helper-transport-wlan.c ****
+ **** similar to gnunet-helper-transport-wlan.c ****
*/
int
main (int argc, char *argv[])
FD_ZERO (&rfds);
if ((0 == write_pout.size) && (1 == stdin_open))
{
- // fprintf (stderr, "LOG : %s adds STDIN to rfds\n", dev.iface); //FIXME: debugging message
FD_SET (STDIN_FILENO, &rfds);
maxfd = MAX (maxfd, STDIN_FILENO);
}
if (0 == write_std.size)
{
- // fprintf (stderr, "LOG : %s adds fd_rfcomm to rfds\n", dev.iface); //FIXME: debugging message
FD_SET (dev.fd_rfcomm, &rfds);
maxfd = MAX (maxfd, dev.fd_rfcomm);
}
for (i = 0; i < crt_rfds; i++) // it can receive messages from multiple devices
{
- // fprintf (stderr, "LOG : %s adds extra fds to rfds\n", dev.iface); //FIXME: debugging message
FD_SET (rfds_list[i], &rfds);
maxfd = MAX (maxfd, rfds_list[i]);
}
FD_ZERO (&wfds);
if (0 < write_std.size)
{
- // fprintf (stderr, "LOG : %s adds STDOUT to wfds\n", dev.iface); //FIXME: debugging message
FD_SET (STDOUT_FILENO, &wfds);
maxfd = MAX (maxfd, STDOUT_FILENO);
}
{
struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *frame;
/* Get the destination address */
- //FIXME : not sure if this is correct
frame = (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *) write_pout.buf;
if (memcmp (&frame->addr1, &dev.pl_mac,
sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)
{
- fprintf (stderr, "LOG : %s has a message for him:)\n", dev.iface); //FIXME: debugging message
- memset (&write_pout, 0, sizeof (write_pout)); // clear the buffer
+ broadcast = 1;
+ memset (&write_pout, 0, sizeof (write_pout)); //clear the buffer
}
else if (memcmp (&frame->addr1, &broadcast_address,
sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)
{
broadcast = 1;
memset (&write_pout, 0, sizeof (write_pout)); //remove the message
- fprintf (stderr, "Skip the broadcast message (pos %d, size %d)\n", neighbours.pos, neighbours.size);
+ fprintf (stderr, "LOG : Skip the broadcast message (pos %d, size %d)\n", neighbours.pos, neighbours.size);
}
else
{
else
{
int found = 0;
+ int pos = 0;
/* Search if the address already exists on the list */
for (i = 0; i < neighbours.size; i++)
{
- if (memcmp (&frame->addr1, &(neighbours.devices[i]), sizeof (bdaddr_t)) == 0 && neighbours.fds[i] != -1)
+ if (memcmp (&frame->addr1, &(neighbours.devices[i]), sizeof (bdaddr_t)) == 0)
{
- found = 1;
- FD_SET (neighbours.fds[i], &wfds);
- maxfd = MAX (maxfd, neighbours.fds[i]);
- sendsocket = neighbours.fds[i];
- fprintf (stderr, "LOG: the address was found in the list\n");
- break;
+ pos = i;
+ if (neighbours.fds[i] != -1)
+ {
+ found = 1; //save the position where it was found
+ FD_SET (neighbours.fds[i], &wfds);
+ maxfd = MAX (maxfd, neighbours.fds[i]);
+ sendsocket = neighbours.fds[i];
+ fprintf (stderr, "LOG: the address was found in the list\n");
+ break;
+ }
}
}
if (found == 0)
addr.rc_family = AF_BLUETOOTH;
addr.rc_channel = get_channel (&dev, addr.rc_bdaddr);
- /***
- *TODO: use a NON-BLOCKING socket
- * sock_flags = fcntl (sendsocket, F_GETFL, 0);
- * fcntl( sendsocket, F_SETFL, sock_flags | O_NONBLOCK);
- */
int tries = 0;
connect_retry:
status = connect (sendsocket, (struct sockaddr *) &addr, sizeof (addr));
{
if (errno == ECONNREFUSED && tries < 2)
{
- fprintf (stderr, "%s failed to connect. Trying again!\n", dev.iface);
+ fprintf (stderr, "LOG : %.*s failed to connect. Trying again!\n", IFNAMSIZ, dev.iface);
tries++;
goto connect_retry;
}
else if (errno == EBADF)
{
- fprintf (stderr, "%s failed to connect : %s. Skip it!\n", dev.iface, strerror (errno));
+ fprintf (stderr, "LOG : %s failed to connect : %s. Skip it!\n", dev.iface, strerror (errno));
memset (&write_pout, 0, sizeof (write_pout));
broadcast = 1;
}
else
{
- fprintf (stderr, "%s failed to connect : %s. Try again later!\n", dev.iface, strerror (errno));
+ fprintf (stderr, "LOG : %s failed to connect : %s. Try again later!\n", dev.iface, strerror (errno));
memset (&write_pout, 0, sizeof (write_pout));
broadcast = 1;
}
{
FD_SET (sendsocket, &wfds);
maxfd = MAX (maxfd, sendsocket);
- fprintf (stderr, "Connection successful\n");
- /* Add the new device to the discovered devices list */
- if (neighbours.size < MAX_PORTS)
+ fprintf (stderr, "LOG : Connection successful\n");
+ if (pos != 0) // save the socket
{
- neighbours.fds[neighbours.size] = sendsocket;
- memcpy (&(neighbours.devices[neighbours.size++]), &addr.rc_bdaddr, sizeof (bdaddr_t));
+ neighbours.fds[pos] = sendsocket;
}
else
{
- fprintf (stderr, "The top limit for the discovarable devices' list was reached\n");
+ /* Add the new device to the discovered devices list */
+ if (neighbours.size < MAX_PORTS)
+ {
+ neighbours.fds[neighbours.size] = sendsocket;
+ memcpy (&(neighbours.devices[neighbours.size++]), &addr.rc_bdaddr, sizeof (bdaddr_t));
+ }
+ else
+ {
+ fprintf (stderr, "The top limit for the discovarable devices' list was reached\n");
+ }
}
}
}
{
/* Select a fd which is ready for action :) */
{
- int retval = select (maxfd + 1, &rfds, &wfds, NULL, NULL); //FIXME : when a device close the connection remove the socket from the list
+ int retval = select (maxfd + 1, &rfds, &wfds, NULL, NULL);
if ((-1 == retval) && (EINTR == errno))
continue;
if (0 > retval && errno != EBADF) // we handle BADF errors later
ssize_t ret =
write (sendsocket, write_pout.buf + write_std.pos,
write_pout.size - write_pout.pos);
- if (0 > ret) //FIXME should I check first the error type?
+ if (0 > ret) //FIXME should I first check the error type?
{
fprintf (stderr, "Failed to write to bluetooth device: %s. Closing the socket!\n",
- strerror (errno));
-
+ strerror (errno));
for (i = 0; i < neighbours.size; i++)
{
if (neighbours.fds[i] == sendsocket)
break;
}
}
- //memset (&(write_pout.buf + write_std.pos), 0, (write_pout.size - write_pout.pos)) // FIXME should I remove the message? or try to resend it
- //write_pour.pos = 0 ; write_pout.size = 0;
+ /* Remove the message */
+ memset (&write_pout.buf + write_std.pos, 0, (write_pout.size - write_pout.pos));
+ write_pout.pos = 0 ;
+ write_pout.size = 0;
}
else
{
write_pout.pos += ret;
if ((write_pout.pos != write_pout.size) && (0 != ret))
{
- /* we should not get partial sends with packet-oriented devices... */
+ /* We should not get partial sends with packet-oriented devices... */
fprintf (stderr, "Write error, partial send: %u/%u\n",
(unsigned int) write_pout.pos,
(unsigned int) write_pout.size);
}
}
}
- for (i = 0; i <= maxfd; i++) //FIXME it should be incremented
+ for (i = 0; i <= maxfd; i++)
{
if (FD_ISSET (i, &rfds))
{
if (0 > ret)
{
fprintf (stderr, "Read error from STDIN: %s\n", strerror (errno));
- break;
+ break; break;
}
if (0 == ret)
{
fprintf(stderr, "LOG : %s accepts a message\n", dev.iface); //FIXME: debugging message
if (readsocket == -1)
{
- fprintf (stderr, "Failed to accept a connection on interface: %s\n",
+ fprintf (stderr, "Failed to accept a connection on interface: %.*s\n", IFNAMSIZ,
strerror (errno));
- return -1; //FIXME probably I should ignore the error and keep the process alive
+ break;
}
else
{
- sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame);
rrm->header.size = htons (write_std.size);
rrm->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER);
-
- /* Remove the socket from the list */
- int j;
- for (j = 0; j < crt_rfds; j++)
- {
- if (i == rfds_list[crt_rfds])
- {
- rfds_list[j] ^= rfds_list[crt_rfds];
- rfds_list[crt_rfds] ^= rfds_list[j];
- rfds_list[j] ^= rfds_list[crt_rfds];
- crt_rfds -= 1;
- break;
- }
- }
}
}
}
projects / oweals / gnunet.git / blobdiff