#include "gnunet_protocols.h"
#include "plugin_transport_wlan.h"
+/**
+ * Maximum number of ports assignable for RFCOMMM protocol.
+ */
#define MAX_PORTS 30
/**
#define MAXLINE 4096
+/**
+ * Maximum number of loops without inquiring for new devices.
+ */
+#define MAX_LOOPS 5
+
/**
* struct for storing the information of the hardware. There is only
* one of these.
char buf[MAXLINE * 2];
};
+/**
+ * Devices buffer used to keep a list with all the discoverable devices in
+ * order to send them HELLO messages one by one when it receive a broadcast message.
+ */
+struct BroadcastMessages
+{
+ /* List with the discoverable devices' addresses */
+ bdaddr_t devices[MAX_PORTS]; //FIXME I should use a linked list but 30 isn't such a big number
+
+ /* List with the open sockets */
+ int fds[MAX_PORTS];
+
+
+ /* The number of the devices */
+ int size;
+
+ /* The current position */
+ int pos;
+
+ /* The device id */
+ int dev_id;
+};
+
/**
* Buffer for data read from stdin to be transmitted to the bluetooth device
*/
static struct SendBuffer write_std;
+/**
+ * Address used to identify the broadcast messages.
+ */
+static struct GNUNET_TRANSPORT_WLAN_MacAddress broadcast_address = {{255, 255, 255, 255, 255, 255}};
-static struct GNUNET_TRANSPORT_WLAN_MacAddress broadcast = {{255, 255, 255, 255, 255, 255}};
+/**
+ * Buffer with the discoverable devices.
+ */
+static struct BroadcastMessages neighbours;
+
+static int searching_devices_count = 0;
/* *********** specialized version of server_mst.c begins here ********** */
/* ****** this is the same version as the one used in gnunet-helper-transport-wlan.c ****** */
*/
static int
mst_receive (struct MessageStreamTokenizer *mst,
- const char *buf, size_t size)
+ const char *buf, size_t size)
{
const struct GNUNET_MessageHeader *hdr;
size_t delta;
ret = GNUNET_OK;
ibuf = (char *) mst->hdr;
-
while (mst->pos > 0)
{
do_align:
+ if (mst->pos < mst->off)
+ {
+ //fprintf (stderr, "We processed too many bytes!\n");
+ return GNUNET_SYSERR;
+ }
if ((mst->curr_buf - mst->off < sizeof (struct GNUNET_MessageHeader)) ||
(0 != (mst->off % ALIGN_FACTOR)))
{
}
if (mst->pos - mst->off < sizeof (struct GNUNET_MessageHeader))
{
+ //FIXME should I reset ??
+ // mst->off = 0;
+ // mst->pos = 0;
return GNUNET_OK;
}
hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
if (want < sizeof (struct GNUNET_MessageHeader))
{
fprintf (stderr,
- "Received invalid message from stdin\n");
- exit (1);
+ "Received invalid message from stdin\n");
+ return GNUNET_SYSERR;
}
- if (mst->curr_buf - mst->off < want)
+ if ((mst->curr_buf - mst->off < want) &&
+ (mst->off > 0))
{
/* need more space */
mst->pos -= mst->off;
}
if (want > mst->curr_buf)
{
+ if (mst->off != 0)
+ {
+ fprintf (stderr, "Error! We should proceeded 0 bytes\n");
+ return GNUNET_SYSERR;
+ }
mst->hdr = realloc (mst->hdr, want);
if (NULL == mst->hdr)
{
- fprintf (stderr, "Failed to allocate buffer for alignment\n");
- exit (1);
+ fprintf (stderr, "Failed to allocate buffer for alignment\n");
+ exit (1);
}
ibuf = (char *) mst->hdr;
mst->curr_buf = want;
if (mst->pos - mst->off < want)
{
delta = GNUNET_MIN (want - (mst->pos - mst->off), size);
+ if (mst->pos + delta > mst->curr_buf)
+ {
+ fprintf (stderr, "The size of the buffer will be exceeded!\n");
+ return GNUNET_SYSERR;
+ }
memcpy (&ibuf[mst->pos], buf, delta);
mst->pos += delta;
buf += delta;
}
if (mst->pos - mst->off < want)
{
+ //FIXME should I use this?
+ // mst->off = 0;
+ // mst->pos = 0;
return GNUNET_OK;
}
mst->cb (mst->cb_cls, hdr);
mst->pos = 0;
}
}
-
+ if (0 != mst->pos)
+ {
+ fprintf (stderr, "There should some valid bytes in the buffer on this stage\n");
+ return GNUNET_SYSERR;
+ }
while (size > 0)
{
if (size < sizeof (struct GNUNET_MessageHeader))
want = ntohs (hdr->size);
if (want < sizeof (struct GNUNET_MessageHeader))
{
- fprintf (stderr,
- "Received invalid message from stdin\n");
- exit (1);
+ fprintf (stderr,
+ "Received invalid message from stdin\n");
+ //exit (1);
+ mst->off = 0;
+ return GNUNET_SYSERR;
}
if (size < want)
break; /* or not, buffer incomplete, so copy to private buffer... */
mst->hdr = realloc (mst->hdr, size + mst->pos);
if (NULL == mst->hdr)
{
- fprintf (stderr, "Failed to allocate buffer for alignment\n");
- exit (1);
+ fprintf (stderr, "Failed to allocate buffer for alignment\n");
+ exit (1);
}
ibuf = (char *) mst->hdr;
mst->curr_buf = size + mst->pos;
if (mst->pos + size > mst->curr_buf)
{
fprintf (stderr,
- "Assertion failed\n");
+ "Assertion failed\n");
exit (1);
}
memcpy (&ibuf[mst->pos], buf, size);
/**
* 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
/**
* 1. initializations
* 2. set the service ID, class, profile information
- * 3. make the service record publicly nrowsable
+ * 3. make the service record publicly browsable
* 4. register the RFCOMM channel
* 5. set the name, provider and description
* 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, l2cap_uuid, svc_uuid;
- sdp_list_t *root_list = 0, *rfcomm_list = 0, *l2cap_list = 0,
- *proto_list = 0, *access_proto_list = 0, *svc_list = 0;
+ uuid_t root_uuid, rfcomm_uuid, svc_uuid;
+ sdp_list_t *root_list = 0, *rfcomm_list = 0, *proto_list = 0,
+ *access_proto_list = 0, *svc_list = 0;
sdp_record_t *record = 0;
sdp_data_t *channel = 0;
sdp_list_append (rfcomm_list, channel);
proto_list = sdp_list_append (0, rfcomm_list);
- /* Set L2CAP information FIXME: probably not needed */
- // sdp_uuid16_create (&l2cap_uuid, L2CAP_UUID);
- // l2cap_list = sdp_list_append (0, &l2cap_uuid);
- //sdp_list_append (proto_list, l2cap_list);
-
/* Set protocol information */
access_proto_list = sdp_list_append (0, proto_list);
sdp_set_access_protos (record, access_proto_list);
sdp_data_free (channel);
sdp_list_free (root_list, 0);
sdp_list_free (rfcomm_list, 0);
- sdp_list_free (l2cap_list, 0);
sdp_list_free (proto_list, 0);
sdp_list_free (access_proto_list, 0);
sdp_list_free (svc_list, 0);
/**
* 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 */
+ neighbours.dev_id = -1;
+ 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)
if (strcmp (dev_info.name, dev->iface) == 0)
{
- //char addr[19] = { 0 }; //the device MAC address
dev_id = dev_info.dev_id; //the device was found
-
- // ba2str (&dev_info.bdaddr, addr); //get the device's MAC address
/**
* 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;
}
-
-//TODO
/**
* 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
*/
-static void
-send_broadcast ()
+static int
+send_broadcast (struct HardwareInfos *dev, int *sendsocket)
{
- // Use a hard coded port number to send hello messages to all the neighbours
+ int new_device = 0;
+ int loops = 0;
+
+ search_for_devices:
+ if ((neighbours.size == neighbours.pos && new_device == 1) || neighbours.size == 0)
+ {
+ inquiry_devices: //skip the conditions and force a inquiry for new 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", IFNAMSIZ, dev->iface);
+ return 2;
+ }
+
+ /* Get the device id */
+ if (neighbours.dev_id == -1)
+ {
+ char addr[19] = { 0 }; //the device MAC address
+
+ ba2str ((bdaddr_t *) &dev->pl_mac, addr);
+ neighbours.dev_id = hci_devid (addr);
+ if (neighbours.dev_id < 0)
+ {
+ 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", 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", IFNAMSIZ, dev->iface);
+ return 1;
+ }
+
+ fprintf (stderr, "LOG : Found %d devices\n", responses); //FIXME delete it after debugging stage
+
+ if (responses == 0)
+ {
+ fprintf (stderr, "LOG : No devices discoverable\n");
+ return 1;
+ }
+
+ for (i = 0; i < responses; i++)
+ {
+ int j;
+ int found = 0;
+
+ /* sanity check */
+ if (i >= MAX_PORTS)
+ {
+ fprintf (stderr, "%.*s reached the top limit for the discoverable devices (after inquiry)\n", IFNAMSIZ,
+ dev->iface);
+ return 2;
+ }
+
+ /* Search if the address already exists on the list */
+ for (j = 0; j < neighbours.size; j++)
+ {
+ if (memcmp (&(devices + i)->bdaddr, &(neighbours.devices[j]), sizeof (bdaddr_t)) == 0)
+ {
+ found = 1;
+ fprintf (stderr, "LOG : the device already exists on the list\n"); //FIXME debugging message
+ break;
+ }
+ }
+
+ if (found == 0)
+ {
+ char addr[19] = { 0 };
+
+ ba2str (&(devices +i)->bdaddr, addr);
+ 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));
+ }
+ }
+
+ free (devices);
+ }
+ }
+
+ int connection_successful = 0;
+ struct sockaddr_rc addr_rc = { 0 };
+ int errno_copy = 0;
+ addr_rc.rc_family = AF_BLUETOOTH;
+
+ /* Try to connect to a new device from the list */
+ while (neighbours.pos < neighbours.size)
+ {
+ /* Check if we are already connected to this device */
+ if (neighbours.fds[neighbours.pos] == -1)
+ {
+
+ memset (&addr_rc.rc_bdaddr, 0, sizeof (addr_rc.rc_bdaddr));
+ memcpy (&addr_rc.rc_bdaddr, &(neighbours.devices[neighbours.pos]), sizeof (addr_rc.rc_bdaddr));
+
+ 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, "LOG : Connected to %s\n", addr);
+
+ break;
+ }
+ else
+ {
+ char addr[19] = { 0 };
+ errno_copy = errno; //Save a copy for later
+ ba2str (&(neighbours.devices[neighbours.pos]), addr);
+ 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, "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));
+ neighbours.fds[neighbours.pos] = neighbours.fds[neighbours.size - 1];
+ neighbours.fds[neighbours.size - 1] = -1;
+ neighbours.size -= 1;
+ }
+
+ neighbours.pos += 1;
+
+ if (neighbours.pos >= neighbours.size)
+ neighbours.pos = 0;
+
+ loops += 1;
+
+ if (loops == MAX_LOOPS) //don't get stuck trying to connect to one device
+ return 1;
+ }
+ }
+ else
+ {
+ fprintf (stderr, "LOG : Search for a new device\n"); //FIXME debugging message
+ neighbours.pos += 1;
+ }
+ }
+
+ /* Cycle on the list */
+ if (neighbours.pos == neighbours.size)
+ {
+ neighbours.pos = 0;
+ searching_devices_count += 1;
+
+ if (searching_devices_count == MAX_LOOPS)
+ {
+ fprintf (stderr, "LOG : Force to inquiry for new devices\n");
+ searching_devices_count = 0;
+ goto inquiry_devices;
+ }
+ }
+ /* If a new device wasn't found, search an old one */
+ if (connection_successful == 0)
+ {
+ int loop_check = neighbours.pos;
+ while (neighbours.fds[neighbours.pos] == -1)
+ {
+ if (neighbours.pos == neighbours.size)
+ neighbours.pos = 0;
+
+ if (neighbours.pos == loop_check)
+ {
+ if (errno_copy == ECONNREFUSED)
+ {
+ fprintf (stderr, "LOG : No device found. Go back and search again\n"); //FIXME debugging message
+ new_device = 1;
+ loops += 1;
+ goto search_for_devices;
+ }
+ else
+ {
+ return 1; // Skip the broadcast message
+ }
+ }
+
+ neighbours.pos += 1;
+ }
+
+ *sendsocket = neighbours.fds[neighbours.pos++];
+ }
+
+ return 0;
}
+
/**
* 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[])
struct MessageStreamTokenizer *stdin_mst;
int raw_eno, i;
uid_t uid;
- int crt_rfds = 0, crt_wfds = 0, rfds_list[MAX_PORTS], wfds_list[MAX_PORTS];
-
+ int crt_rfds = 0, rfds_list[MAX_PORTS];
+ int broadcast, sendsocket;
/* Assert privs so we can modify the firewall rules! */
uid = getuid ();
#ifdef HAVE_SETRESUID
stdin_mst = mst_create (&stdin_send_hw, &dev);
stdin_open = 1;
+ fprintf (stderr, "\n-----------------------------------------------\n Check if the program exits\n-----------------------------------------------\n");
+ /**
+ * TODO : When a connection fails I should ignore only the CONTROL messages.
+ * For DATA messages I should retry to send the message until it doesn't fail
+ * Also I should make the time out of a mac endpoint smaller and check if the rate
+ * from get_wlan_header (plugin_transport_bluetooth.c) is correct.
+ */
while (1)
{
maxfd = -1;
+ broadcast = 0;
+ sendsocket = -1;
+
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);
}
- 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);
- }
-
- for (i = 0; i < crt_rfds; i++)
+
+ 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]);
}
-
- for (i = 0; i < crt_wfds; i++)
+ FD_ZERO (&wfds);
+ if (0 < write_std.size)
{
- fprintf(stderr, "LOG : %s adds extra fds to wfds\n", dev.iface); //FIXME: debugging message
- FD_SET (wfds_list[i], &wfds);
- maxfd = MAX (maxfd, wfds_list[i]);
+ FD_SET (STDOUT_FILENO, &wfds);
+ maxfd = MAX (maxfd, STDOUT_FILENO);
}
-
- if (0 < write_pout.size)
- {
- int sendsocket, status;
- struct sockaddr_rc addr = { 0 };
+ if (0 < write_pout.size) //it can send messages only to one device per loop
+ {
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,
+ else if (memcmp (&frame->addr1, &broadcast_address,
sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)
{
- fprintf (stderr, "LOG : %s has a broadcast message\n", dev.iface); //FIXME: debugging message
- memset (&write_pout, 0, sizeof (write_pout)); //FIXME for now just clear the buffer
- send_broadcast();
+ fprintf (stderr, "LOG : %s has a broadcast message (pos %d, size %d)\n", dev.iface, neighbours.pos, neighbours.size); //FIXME: debugging message
+ // broadcast = 1; // IF I HAVE A BROADCAST MESSAGE I skip.
+ // memset (&write_pout, 0, sizeof (write_pout));
+
+ if (send_broadcast(&dev, &sendsocket) != 0) //if the searching wasn't successful don't get stuck on the select stage
+ {
+ broadcast = 1;
+ memset (&write_pout, 0, sizeof (write_pout)); //remove the message
+ fprintf (stderr, "LOG : Skip the broadcast message (pos %d, size %d)\n", neighbours.pos, neighbours.size);
+ }
+ else
+ {
+ FD_SET (sendsocket, &wfds);
+ maxfd = MAX (maxfd, sendsocket);
+ }
}
else
{
- fprintf (stderr, "LOG : %s has a new message for %x:%x:%x:%x:%x:%x\n", dev.iface,
- frame->addr1.mac[5], frame->addr1.mac[4], frame->addr1.mac[3],
- frame->addr1.mac[2], frame->addr1.mac[1], frame->addr1.mac[0]); //FIXME: debugging message
-
- memcpy (&addr.rc_bdaddr, &frame->addr1, sizeof (bdaddr_t));
-
- sendsocket = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
-
- if (sendsocket < 0)
+ int found = 0;
+ int pos = 0;
+ /* Search if the address already exists on the list */
+ for (i = 0; i < neighbours.size; i++)
{
- fprintf (stderr, "Failed to create a RFCOMM socket (sending stage): %s\n",
- strerror (errno));
- return -1;
+ if (memcmp (&frame->addr1, &(neighbours.devices[i]), sizeof (bdaddr_t)) == 0)
+ {
+ 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;
+ }
+ }
}
-
-
- 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);
- */
- status = connect (sendsocket, (struct sockaddr *) &addr, sizeof (addr));
- if (0 != status && errno != EAGAIN)
- {
- fprintf (stderr, "%s failed to connect\n", dev.iface);
- return -1;
- }
-
- FD_SET (sendsocket, &wfds);
- maxfd = MAX (maxfd, sendsocket);
-
- if (crt_wfds < MAX_PORTS)
- wfds_list[crt_wfds++] = sendsocket; //add the socket to the list
- else
+ if (found == 0)
{
- fprintf (stderr, "The limit for the write file descriptors list was \
- reached\n");
- break;
+ int status;
+ struct sockaddr_rc addr = { 0 };
+
+ 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,
+ frame->addr1.mac[5], frame->addr1.mac[4], frame->addr1.mac[3],
+ frame->addr1.mac[2], frame->addr1.mac[1], frame->addr1.mac[0]); //FIXME: debugging message
+
+ sendsocket = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
+
+ if (sendsocket < 0)
+ {
+ fprintf (stderr, "Failed to create a RFCOMM socket (sending stage): %s\n",
+ strerror (errno));
+ return -1;
+ }
+
+ memcpy (&addr.rc_bdaddr, &frame->addr1, sizeof (bdaddr_t));
+ addr.rc_family = AF_BLUETOOTH;
+ addr.rc_channel = get_channel (&dev, addr.rc_bdaddr);
+
+ int tries = 0;
+ connect_retry:
+ status = connect (sendsocket, (struct sockaddr *) &addr, sizeof (addr));
+ if (0 != status && errno != EAGAIN)
+ {
+ if (errno == ECONNREFUSED && tries < 2)
+ {
+ fprintf (stderr, "LOG : %.*s failed to connect. Trying again!\n", IFNAMSIZ, dev.iface);
+ tries++;
+ goto connect_retry;
+ }
+ else if (errno == EBADF)
+ {
+ 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, "LOG : %s failed to connect : %s. Try again later!\n", dev.iface, strerror (errno));
+ memset (&write_pout, 0, sizeof (write_pout));
+ broadcast = 1;
+ }
+
+ }
+ else
+ {
+ FD_SET (sendsocket, &wfds);
+ maxfd = MAX (maxfd, sendsocket);
+ fprintf (stderr, "LOG : Connection successful\n");
+ if (pos != 0) // save the socket
+ {
+ neighbours.fds[pos] = sendsocket;
+ }
+ else
+ {
+ /* 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");
+ }
+ }
+ }
}
}
}
+
+ if (broadcast == 0)
{
- int retval = select (maxfd + 1, &rfds, &wfds, NULL, NULL);
- if ((-1 == retval) && (EINTR == errno))
- continue;
- if (0 > retval)
+ /* Select a fd which is ready for action :) */
{
- fprintf (stderr, "select failed: %s\n", strerror (errno));
- break;
+ 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
+ {
+ fprintf (stderr, "select failed: %s\n", strerror (errno));
+ break;
+ }
}
- }
- for (i = maxfd; i >= 0; i--)
- {
- if (FD_ISSET (i , &wfds))
+ if (FD_ISSET (STDOUT_FILENO , &wfds))
{
- if (i == STDOUT_FILENO)
+ ssize_t ret =
+ write (STDOUT_FILENO, write_std.buf + write_std.pos,
+ write_std.size - write_std.pos);
+ if (0 > ret)
{
- ssize_t ret =
- write (STDOUT_FILENO, write_std.buf + write_std.pos,
- write_std.size - write_std.pos);
- if (0 > ret)
- {
- fprintf (stderr, "Failed to write to STDOUT: %s\n", strerror (errno));
- break;
- }
- write_std.pos += ret;
- if (write_std.pos == write_std.size)
- {
- write_std.pos = 0;
- write_std.size = 0;
- }
- fprintf(stderr, "LOG : %s sends a message to STDOUT\n", dev.iface); //FIXME: debugging message
- }
- else
+ fprintf (stderr, "Failed to write to STDOUT: %s\n", strerror (errno));
+ break;
+ }
+ write_std.pos += ret;
+ if (write_std.pos == write_std.size)
+ {
+ write_std.pos = 0;
+ write_std.size = 0;
+ }
+ fprintf (stderr, "LOG : %s sends a message to STDOUT\n", dev.iface); //FIXME: debugging message
+
+ }
+ if (sendsocket != -1)
+ {
+ if (FD_ISSET (sendsocket , &wfds))
{
ssize_t ret =
- write (i, write_pout.buf + write_std.pos,
- write_pout.size - write_pout.pos);
- if (0 > ret)
- {
- fprintf (stderr, "Failed to write to bluetooth device: %s\n",
- strerror (errno));
- break;
- }
- write_pout.pos += ret;
- if ((write_pout.pos != write_pout.size) && (0 != ret))
+ write (sendsocket, write_pout.buf + write_std.pos,
+ write_pout.size - write_pout.pos);
+ if (0 > ret) //FIXME should I first check the error type?
{
- /* 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);
- break;
+ fprintf (stderr, "Failed to write to bluetooth device: %s. Closing the socket!\n",
+ strerror (errno));
+ for (i = 0; i < neighbours.size; i++)
+ {
+ if (neighbours.fds[i] == sendsocket)
+ {
+ (void) close(sendsocket);
+ neighbours.fds[i] = -1;
+ break;
+ }
+ }
+ /* 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;
}
- if (write_pout.pos == write_pout.size)
+ else
{
- write_pout.pos = 0;
- write_pout.size = 0;
- (void) close (i);
+ write_pout.pos += ret;
+ if ((write_pout.pos != write_pout.size) && (0 != ret))
+ {
+ /* 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);
+ break;
+ }
+
+ if (write_pout.pos == write_pout.size)
+ {
+ write_pout.pos = 0;
+ write_pout.size = 0;
+ }
+ fprintf (stderr, "LOG : %s sends a message to a DEVICE\n", dev.iface); //FIXME: debugging message
}
- fprintf(stderr, "LOG : %s sends a message to a DEVICE\n", dev.iface); //FIXME: debugging message
}
-
}
-
- if (FD_ISSET (i, &rfds))
+ for (i = 0; i <= maxfd; i++)
{
- if (i == STDIN_FILENO)
+ if (FD_ISSET (i, &rfds))
{
- ssize_t ret =
- read (i, readbuf, sizeof (readbuf));
- if (0 > ret)
+ if (i == STDIN_FILENO)
{
- fprintf (stderr, "Read error from STDIN: %s\n", strerror (errno));
- break;
- }
- if (0 == ret)
- {
- /* stop reading... */
- stdin_open = 0;
- }
- fprintf(stderr, "LOG : %s receives a message from STDIN\n", dev.iface); //FIXME: debugging message
- mst_receive (stdin_mst, readbuf, ret);
- }
- else if (i == dev.fd_rfcomm)
- {
- int readsocket;
- struct sockaddr_rc addr = { 0 };
- unsigned int opt = sizeof (addr);
-
- readsocket = accept (dev.fd_rfcomm, (struct sockaddr *) &addr, &opt);
- fprintf(stderr, "LOG : %s accepts a message\n", dev.iface); //FIXME: debugging message
- if (readsocket == -1)
+ ssize_t ret =
+ read (i, readbuf, sizeof (readbuf));
+ if (0 > ret)
+ {
+ fprintf (stderr, "Read error from STDIN: %s\n", strerror (errno));
+ break; break;
+ }
+ if (0 == ret)
+ {
+ /* stop reading... */
+ stdin_open = 0;
+ }
+ else
+ {
+ mst_receive (stdin_mst, readbuf, ret);
+ fprintf (stderr, "LOG : %s receives a message from STDIN\n", dev.iface); //FIXME: debugging message
+ }
+ }
+ else if (i == dev.fd_rfcomm)
{
- fprintf (stderr, "Failed to accept a connection on interface: %s\n",
- strerror (errno));
- return -1;
- } else {
- FD_SET (readsocket, &rfds);
- maxfd = MAX (maxfd, readsocket);
+ int readsocket;
+ struct sockaddr_rc addr = { 0 };
+ unsigned int opt = sizeof (addr);
- if (crt_rfds < MAX_PORTS)
- rfds_list[crt_rfds++] = readsocket;
- else
+ readsocket = accept (dev.fd_rfcomm, (struct sockaddr *) &addr, &opt);
+ fprintf(stderr, "LOG : %s accepts a message\n", dev.iface); //FIXME: debugging message
+ if (readsocket == -1)
{
- fprintf (stderr, "The limit for the read file descriptors list was \
- reached\n");
+ fprintf (stderr, "Failed to accept a connection on interface: %.*s\n", IFNAMSIZ,
+ strerror (errno));
break;
}
- }
-
- }
- else
- {
- struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm;
- ssize_t ret;
-
- rrm = (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) write_std.buf;
- ret =
- read_from_the_socket (i, (unsigned char *) &rrm->frame,
- sizeof (write_std.buf)
- - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
- + sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame),
- rrm);
- fprintf (stderr, "LOG: %s reads something from the socket\n", dev.iface);//FIXME : debugging message
- if (0 > ret)
- {
- fprintf (stderr, "Read error from rfcomm socket: %s\n", strerror (errno));
- break;
- }
- if ((0 < ret) && (0 == mac_test (&rrm->frame, &dev)))
+ else
+ {
+ FD_SET (readsocket, &rfds);
+ maxfd = MAX (maxfd, readsocket);
+
+ if (crt_rfds < MAX_PORTS)
+ rfds_list[crt_rfds++] = readsocket;
+ else
+ {
+ fprintf (stderr, "The limit for the read file descriptors list was \
+ reached\n");
+ break;
+ }
+ }
+
+ }
+ else
{
- write_std.size = ret
- + sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
- - sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame);
- rrm->header.size = htons (write_std.size);
- rrm->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER);
+ struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm;
+ ssize_t ret;
+ fprintf (stderr, "LOG : %s reads something from the socket\n", dev.iface);//FIXME : debugging message
+ rrm = (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) write_std.buf;
+ ret =
+ read_from_the_socket (i, (unsigned char *) &rrm->frame,
+ sizeof (write_std.buf)
+ - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
+ + sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame),
+ rrm);
+ if (0 >= ret)
+ {
+ int j;
+ FD_CLR (i, &rfds);
+ close (i);
+ /* Remove the socket from the list */
+ for (j = 0; j < crt_rfds; j++)
+ {
+ if (rfds_list[j] == i)
+ {
+ rfds_list[j] ^= rfds_list[crt_rfds - 1];
+ rfds_list[crt_rfds - 1] ^= rfds_list[j];
+ rfds_list[j] ^= rfds_list[crt_rfds - 1];
+ crt_rfds -= 1;
+ break;
+ }
+ }
+
+ fprintf (stderr, "Read error from raw socket: %s\n", strerror (errno));
+ break;
+ }
+ if ((0 < ret) && (0 == mac_test (&rrm->frame, &dev)))
+ {
+ write_std.size = ret
+ + sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
+ - sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame);
+ rrm->header.size = htons (write_std.size);
+ rrm->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER);
+ }
}
}
}
stdin_mst = NULL;
sdp_close (dev.session);
(void) close (dev.fd_rfcomm);
+ (void) close (sendsocket);
+
for (i = 0; i < crt_rfds; i++)
(void) close (rfds_list[i]);
- for (i = 0; i < crt_wfds; i++)
- (void) close (wfds_list[i]);
+ for (i = 0; i < neighbours.size; i++)
+ (void) close (neighbours.fds[i]);
return 1; /* we never exit 'normally' */
-
- /**
- *TODO
- * 1. check if the rate from get_wlan_header (plugin_transport_bluetooth.c) is correct
- * 2.
- */
}
projects / oweals / gnunet.git / blobdiff