/*
This file is part of GNUnet.
- (C) 2010, 2011, 2012 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2010, 2011, 2012 GNUnet e.V.
Copyright (c) 2007, 2008, Andy Green <andy@warmcat.com>
- Copyright (C) 2009 Thomas d'Otreppe
+ Copyright Copyright (C) 2009 Thomas d'Otreppe
- GNUnet is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
+ GNUnet is free software: you can redistribute it and/or modify it
+ under the terms of the GNU Affero General Public License as published
+ by the Free Software Foundation, either version 3 of the License,
+ or (at your option) any later version.
GNUnet is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
- You should have received a copy of the GNU General Public License
- along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ SPDX-License-Identifier: AGPL3.0-or-later
*/
#include "gnunet_config.h"
-#include "plugin_transport_wlan.h"
-#include "gnunet_protocols.h"
#ifdef MINGW
#include "platform.h"
#include "gnunet_util_lib.h"
#include <bthdef.h>
#include <ws2bth.h>
- #include "gnunet_protocols.h"
#else
+ #define SOCKTYPE int
#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
#include <bluetooth/hci_lib.h>
#include <bluetooth/sdp.h>
#include <bluetooth/sdp_lib.h>
#include <errno.h>
- #include <linux/if.h>
+ #include <linux/if.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <unistd.h>
#endif
+#include "plugin_transport_wlan.h"
+#include "gnunet_protocols.h"
/**
UINT8 mac[MAC_ADDR_SIZE];
};
- // {31191E56-FA7E-4517-870E-71B86BBCC52F}
+ /**
+ * The UUID used for the SDP service.
+ * {31191E56-FA7E-4517-870E-71B86BBCC52F}
+ */
#define GNUNET_BLUETOOTH_SDP_UUID \
{ \
0x31, 0x19, 0x1E, 0x56, \
}
#endif
+/**
+ * In bluez library, the maximum name length of a device is 8
+ */
+#define BLUEZ_DEVNAME_SIZE 8
+
/**
* struct for storing the information of the hardware. There is only
* one of these.
#ifdef MINGW
/**
* socket handle
- */
+ */
struct GNUNET_NETWORK_Handle *handle;
/**
* MAC address of our own bluetooth interface.
*/
struct GNUNET_TRANSPORT_WLAN_MacAddress pl_mac;
-
+
/**
* SDP session
*/
* destination? Always smaller than 'size'.
*/
size_t pos;
-
+
/**
* Buffered data; twice the maximum allowed message size as we add some
* headers.
#ifdef LINUX
/**
- * Devices buffer used to keep a list with all the discoverable devices in
+ * 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];
+ bdaddr_t devices[MAX_PORTS];
/* List with the open sockets */
int fds[MAX_PORTS];
/* The number of the devices */
int size;
-
+
/* The current position */
int pos;
static struct SendBuffer write_std;
-/* ****** this are the same functions as the ones used in gnunet-helper-transport-wlan.c ****** */
+/* ****** this are the same functions as the ones used in gnunet-helper-transport-wlan.c ****** */
/**
* To what multiple do we align messages? 8 byte should suffice for everyone
* @param cls closure
* @param message the actual message
*/
-typedef void (*MessageTokenizerCallback) (void *cls,
+typedef void (*MessageTokenizerCallback) (void *cls,
const struct
GNUNET_MessageHeader *
message);
ret->cb = cb;
ret->cb_cls = cb_cls;
ret->pos = 0;
-
+
return ret;
}
delta =
GNUNET_MIN (sizeof (struct GNUNET_MessageHeader) -
(mst->pos - mst->off), size);
- memcpy (&ibuf[mst->pos], buf, delta);
+ GNUNET_memcpy (&ibuf[mst->pos], buf, delta);
mst->pos += delta;
buf += delta;
size -= delta;
fprintf (stderr, "The size of the buffer will be exceeded!\n");
return GNUNET_SYSERR;
}
- memcpy (&ibuf[mst->pos], buf, delta);
+ GNUNET_memcpy (&ibuf[mst->pos], buf, delta);
mst->pos += delta;
buf += delta;
size -= delta;
"Assertion failed\n");
exit (1);
}
- memcpy (&ibuf[mst->pos], buf, size);
+ GNUNET_memcpy (&ibuf[mst->pos], buf, size);
mst->pos += size;
}
return ret;
if (((crc) & 0xFF) == buf[0] && ((crc >> 8) & 0xFF) == buf[1] &&
((crc >> 16) & 0xFF) == buf[2] && ((crc >> 24) & 0xFF) == buf[3])
return 0;
- return 1;
+ return 1;
}
/**
* Function used to get the code of last error and to print the type of error.
*/
- static void
+ static void
print_last_error()
{
LPVOID lpMsgBuf = NULL;
- FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
- NULL, GetLastError(), 0, (LPTSTR) &lpMsgBuf, 0, NULL);
- fprintf (stderr, "%s\n", (char *)lpMsgBuf) ;
- //FIXME : it crashes
- // if (lpMsgBuf)
- // free (lpMsgBuf);
+
+ if (FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL, GetLastError(), 0, (LPTSTR) &lpMsgBuf, 0, NULL))
+ fprintf (stderr, "%s\n", (char *)lpMsgBuf);
+ else
+ fprintf (stderr, "Failed to format the message for the last error! Error number : %d\n", GetLastError());
}
/**
/**
* Function used to convert the GUID.
* @param bytes the GUID represented as a char array
- * @param uuid pointer to the GUID
+ * @param uuid pointer to the GUID
*/
- static void
+ static void
convert_guid(char *bytes, GUID * uuid)
{
int i;
#ifdef LINUX
/**
* Function for assigning a port number
- *
+ *
* @param socket the socket used to bind
* @param addr pointer to the rfcomm address
- * @return 0 on success
- */
+ * @return 0 on success
+ */
static int
bind_socket (int socket, struct sockaddr_rc *addr)
{
int port, status;
-
+
/* 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++)
if (status == 0)
return 0;
}
-
- return -1;
+
+ return -1;
}
#endif
* @return 0 on success
*/
static int
- register_service (struct HardwareInfos *dev)
+ register_service (struct HardwareInfos *dev)
{
- // advertise the service
+ /* advertise the service */
CSADDR_INFO addr_info;
WSAQUERYSET wqs;
GUID guid;
}
/* save the device address */
- memcpy (&dev->pl_mac, &addr.btAddr, sizeof (BTH_ADDR));
+ GNUNET_memcpy (&dev->pl_mac, &addr.btAddr, sizeof (BTH_ADDR));
/* set the address information */
memset (&addr_info, 0, sizeof (CSADDR_INFO));
wqs.lpServiceClassId = &guid;
wqs.dwNumberOfCsAddrs = 1;
wqs.lpcsaBuffer = &addr_info ;
- wqs.lpBlob = 0; //FIXME it should be 0 for a new entry
+ wqs.lpBlob = 0;
- if (SOCKET_ERROR == WSASetService (&wqs , RNRSERVICE_REGISTER, 0))
+ if (SOCKET_ERROR == WSASetService (&wqs , RNRSERVICE_REGISTER, 0))
{
fprintf (stderr, "Failed to register the SDP service: ");
print_last_error();
* @return 0 on success
*/
static int
- register_service (struct HardwareInfos *dev, int rc_channel)
+ register_service (struct HardwareInfos *dev, int rc_channel)
{
/**
* 1. initializations
* 6. register the service record to the local SDP server
* 7. cleanup
*/
- uint8_t svc_uuid_int[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 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_dsc = "Bluetooth plugin services";
- const char *service_prov = "GNUnet provider";
- uuid_t root_uuid, rfcomm_uuid, svc_uuid;
+ const char *service_prov = "GNUnet provider";
+ 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;
-
+
record = sdp_record_alloc();
/* Set the general service ID */
sdp_set_service_id (record, svc_uuid);
/* Make the service record publicly browsable */
- sdp_uuid16_create (&root_uuid, PUBLIC_BROWSE_GROUP);
- root_list = sdp_list_append (0, &root_uuid);
+ sdp_uuid16_create (&root_uuid, PUBLIC_BROWSE_GROUP);
+ root_list = sdp_list_append (0, &root_uuid);
sdp_set_browse_groups (record, root_list);
/* Register the RFCOMM channel */
/* Set the name, provider, and description */
sdp_set_info_attr (record, dev->iface, service_prov, service_dsc);
-
+
/* Connect to the local SDP server */
dev->session = sdp_connect (BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY);
-
+
if (!dev->session)
{
fprintf (stderr, "Failed to connect to the SDP server on interface `%.*s': %s\n",
//FIXME exit?
return 1;
}
-
+
/* Register the service record */
if (sdp_record_register (dev->session, record, 0) < 0)
{
//FIXME exit?
return 1;
}
-
+
/* Cleanup */
- sdp_data_free (channel);
+ sdp_data_free (channel);
sdp_list_free (root_list, 0);
sdp_list_free (rfcomm_list, 0);
sdp_list_free (proto_list, 0);
sdp_list_free (access_proto_list, 0);
sdp_list_free (svc_list, 0);
sdp_record_free (record);
-
+
return 0;
}
#endif
#ifdef MINGW
/**
- * Function for searching and browsing for a service. This will return the
+ * Function for searching and browsing for a service. This will return the
* port number on which the service is running.
*
* @param dest target address
GUID guid;
unsigned char uuid[] = GNUNET_BLUETOOTH_SDP_UUID;
convert_guid ((char *) uuid, &guid);
-
+
wqs = (WSAQUERYSET*)malloc (wqs_len);
ZeroMemory (wqs, wqs_len);
-
+
wqs->dwSize = sizeof (WSAQUERYSET) ;
wqs->lpServiceClassId = &guid;
wqs->dwNameSpace = NS_BTH;
wqs->dwNumberOfCsAddrs = 0;
wqs->lpszContext = (LPSTR)dest;
-
+
if (SOCKET_ERROR == WSALookupServiceBegin (wqs, LUP_FLUSHCACHE | LUP_RETURN_ALL, &h))
{
if (GetLastError() == WSASERVICE_NOT_FOUND)
return -1;
}
}
-
+
/* search the sdp service */
while (!done)
{
if (SOCKET_ERROR == WSALookupServiceNext (h, LUP_FLUSHCACHE | LUP_RETURN_ALL, &wqs_len, wqs))
{
int error = WSAGetLastError();
-
+
switch (error)
{
case WSAEFAULT:
free (wqs);
- //fprintf (stderr, "WSAFAULT error! (the memory allocated wasn't enought\n");
wqs = (WSAQUERYSET*)malloc (wqs_len);
break;
case WSANO_DATA:
break;
case WSA_E_NO_MORE:
done = 1;
- // fprintf (stderr, "No matching service found\n");
break;
default:
fprintf (stderr, "Failed to look over the services: ");
channel = ((SOCKADDR_BTH*)wqs->lpcsaBuffer->RemoteAddr.lpSockaddr)->port;
}
}
-
+
free (wqs) ;
WSALookupServiceEnd (h);
-
+
return channel;
}
#else
/**
- * Function used for searching and browsing for a service. This will return the
+ * Function used 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
* @return channel
*/
static int
- get_channel(struct HardwareInfos *dev, bdaddr_t dest)
+ get_channel(struct HardwareInfos *dev, bdaddr_t dest)
{
/**
* 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
- * 2.3. for each service record get a list of the protocol sequences and get
+ * 2.3. for each service record get a list of the protocol sequences and get
* the port number
*/
- uint8_t svc_uuid_int[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ uint8_t svc_uuid_int[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
dest.b[5], dest.b[4], dest.b[3],
dest.b[2], dest.b[1], dest.b[0]};
sdp_session_t *session = 0;
sdp_list_t *search_list = 0, *attrid_list = 0, *response_list = 0, *it = 0;
uuid_t svc_uuid;
uint32_t range = 0x0000ffff;
- uint8_t channel = -1;
-
+ int channel = -1;
+
/* Connect to the local SDP server */
- session = sdp_connect (BDADDR_ANY, &dest, 0);
+ session = sdp_connect (BDADDR_ANY, &dest, 0);
if (!session)
{
fprintf (stderr, "Failed to connect to the SDP server on interface `%.*s': %s\n",
IFNAMSIZ, dev->iface, strerror (errno));
- //FIXME exit?
return -1;
}
-
+
sdp_uuid128_create (&svc_uuid, &svc_uuid_int);
search_list = sdp_list_append (0, &svc_uuid);
attrid_list = sdp_list_append (0, &range);
-
- if (sdp_service_search_attr_req (session, search_list,
+
+ if (sdp_service_search_attr_req (session, search_list,
SDP_ATTR_REQ_RANGE, attrid_list, &response_list) == 0)
{
for (it = response_list; it; it = it->next)
{
sdp_record_t *record = (sdp_record_t*) it->data;
- //TODO print some record informations to be sure everything is good
sdp_list_t *proto_list = 0;
if (sdp_get_access_protos (record, &proto_list) == 0)
{
sdp_record_free (record);
}
}
-
+
sdp_list_free (search_list, 0);
sdp_list_free (attrid_list, 0);
sdp_list_free (response_list, 0);
-
+
sdp_close (session);
-
- if (channel == -1)
- fprintf (stderr, "Failed to find the listening channel for interface `%.*s': %s\n",
- IFNAMSIZ, dev->iface, strerror (errno));
-
+
+ if (-1 == channel)
+ fprintf (stderr,
+ "Failed to find the listening channel for interface `%.*s': %s\n",
+ IFNAMSIZ,
+ dev->iface,
+ strerror (errno));
+
return channel;
}
#endif
/**
* 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
* @param ri where to write radiotap_rx info
* @return number of bytes written to 'buf'
*/
-static ssize_t
-read_from_the_socket (void *sock,
+static ssize_t
+read_from_the_socket (void *sock,
unsigned char *buf, size_t buf_size,
struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *ri)
{
unsigned char tmpbuf[buf_size];
ssize_t count;
-
+
#ifdef MINGW
count = GNUNET_NETWORK_socket_recv ((struct GNUNET_NETWORK_Handle *)sock, tmpbuf, buf_size);
#else
- count = read (*((int *)sock), tmpbuf, buf_size);
+ count = read (*((int *)sock), tmpbuf, buf_size);
#endif
if (0 > count)
return -1;
}
-
+
#ifdef LINUX
- /* Get the channel used */ //FIXME probably not needed anymore
+ /* Get the channel used */
int len;
- struct sockaddr_rc rc_addr = { 0 };
+ struct sockaddr_rc rc_addr = { 0 };
memset (&rc_addr, 0, sizeof (rc_addr));
len = sizeof (rc_addr);
{
count -= sizeof(uint32_t);
}
-
- memcpy (buf, tmpbuf, count);
-
+
+ GNUNET_memcpy (buf, tmpbuf, count);
+
return count;
}
+
/**
* Open the bluetooth interface for reading/writing
*
* @param dev pointer to the device struct
- * @return 0 on success
+ * @return 0 on success, non-zero on error
*/
static int
open_device (struct HardwareInfos *dev)
-{
+{
#ifdef MINGW
SOCKADDR_BTH addr;
- /* bind the hci socket to the interface */
+ /* bind the RFCOMM socket to the interface */
addr.addressFamily = AF_BTH;
addr.btAddr = 0;
addr.port = BT_PORT_ANY;
- //FIXME flags parameter
- if (GNUNET_NETWORK_socket_bind (dev->handle, (const SOCKADDR*)&addr, sizeof (SOCKADDR_BTH), 0) != GNUNET_OK)
+ if (GNUNET_OK !=
+ GNUNET_NETWORK_socket_bind (dev->handle, (const SOCKADDR*)&addr, sizeof (SOCKADDR_BTH)))
{
fprintf (stderr, "Failed to bind the socket: ");
if (GetLastError() == WSAENETDOWN)
fprintf (stderr, "Failed to register a service: ");
print_last_error();
return 1;
- }
+ }
#else
int i, dev_id = -1, fd_hci;
- struct
+ struct
{
struct hci_dev_list_req list;
struct hci_dev_req dev[HCI_MAX_DEV];
} 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 (fd_hci < 0)
{
- fprintf (stderr, "Failed to create HCI socket: %s\n", strerror (errno));
+ fprintf (stderr,
+ "Failed to create HCI socket: %s\n",
+ strerror (errno));
return -1;
}
-
+
memset (&request, 0, sizeof(request));
request.list.dev_num = HCI_MAX_DEV;
if (ioctl (fd_hci, HCIGETDEVLIST, (void *) &request) < 0)
{
- fprintf (stderr, "ioctl(HCIGETDEVLIST) on interface `%.*s' failed: %s\n",
- IFNAMSIZ, dev->iface, strerror (errno));
+ fprintf (stderr,
+ "ioctl(HCIGETDEVLIST) on interface `%.*s' failed: %s\n",
+ IFNAMSIZ,
+ dev->iface,
+ strerror (errno));
+ (void) close (fd_hci);
return 1;
}
-
+
/* Search for a device with dev->iface name */
for (i = 0; i < request.list.dev_num; i++)
{
memset (&dev_info, 0, sizeof(struct hci_dev_info));
dev_info.dev_id = request.dev[i].dev_id;
- strncpy (dev_info.name, dev->iface, IFNAMSIZ);
-
+ strncpy (dev_info.name, dev->iface, BLUEZ_DEVNAME_SIZE);
+
if (ioctl (fd_hci, HCIGETDEVINFO, (void *) &dev_info))
{
- fprintf (stderr, "ioctl(HCIGETDEVINFO) on interface `%.*s' failed: %s\n",
- IFNAMSIZ, dev->iface, strerror (errno));
+ fprintf (stderr,
+ "ioctl(HCIGETDEVINFO) on interface `%.*s' failed: %s\n",
+ IFNAMSIZ,
+ dev->iface,
+ strerror (errno));
+ (void) close (fd_hci);
return 1;
}
-
- if (strcmp (dev_info.name, dev->iface) == 0)
+
+ if (strncmp (dev_info.name, dev->iface, BLUEZ_DEVNAME_SIZE) == 0)
{
-
+
dev_id = dev_info.dev_id; //the device was found
/**
* Copy the MAC address to the device structure
*/
- memcpy (&dev->pl_mac, &dev_info.bdaddr, sizeof (bdaddr_t));
-
+ GNUNET_memcpy (&dev->pl_mac, &dev_info.bdaddr, sizeof (bdaddr_t));
+
/* Check if the interface is up */
if (hci_test_bit (HCI_UP, (void *) &dev_info.flags) == 0)
{
/* Bring the interface up */
if (ioctl (fd_hci, HCIDEVUP, dev_info.dev_id))
{
- fprintf (stderr, "ioctl(HCIDEVUP) on interface `%.*s' failed: %s\n",
- IFNAMSIZ, dev->iface, strerror (errno));
+ fprintf (stderr,
+ "ioctl(HCIDEVUP) on interface `%.*s' failed: %s\n",
+ IFNAMSIZ,
+ dev->iface,
+ strerror (errno));
+ (void) close (fd_hci);
return 1;
}
}
-
+
/* Check if the device is discoverable */
if (hci_test_bit (HCI_PSCAN, (void *) &dev_info.flags) == 0 ||
hci_test_bit (HCI_ISCAN, (void *) &dev_info.flags) == 0)
{
/* Set interface Page Scan and Inqury Scan ON */
struct hci_dev_req dev_req;
-
+
memset (&dev_req, 0, sizeof (dev_req));
dev_req.dev_id = dev_info.dev_id;
dev_req.dev_opt = SCAN_PAGE | SCAN_INQUIRY;
-
+
if (ioctl (fd_hci, HCISETSCAN, (unsigned long) &dev_req))
- {
- fprintf (stderr, "ioctl(HCISETSCAN) on interface `%.*s' failed: %s\n",
- IFNAMSIZ, dev->iface, strerror (errno));
+ {
+ fprintf (stderr,
+ "ioctl(HCISETSCAN) on interface `%.*s' failed: %s\n",
+ IFNAMSIZ,
+ dev->iface,
+ strerror (errno));
+ (void) close (fd_hci);
return 1;
}
-
+
}
break;
}
-
+
}
-
+
/* Check if the interface was not found */
- if (dev_id == -1)
+ if (-1 == dev_id)
{
- fprintf (stderr, "The interface %s was not found\n", dev->iface);
+ fprintf (stderr,
+ "The interface %s was not found\n",
+ dev->iface);
+ (void) close (fd_hci);
return 1;
}
-
+
/* Close the hci socket */
(void) close(fd_hci);
-
-
-
+
+
+
/* Bind the rfcomm socket to the interface */
- memset (&rc_addr, 0, sizeof (rc_addr));
+ memset (&rc_addr, 0, sizeof (rc_addr));
rc_addr.rc_family = AF_BLUETOOTH;
rc_addr.rc_bdaddr = *BDADDR_ANY;
-
+
if (bind_socket (dev->fd_rfcomm, &rc_addr) != 0)
{
- fprintf (stderr, "Failed to bind interface `%.*s': %s\n", IFNAMSIZ,
- dev->iface, strerror (errno));
+ fprintf (stderr,
+ "Failed to bind interface `%.*s': %s\n",
+ IFNAMSIZ,
+ dev->iface,
+ strerror (errno));
return 1;
}
-
+
/* Register a SDP service */
if (register_service (dev, rc_addr.rc_channel) != 0)
{
- fprintf (stderr, "Failed to register a service on interface `%.*s': %s\n", IFNAMSIZ,
+ fprintf (stderr,
+ "Failed to register a service on interface `%.*s': %s\n",
+ IFNAMSIZ,
dev->iface, strerror (errno));
return 1;
}
-
+
/* Switch socket in listening mode */
if (listen (dev->fd_rfcomm, 5) == -1) //FIXME: probably we need a bigger number
{
dev->iface, strerror (errno));
return 1;
}
-
+
#endif
return 0;
mac_set (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader,
const struct HardwareInfos *dev)
{
- taIeeeHeader->frame_control = htons (IEEE80211_FC0_TYPE_DATA);
+ taIeeeHeader->frame_control = htons (IEEE80211_FC0_TYPE_DATA);
taIeeeHeader->addr3 = mac_bssid_gnunet;
#ifdef MINGW
- memcpy (&taIeeeHeader->addr2, &dev->pl_mac, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
+ GNUNET_memcpy (&taIeeeHeader->addr2, &dev->pl_mac, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
#else
taIeeeHeader->addr2 = dev->pl_mac;
#endif
struct stat sbuf;
int ret;
- ret = snprintf (strbuf, sizeof (strbuf),
+ ret = snprintf (strbuf, sizeof (strbuf),
"/sys/class/bluetooth/%s/subsystem",
iface);
if ((ret < 0) || (ret >= sizeof (strbuf)) || (0 != stat (strbuf, &sbuf)))
{
- fprintf (stderr,
- "Did not find 802.15.1 interface `%s'. Exiting.\n",
+ fprintf (stderr,
+ "Did not find 802.15.1 interface `%s'. Exiting.\n",
iface);
exit (1);
}
sendsize = ntohs (hdr->size);
if ( (sendsize <
sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage)) ||
- (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER != ntohs (hdr->type)) )
+ (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER != ntohs (hdr->type)) )
{
fprintf (stderr, "Received malformed message\n");
exit (1);
}
- sendsize -= (sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) -
+ sendsize -= (sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) -
sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame));
if (MAXLINE < sendsize)
{
exit (1);
}
header = (const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) hdr;
- memcpy (&write_pout.buf, &header->frame, sendsize);
+ GNUNET_memcpy (&write_pout.buf, &header->frame, sendsize);
blueheader = (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *) &write_pout.buf;
/* payload contains MAC address, but we don't trust it, so we'll
* overwrite it with OUR MAC address to prevent mischief */
mac_set (blueheader, dev);
- memcpy (&blueheader->addr1, &header->frame.addr1,
+ GNUNET_memcpy (&blueheader->addr1, &header->frame.addr1,
sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
write_pout.size = sendsize;
}
* @param dev pointer to the socket which was added to the set
* @return 0 on success
*/
- static int
- send_broadcast (struct HardwareInfos *dev, int *sendsocket)
+ static int
+ send_broadcast (struct HardwareInfos *dev, int *sendsocket)
{
int new_device = 0;
int loops = 0;
search_for_devices:
- if ((neighbours.size == neighbours.pos && new_device == 1) || neighbours.size == 0)
- {
+ 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
+ /**
+ * 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;
if (neighbours.dev_id == -1)
{
char addr[19] = { 0 }; //the device MAC address
-
- ba2str ((bdaddr_t *) &dev->pl_mac, addr);
+
+ 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)
{
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++)
+
+ for (i = 0; i < responses; i++)
{
int j;
int found = 0;
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)
+ 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
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));
+ GNUNET_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;
{
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));
-
+ GNUNET_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)
+ if ( (-1 < *sendsocket) &&
+ (0 == connect (*sendsocket,
+ (struct sockaddr *) &addr_rc,
+ sizeof (addr_rc))) )
{
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
+
+ if (-1 != *sendsocket)
+ {
+ (void) close (*sendsocket);
+ *sendsocket = -1;
+ }
ba2str (&(neighbours.devices[neighbours.pos]), addr);
- fprintf (stderr, "LOG : Couldn't connect on device %s, error : %s\n", addr, strerror(errno));
+ 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));
+ GNUNET_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.pos += 1;
}
}
-
+
/* Cycle on the list */
if (neighbours.pos == neighbours.size)
{
}
}
/* If a new device wasn't found, search an old one */
- if (connection_successful == 0)
+ 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)
/**
* Main function of the helper. This code accesses a bluetooth interface
- * forwards traffic in both directions between the bluetooth interface and
+ * forwards traffic in both directions between the bluetooth interface and
* stdin/stdout of this process. Error messages are written to stderr.
*
* @param argc number of arguments, must be 2
int
main (int argc, char *argv[])
{
-#ifdef LINUX
+#ifdef LINUX
struct HardwareInfos dev;
char readbuf[MAXLINE];
int maxfd;
int stdin_open;
struct MessageStreamTokenizer *stdin_mst;
int raw_eno, i;
- uid_t uid;
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
- if (0 != setresuid (uid, 0, 0))
{
- fprintf (stderr, "Failed to setresuid to root: %s\n", strerror (errno));
- return 254;
- }
- #else
- if (0 != seteuid (0))
- {
- fprintf (stderr, "Failed to seteuid back to root: %s\n", strerror (errno));
- return 254;
+#ifdef HAVE_SETRESUID
+ uid_t uid = getuid ();
+
+ if (0 != setresuid (uid, 0, 0))
+ {
+ fprintf (stderr,
+ "Failed to setresuid to root: %s\n",
+ strerror (errno));
+ return 254;
+ }
+#else
+ if (0 != seteuid (0))
+ {
+ fprintf (stderr,
+ "Failed to seteuid back to root: %s\n", strerror (errno));
+ return 254;
+ }
+#endif
}
- #endif
/* Make use of SGID capabilities on POSIX */
memset (&dev, 0, sizeof (dev));
if (-1 == dev.fd_rfcomm)
{
- fprintf (stderr, "Failed to create a HCI socket: %s\n", strerror (raw_eno));
+ fprintf (stderr, "Failed to create a RFCOMM socket: %s\n", strerror (raw_eno));
return 1;
}
if (dev.fd_rfcomm >= FD_SETSIZE)
macmsg.hdr.size = htons (sizeof (macmsg));
macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL);
- memcpy (&macmsg.mac, &dev.pl_mac, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
- memcpy (write_std.buf, &macmsg, sizeof (macmsg));
+ GNUNET_memcpy (&macmsg.mac, &dev.pl_mac, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
+ GNUNET_memcpy (write_std.buf, &macmsg, sizeof (macmsg));
write_std.size = sizeof (macmsg);
}
-
-
- stdin_mst = mst_create (&stdin_send_hw, &dev);
+
+
+ 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
+ * TODO : 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;
maxfd = MAX (maxfd, dev.fd_rfcomm);
}
- for (i = 0; i < crt_rfds; i++) // it can receive messages from multiple devices
+ for (i = 0; i < crt_rfds; i++) // it can receive messages from multiple devices
{
FD_SET (rfds_list[i], &rfds);
maxfd = MAX (maxfd, rfds_list[i]);
maxfd = MAX (maxfd, STDOUT_FILENO);
}
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 */
frame = (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *) write_pout.buf;
-
- if (memcmp (&frame->addr1, &dev.pl_mac,
+
+ if (memcmp (&frame->addr1, &dev.pl_mac,
sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)
{
broadcast = 1;
- memset (&write_pout, 0, sizeof (write_pout)); //clear the buffer
- }
- else if (memcmp (&frame->addr1, &broadcast_address,
+ memset (&write_pout, 0, sizeof (write_pout)); //clear the buffer
+ }
+ else if (memcmp (&frame->addr1, &broadcast_address,
sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)
{
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);
+ fprintf (stderr, "LOG : Skipping the broadcast message (pos %d, size %d)\n", neighbours.pos, neighbours.size);
}
else
{
FD_SET (sendsocket, &wfds);
maxfd = MAX (maxfd, sendsocket);
}
- }
- 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)
+ if (memcmp (&frame->addr1, &(neighbours.devices[i]), sizeof (bdaddr_t)) == 0)
{
pos = i;
if (neighbours.fds[i] != -1)
{
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,
+
+ 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
-
+ 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)
+
+ if (sendsocket < 0)
{
- fprintf (stderr, "Failed to create a RFCOMM socket (sending stage): %s\n",
+ 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));
+
+ GNUNET_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));
memset (&write_pout, 0, sizeof (write_pout));
broadcast = 1;
}
-
+
}
else
{
if (neighbours.size < MAX_PORTS)
{
neighbours.fds[neighbours.size] = sendsocket;
- memcpy (&(neighbours.devices[neighbours.size++]), &addr.rc_bdaddr, sizeof (bdaddr_t));
+ GNUNET_memcpy (&(neighbours.devices[neighbours.size++]), &addr.rc_bdaddr, sizeof (bdaddr_t));
}
else
{
write_std.size = 0;
}
fprintf (stderr, "LOG : %s sends a message to STDOUT\n", dev.iface); //FIXME: debugging message
-
- }
- if (sendsocket != -1)
+
+ }
+ if (-1 != sendsocket)
{
if (FD_ISSET (sendsocket , &wfds))
{
- ssize_t ret =
- write (sendsocket, write_pout.buf + write_std.pos,
- write_pout.size - write_pout.pos);
+ ssize_t 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?
{
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)
}
}
/* Remove the message */
- memset (&write_pout.buf + write_std.pos, 0, (write_pout.size - write_pout.pos));
+ memset (&write_pout.buf + write_std.pos, 0, (write_pout.size - write_pout.pos));
write_pout.pos = 0 ;
write_pout.size = 0;
}
(unsigned int) write_pout.size);
break;
}
-
+
if (write_pout.pos == write_pout.size)
{
write_pout.pos = 0;
{
if (i == STDIN_FILENO)
{
- ssize_t ret =
+ ssize_t ret =
read (i, readbuf, sizeof (readbuf));
if (0 > ret)
{
- fprintf (stderr, "Read error from STDIN: %s\n", strerror (errno));
- break; break;
+ fprintf (stderr,
+ "Read error from STDIN: %s\n",
+ strerror (errno));
+ break;
}
if (0 == ret)
{
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)
+ }
+ 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)
{
- fprintf (stderr, "Failed to accept a connection on interface: %.*s\n", IFNAMSIZ,
+ fprintf (stderr, "Failed to accept a connection on interface: %.*s\n", IFNAMSIZ,
strerror (errno));
break;
}
{
FD_SET (readsocket, &rfds);
maxfd = MAX (maxfd, readsocket);
-
+
if (crt_rfds < MAX_PORTS)
rfds_list[crt_rfds++] = readsocket;
else
break;
}
}
-
- }
- else
+
+ }
+ else
{
struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm;
ssize_t ret;
- fprintf (stderr, "LOG : %s reads something from the socket\n", dev.iface);//FIXME : debugging message
+ 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 ((void *)&i, (unsigned char *) &rrm->frame,
- sizeof (write_std.buf)
- - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
- + sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame),
+ sizeof (write_std.buf)
+ - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
+ + sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame),
rrm);
if (0 >= ret)
{
}
if ((0 < ret) && (0 == mac_test (&rrm->frame, &dev)))
{
- write_std.size = ret
- + sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
+ 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);
-
+ if (-1 != sendsocket)
+ (void) close (sendsocket);
+
for (i = 0; i < crt_rfds; i++)
(void) close (rfds_list[i]);
struct MessageStreamTokenizer *stdin_mst;
/* check the handles */
- if (stdin_handle == INVALID_HANDLE_VALUE)
+ if (stdin_handle == INVALID_HANDLE_VALUE)
{
fprintf (stderr, "Failed to get the stdin handle\n");
ExitProcess (2);
}
- if (stdout_handle == INVALID_HANDLE_VALUE)
+ if (stdout_handle == INVALID_HANDLE_VALUE)
{
fprintf (stderr, "Failed to get the stdout handle\n");
ExitProcess (2);
}
- if (open_device (&dev) == -1)
+ if (open_device (&dev) == -1)
{
fprintf (stderr, "Failed to open the device\n");
print_last_error();
print_last_error();
}
ExitProcess (2);
- }
+ }
if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking (dev.handle, 1) )
{
fprintf (stderr, "Failed to change the socket mode\n");
ExitProcess (2);
}
-
+
memset (&write_std, 0, sizeof (write_std));
- memset (&write_pout, 0, sizeof (write_pout));
+ memset (&write_pout, 0, sizeof (write_pout));
stdin_open = 1;
rfds = GNUNET_NETWORK_fdset_create ();
wfds = GNUNET_NETWORK_fdset_create ();
-
+
/* Send MAC address of the bluetooth interface to STDOUT first */
{
struct GNUNET_TRANSPORT_WLAN_HelperControlMessage macmsg;
macmsg.hdr.size = htons (sizeof (macmsg));
macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL);
- memcpy (&macmsg.mac, &dev.pl_mac, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress_Copy));
- memcpy (write_std.buf, &macmsg, sizeof (macmsg));
+ GNUNET_memcpy (&macmsg.mac, &dev.pl_mac, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress_Copy));
+ GNUNET_memcpy (write_std.buf, &macmsg, sizeof (macmsg));
write_std.size = sizeof (macmsg);
}
-
-
- stdin_mst = mst_create (&stdin_send_hw, &dev);
+
+
+ stdin_mst = mst_create (&stdin_send_hw, &dev);
stdin_open = 1;
-
- fprintf (stderr, "\n-----------------------------------------------\n Check if the program exits\n-----------------------------------------------\n");
int pos = 0;
int stdin_pos = -1;
pos = 0;
stdin_pos = -1;
stdout_pos = -1;
- sendsocket = NULL; //FIXME memleaks
- fprintf (stderr, "---------------------------------------------------\n");
-
- GNUNET_NETWORK_fdset_zero (rfds);
+ sendsocket = NULL; //FIXME ???memleaks
+
+ GNUNET_NETWORK_fdset_zero (rfds);
if ((0 == write_pout.size) && (1 == stdin_open))
{
stdin_pos = pos;
pos +=1;
- fprintf (stderr, "LOG: set STDIN_FILENO\n");
- GNUNET_NETWORK_fdset_handle_set (rfds, (struct GNUNET_DISK_FileHandle*) &stdin_handle); //FIXME create a GNUNET_STRUCT handle for stdin
+ GNUNET_NETWORK_fdset_handle_set (rfds, (struct GNUNET_DISK_FileHandle*) &stdin_handle);
}
if (0 == write_std.size)
{
pos += 1;
- fprintf (stderr, "LOG: set the listening socket %d\n", GNUNET_NETWORK_get_fd (dev.handle));
GNUNET_NETWORK_fdset_set (rfds, dev.handle);
}
-
+
for (i = 0; i < crt_rfds; i++)
{
pos += 1;
- fprintf (stderr, "LOG: adding %d read socket\n", i);
GNUNET_NETWORK_fdset_set (rfds, rfds_list[i]);
}
if (0 < write_std.size)
{
stdout_pos = pos;
- fprintf (stderr, "LOG: set STDOUT_FILENO\n");
GNUNET_NETWORK_fdset_handle_set (wfds, (struct GNUNET_DISK_FileHandle*) &stdout_handle);
- fprintf (stderr, "LOG: after setting STDOUT_FILENO\n");
// printf ("%s\n", write_std.buf);
// memset (write_std.buf, 0, write_std.size);
- // write_std.size = 0;
+ // write_std.size = 0;
}
if (0 < write_pout.size)
- {
+ {
if (strcmp (argv[1], "ff:ff:ff:ff:ff:ff") == 0) {
- fprintf(stderr, "BROADCAST\n");
+ fprintf(stderr, "LOG: BROADCAST! Skipping the message\n");
// skip the message
broadcast = 1;
memset (write_pout.buf, 0, write_pout.size);
write_pout.size = 0;
- }
- else
+ }
+ else
{
SOCKADDR_BTH addr;
fprintf (stderr, "LOG : has a new message for %s\n", argv[1]);
sendsocket = GNUNET_NETWORK_socket_create (AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
-
- if (sendsocket == NULL)
+
+ if (sendsocket == NULL)
{
fprintf (stderr, "Failed to create RFCOMM socket: \n");
print_last_error();
ExitProcess (2);
}
-
+
memset (&addr, 0, sizeof (addr));
//addr.addressFamily = AF_BTH;
- if (SOCKET_ERROR ==
+ if (SOCKET_ERROR ==
WSAStringToAddress (argv[1], AF_BTH, NULL, (LPSOCKADDR) &addr, &addr_len))
{
fprintf (stderr, "Failed to translate the address: ");
print_last_error();
ExitProcess ( 2 ) ;
}
- addr.port = get_channel (argv[1]); //crapa aici
+ addr.port = get_channel (argv[1]);
if (addr.port == -1)
{
fprintf (stderr, "Couldn't find the sdp service for the address: %s\n", argv[1]);
}
else
{
- fprintf (stderr, "got the channel %d\n", addr.port);
-
if (GNUNET_OK != GNUNET_NETWORK_socket_connect (sendsocket, (LPSOCKADDR)&addr, addr_len))
{
fprintf (stderr, "Failed to connect: ");
}
}
}
-
+
if (broadcast == 0)
{
- fprintf (stderr, "before select\n");
int retval = GNUNET_NETWORK_socket_select (rfds, wfds, NULL, GNUNET_TIME_relative_get_forever_());
- fprintf (stderr, "after select %d\n", retval);
if (retval < 0)
{
- fprintf (stderr, "select error\n");
+ fprintf (stderr, "Select error\n");
ExitProcess (2);
}
//if (GNUNET_NETWORK_fdset_isset (wfds, (struct GNUNET_NETWORK_Handle*)&stdout_handle))
if (retval == stdout_pos)
{
- fprintf (stderr, "-------------STDOUT------------\n");
fprintf(stderr, "LOG : sends a message to STDOUT\n"); //FIXME: debugging message
//ssize_t ret;
//ret = GNUNET_NETWORK_socket_send ((struct GNUNET_NETWORK_Handle *)&stdout_handle, write_std.buf + write_std.pos, write_std.size - write_std.pos);
print_last_error();
break;
}
- fprintf (stderr, "--->sended: %d\n", ret);
- Sleep(5000);
+
if (ret <= 0)
{
fprintf (stderr, "Failed to write to STDOUT\n");
ExitProcess (2);
}
-
+
write_std.pos += ret;
if (write_std.pos == write_std.size)
{
{
if (GNUNET_NETWORK_fdset_isset (wfds, sendsocket))
{
- fprintf (stderr, "-------------SEND------------\n");
ssize_t ret;
- ret = GNUNET_NETWORK_socket_send (sendsocket, write_pout.buf + write_pout.pos,
+ ret = GNUNET_NETWORK_socket_send (sendsocket, write_pout.buf + write_pout.pos,
write_pout.size - write_pout.pos);
-
+
if (GNUNET_SYSERR == ret)
{
fprintf (stderr, "Failed to send to the socket. Closing the socket. Error: \n");
print_last_error();
}
ExitProcess (2);
- //break;
}
else
{
(unsigned int) write_pout.size);
break;
}
-
+
if (write_pout.pos == write_pout.size)
{
write_pout.pos = 0;
write_pout.size = 0;
-
+
}
fprintf(stderr, "LOG : sends a message to a DEVICE\n"); //FIXME: debugging message
}
}
}
-
+
//if (GNUNET_NETWORK_fdset_isset (rfds, (struct GNUNET_NETWORK_Handle*)&stdin_handle))
- if (retval == stdin_pos) //FALSEEE!!!! NUUUUU EEE VOOIEE!!_----------------------------------------------------------?
+ if (retval == stdin_pos)
{
- fprintf (stderr, "-------------STDIN------------\n");
- //ssize_t ret;
+ //ssize_t ret;
//ret = GNUNET_NETWORK_socket_recv ((struct GNUNET_NETWORK_Handle *)&stdin_handle, readbuf, sizeof (write_pout.buf));
//ret = read (STDIN_FILENO, readbuf, sizeof (readbuf));
DWORD ret;
else
if (GNUNET_NETWORK_fdset_isset (rfds, dev.handle))
{
- fprintf (stderr, "-------------ACCEPT------------\n");
fprintf (stderr, "LOG: accepting connection\n");
struct GNUNET_NETWORK_Handle *readsocket;
- readsocket = GNUNET_NETWORK_socket_accept (dev.handle, (LPSOCKADDR)&acc_addr, &addr_len);
+ readsocket = GNUNET_NETWORK_socket_accept (dev.handle, (LPSOCKADDR)&acc_addr, &addr_len);
if (readsocket == NULL)
{
fprintf (stderr, "Accept error %d: ", GetLastError());
{
if (GNUNET_NETWORK_fdset_isset (rfds, rfds_list[i]))
{
- struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm;
+ struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm;
ssize_t ret;
fprintf (stderr, "LOG: reading something from the socket\n");//FIXME : debugging message
rrm = (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) write_std.buf;
ret = read_from_the_socket (rfds_list[i], (unsigned char *) &rrm->frame,
- sizeof (write_std.buf)
- - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
- + sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame),
+ sizeof (write_std.buf)
+ - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
+ + sizeof (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame),
rrm);
- fprintf (stderr, "MESSAGE: %s\n", readbuf);
if (0 >= ret)
{
fprintf (stderr, "Read error from raw socket: ");
print_last_error();
break;
-
+
}
if ((0 < ret) && (0 == mac_test (&rrm->frame, &dev)))
{
- write_std.size = ret
- + sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)
+ 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);
}
break;
}
- }
+ }
}
}
-
+
mst_destroy (stdin_mst);
stdin_mst = NULL;
WSACleanup();
#endif
return 1; /* we never exit 'normally' */
-}
\ No newline at end of file
+}
projects / oweals / gnunet.git / blobdiff