if HAVE_PCAP
if LINUX
- WANBIN = gnunet-transport-wlan-helper
+ WLAN_BIN = gnunet-transport-wlan-helper
+ WLAN_BIN_DUMMY = gnunet-transport-wlan-helper-dummy
WLAN_PLUGIN_LA = libgnunet_plugin_transport_wlan.la
WLAN_API_TEST = test_transport_api_wlan
WLAN_REL_TEST = test_transport_api_reliability_wlan
+ WLAN_UREL_TEST = test_transport_api_unreliability_wlan
endif
endif
bin_PROGRAMS = \
gnunet-transport \
- $(WANBIN) \
- gnunet-service-transport $(NATBIN)
+ $(WLAN_BIN) \
+ gnunet-service-transport $(NATBIN) \
+ $(WLAN_BIN_DUMMY)
bin_SCRIPTS = \
gnunet-transport-certificate-creation
gnunet_transport_wlan_helper_SOURCES = \
wlan/radiotap-parser.c \
wlan/helper_common.c \
- wlan/loopback_helper.c \
gnunet-transport-wlan-helper.c
+gnunet_transport_wlan_helper_dummy_SOURCES = \
+ wlan/radiotap-parser.c \
+ wlan/helper_common.c \
+ test_plugin_transport_wlan_dummy.c
+
gnunet_transport_wlan_helper_LDADD = \
$(top_builddir)/src/util/libgnunetutil.la \
-lpcap
+gnunet_transport_wlan_helper_dummy_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la \
+ -lpcap
+
gnunet_nat_client_SOURCES = \
$(NATCLIENT)
$(HTTP_QUOTA_TEST) \
$(HTTPS_QUOTA_TEST) \
$(WLAN_API_TEST) \
- $(WLAN_REL_TEST)
+ $(WLAN_REL_TEST) \
+ $(WLAN_UREL_TEST)
# TODO: add tests for nat, etc.
if !DISABLE_TEST_RUN
$(UNIX_QUOTA_TEST) \
$(HTTP_QUOTA_TEST) \
$(HTTPS_QUOTA_TEST) \
- $(WLAN_REL_TEST)
+ $(WLAN_UREL_TEST)
endif
+# $(WLAN_API_TEST)
+# $(WLAN_REL_TEST)
+
test_transport_ats_SOURCES = \
test_transport_ats.c
test_transport_ats_LDADD = -lm \
$(top_builddir)/src/transport/libgnunettransport.la \
$(top_builddir)/src/hello/libgnunethello.la \
$(top_builddir)/src/util/libgnunetutil.la
-
+
+test_transport_api_unreliability_wlan_SOURCES = \
+ test_transport_api_unreliability.c
+test_transport_api_unreliability_wlan_LDADD = \
+ $(top_builddir)/src/transport/libgnunettransport.la \
+ $(top_builddir)/src/hello/libgnunethello.la \
+ $(top_builddir)/src/util/libgnunetutil.la
test_transport_api_udp_SOURCES = \
test_transport_api.c
if (-1 == ioctl(dev->fd_raw, SIOCGIFINDEX, &ifr))
{
fprintf (stderr,
- "ioctl(SIOCGIFINDEX) on interface `%.*s' failed: %s\n",
+ "Line: 381 ioctl(SIOCGIFINDEX) on interface `%.*s' failed: %s\n",
IFNAMSIZ,
dev->iface,
strerror (errno));
/* Bring interface up*/
ifr.ifr_flags |= IFF_UP | IFF_BROADCAST | IFF_RUNNING;
- if (-1 != ioctl(dev->fd_raw, SIOCSIFFLAGS, &ifr))
+ if (-1 == ioctl(dev->fd_raw, SIOCSIFFLAGS, &ifr))
{
fprintf (stderr,
- "ioctl(SIOCSIFFLAGS) on interface `%.*s' failed: %s\n",
+ "Line: 434 ioctl(SIOCSIFFLAGS) on interface `%.*s' failed: %s\n",
IFNAMSIZ,
dev->iface,
strerror (errno));
}
/* lookup the hardware type */
- if (-1 != ioctl(dev->fd_raw, SIOCGIFHWADDR, &ifr))
+ if (-1 == ioctl(dev->fd_raw, SIOCGIFHWADDR, &ifr))
{
fprintf (stderr,
- "ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n",
+ "Line: 457 ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n",
IFNAMSIZ,
dev->iface,
strerror (errno));
}
+struct RadioTapheader
+{
+ struct ieee80211_radiotap_header header;
+ u8 rate;
+ u8 pad1;
+ u16 txflags;
+};
static void
stdin_send_hw (void *cls,
size_t sendsize;
// struct? // FIXME: make nice...
- unsigned char u8aRadiotap[] =
- { 0x00, 0x00, // <-- radiotap version
- 0x0c, 0x00, // <- radiotap header length
- 0x04, 0x80, 0x00, 0x00, // <-- bitmap
- 0x00, // <-- rate
- 0x00, // <-- padding for natural alignment
- 0x18, 0x00, // <-- TX flags
- };
+ struct RadioTapheader rtheader;
+ rtheader.header.it_version = 0;
+ rtheader.header.it_len = htole16(0x0c);
+ rtheader.header.it_present = htole32(0x00008004);
+ rtheader.rate = 0x00;
+ rtheader.txflags = htole16(IEEE80211_RADIOTAP_F_TX_NOACK | IEEE80211_RADIOTAP_F_TX_NOSEQ);
+
+ /* { 0x00, 0x00, <-- radiotap version
+ 0x0c, 0x00, <- radiotap header length
+ 0x04, 0x80, 0x00, 0x00, <-- bitmap
+ 0x00, <-- rate
+ 0x00, <-- padding for natural alignment
+ 0x18, 0x00, <-- TX flags
+ };*/
sendsize = ntohs(hdr->size);
if (sendsize < sizeof(struct Radiotap_Send) + sizeof(struct GNUNET_MessageHeader))
exit(1);
}
- u8aRadiotap[2] = htole16(sizeof(u8aRadiotap)); // WTF?
- u8aRadiotap[8] = header->rate;
- memcpy(write_pout->buf, u8aRadiotap, sizeof(u8aRadiotap));
- memcpy(write_pout->buf + sizeof(u8aRadiotap), &header[1], sendsize);
+ rtheader.header.it_len = htole16(sizeof(rtheader));
+ rtheader.rate = header->rate;
+ memcpy(write_pout->buf, &rtheader, sizeof(rtheader));
+ memcpy(write_pout->buf + sizeof(rtheader), &header[1], sendsize);
/* payload contains MAC address, but we don't trust it, so we'll
overwrite it with OUR MAC address again to prevent mischief */
- wlanheader = (struct ieee80211_frame *) (write_pout->buf + sizeof(u8aRadiotap));
+ wlanheader = (struct ieee80211_frame *) (write_pout->buf + sizeof(rtheader));
mac_set(wlanheader, dev);
- write_pout->size = sendsize + sizeof(u8aRadiotap);
+ write_pout->size = sendsize + sizeof(rtheader);
}
#if 0
int stdin_open;
struct GNUNET_SERVER_MessageStreamTokenizer * stdin_mst;
- if (2 != argc)
- {
- fprintf (stderr,
- "This program must be started with the interface argument.\n");
- fprintf (stderr,
- "Usage: interface-name\n");
- return 1;
- }
if (0 != wlaninit(&dev, argv[1]))
return 1;
uid = getuid();
int
main(int argc, char *argv[])
{
- if (3 != argc)
+ if (2 != argc)
{
fprintf (stderr,
- "This program must be started with the interface and the operating mode as argument.\n");
+ "This program must be started with the interface as argument.\n");
fprintf (stderr,
- "Usage: interface-name options\n"
- "options: 0 = with hardware\n"
- "1 = first loopback file\n"
- "2 = second loopback file\n"
+ "Usage: interface-name\n"
"\n");
return 1;
}
- if (strstr(argv[2], "1") || strstr(argv[2], "2"))
- return testmode(argc, argv);
- return hardwaremode(argc - 1, argv);
+ return hardwaremode(argc , argv);
}
#include "plugin_transport_wlan.h"
#include "gnunet_common.h"
#include "gnunet_crypto_lib.h"
-#include "wlan/ieee80211.h"
+//#include "wlan/ieee80211.h"
+//#include <netinet/ip.h>
#include <string.h>
/**
* Max size of packet from helper
*/
-#define WLAN_MTU 3000
+#define WLAN_MTU 2100
/**
* Time until retransmission of a fragment in ms
#define HALLO_BEACON_SCALING_FACTOR 900
-#define DEBUG_wlan GNUNET_YES
+#define DEBUG_wlan GNUNET_NO
#define DEBUG_wlan_retransmission GNUNET_NO
+#define DEBUG_wlan_ip_udp_packets_on_air GNUNET_NO
#define MESSAGE_LENGHT_UNKNOWN -1
//#define NO_MESSAGE_OR_MESSAGE_FINISHED -2
*/
#define LEARNED_ADDRESS_EXPIRATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 6)
+#define IEEE80211_ADDR_LEN 6 /* size of 802.11 address */
+
+#define IEEE80211_FC0_VERSION_MASK 0x03
+#define IEEE80211_FC0_VERSION_SHIFT 0
+#define IEEE80211_FC0_VERSION_0 0x00
+#define IEEE80211_FC0_TYPE_MASK 0x0c
+#define IEEE80211_FC0_TYPE_SHIFT 2
+#define IEEE80211_FC0_TYPE_MGT 0x00
+#define IEEE80211_FC0_TYPE_CTL 0x04
+#define IEEE80211_FC0_TYPE_DATA 0x08
+
+/*
+ * Structure of an internet header, naked of options.
+ */
+struct iph
+ {
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ unsigned int ip_hl:4; /* header length */
+ unsigned int ip_v:4; /* version */
+#endif
+#if __BYTE_ORDER == __BIG_ENDIAN
+ unsigned int ip_v:4; /* version */
+ unsigned int ip_hl:4; /* header length */
+#endif
+ u_int8_t ip_tos; /* type of service */
+ u_short ip_len; /* total length */
+ u_short ip_id; /* identification */
+ u_short ip_off; /* fragment offset field */
+#define IP_RF 0x8000 /* reserved fragment flag */
+#define IP_DF 0x4000 /* dont fragment flag */
+#define IP_MF 0x2000 /* more fragments flag */
+#define IP_OFFMASK 0x1fff /* mask for fragmenting bits */
+ u_int8_t ip_ttl; /* time to live */
+ u_int8_t ip_p; /* protocol */
+ u_short ip_sum; /* checksum */
+ struct in_addr ip_src, ip_dst; /* source and dest address */
+ };
+
+struct udphdr
+{
+ u_int16_t source;
+ u_int16_t dest;
+ u_int16_t len;
+ u_int16_t check;
+};
+
+/*
+ * generic definitions for IEEE 802.11 frames
+ */
+struct ieee80211_frame {
+ u_int8_t i_fc[2];
+ u_int8_t i_dur[2];
+ u_int8_t i_addr1[IEEE80211_ADDR_LEN];
+ u_int8_t i_addr2[IEEE80211_ADDR_LEN];
+ u_int8_t i_addr3[IEEE80211_ADDR_LEN];
+ u_int8_t i_seq[2];
+#if DEBUG_wlan_ip_udp_packets_on_air
+ u_int8_t llc[4];
+ struct iph ip;
+ struct udphdr udp;
+#endif
+} GNUNET_PACKED;
/**
* Initial handshake message for a session.
*/
static void
do_transmit(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+/**
+ * Generates a nice hexdump of a memory area.
+ *
+ * \param mem pointer to memory to dump
+ * \param length how many bytes to dump
+ */
+void hexdump(void *mem, unsigned length)
+{
+ char line[80];
+ char *src = (char*)mem;
+
+ printf(
+ "dumping %u bytes from %p\r\n"
+ " 0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF\r\n"
+ , length, src
+ );
+ unsigned i;
+ int j;
+
+ for (i=0; i<length; i+=16, src+=16) {
+ char *t = line;
+
+ t += sprintf(t, "%04x: ", i);
+ for ( j=0; j<16; j++) {
+ if (i+j < length)
+ t += sprintf(t, "%02X", src[j] & 0xff);
+ else
+ t += sprintf(t, " ");
+ t += sprintf(t, j%2 ? " " : "-");
+ }
+
+ t += sprintf(t, " ");
+ for (j=0; j<16; j++) {
+ if (i+j < length) {
+ if (isprint((unsigned char)src[j]))
+ t += sprintf(t, "%c", src[j]);
+ else
+ t += sprintf(t, ".");
+ } else {
+ t += sprintf(t, " ");
+ }
+ }
+
+ t += sprintf(t, "\r\n");
+ printf("%s", line);
+ }
+}
+
/**
* Sets a bit active in the bitArray. Increment bit-specific
* usage counter on disk only if below 4bit max (==15).
}
else
{
- plugin->server_write_delay_task
- = GNUNET_SCHEDULER_add_delayed(next_send,
- &delay_fragment_task, plugin);
+ plugin->server_write_delay_task = GNUNET_SCHEDULER_add_delayed(next_send,
+ &delay_fragment_task, plugin);
}
}
GNUNET_assert(session != NULL);
pm = session->pending_message;
-
#if DEBUG_wlan
if (pm == NULL)
{
uint16_t * tmp16;
const int rate = 11000000;
- Header->i_fc[0] = 0x08;
+ Header->i_fc[0] = IEEE80211_FC0_TYPE_DATA;
Header->i_fc[1] = 0x00;
memcpy(&Header->i_addr3, &mac_bssid, sizeof(mac_bssid));
memcpy(&Header->i_addr2, plugin->mac_address.mac, sizeof(plugin->mac_address));
tmp16 = (uint16_t*) Header->i_dur;
*tmp16 = (uint16_t) htole16((size * 1000000) / rate + 290);
+#if DEBUG_wlan_ip_udp_packets_on_air
+ uint crc = 0;
+ uint16_t * x;
+ int count;
+ Header->ip.ip_dst.s_addr = *((uint32_t*) &to_mac_addr->mac[2]);
+ Header->ip.ip_src.s_addr = *((uint32_t*) &plugin->mac_address.mac[2]);
+ Header->ip.ip_v = 4;
+ Header->ip.ip_hl = 5;
+ Header->ip.ip_p = 17;
+ Header->ip.ip_ttl = 1;
+ Header->ip.ip_len = htons(size + 8);
+ Header->ip.ip_sum = 0;
+ x =(uint16_t *) &Header->ip;
+ count = sizeof(struct iph);
+ while (count > 1) {
+ /* This is the inner loop */
+ crc += (unsigned short) * x++;
+ count -= 2;
+ }
+ /* Add left-over byte, if any */
+ if( count > 0 )
+ crc += * (unsigned char *) x;
+ crc = (crc & 0xffff) + (crc >> 16);
+ Header->ip.ip_sum = htons(~ (unsigned short) crc);
+ Header->llc[0] = 6;
+ Header->llc[1] = 6;
+ Header->udp.len = htons(size - sizeof(struct ieee80211_frame));
+
+#endif
+
return GNUNET_YES;
}
uint32_t
getcrc32(const char *msgbuf, size_t msgbuf_size)
{
- //TODO calc some crc
- return 0;
+
+ return GNUNET_CRYPTO_crc32_n(msgbuf, msgbuf_size);;
}
/**
//TODO DOXIGEN
static void
-finish_sending(void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+finish_sending(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct Finish_send * finish = cls;
struct Plugin * plugin;
GNUNET_free (finish);
return;
}
- bytes = GNUNET_DISK_file_write (plugin->server_stdin_handle,
- finish->msgheader,
- finish->size);
+ bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle,
+ finish->msgheader, finish->size);
GNUNET_assert (bytes != GNUNET_SYSERR);
if (bytes != finish->size)
{
finish->msgheader = finish->msgheader + bytes;
finish->size = finish->size - bytes;
- plugin->server_write_task
- = GNUNET_SCHEDULER_add_write_file(GNUNET_TIME_UNIT_FOREVER_REL,
- plugin->server_stdin_handle,
- &finish_sending, finish);
+ plugin->server_write_task = GNUNET_SCHEDULER_add_write_file(
+ GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle,
+ &finish_sending, finish);
}
else
{
ieeewlanheader = (struct ieee80211_frame *) &radioHeader[1];
getWlanHeader(ieeewlanheader, &(fm->session->addr), plugin, size);
+
//could be faster if content is just send and not copyed before
//fragmentheader is needed
fragheader.message_crc = htons(getcrc16(copystart, copysize));
wlanheader->header.size = htons(msgbuf_size + sizeof(struct WlanHeader));
wlanheader->header.type = htons(GNUNET_MESSAGE_TYPE_WLAN_DATA);
memcpy(&(wlanheader->target), target, sizeof(struct GNUNET_PeerIdentity));
- wlanheader->crc = htonl(getcrc32(msgbuf, msgbuf_size));
+ wlanheader->crc = 0;
memcpy(&wlanheader[1], msgbuf, msgbuf_size);
+ wlanheader->crc = htonl(getcrc32((char*) wlanheader, msgbuf_size + sizeof(struct WlanHeader)));
+ //GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Wlan message Header crc: %u, %u\n",getcrc32((char*) wlanheader, msgbuf_size + sizeof(struct WlanHeader)), wlanheader->crc);
+ //hexdump(newmsg->msg, msgbuf_size + sizeof(struct WlanHeader));
+
newmsg->transmit_cont = cont;
newmsg->transmit_cont_cls = cont_cls;
newmsg->timeout = GNUNET_TIME_relative_to_absolute(timeout);
struct Session_id_fragment_triple triple;
triple.session = session;
triple.message_id = message_id;
+ triple.fm = NULL;
GNUNET_CONTAINER_heap_iterate(plugin->pending_Fragment_Messages,
&search_fragment_message_from_session_and_id, &triple);
return triple.fm;
{
plugin->pendingsessions--;
GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head,
- plugin->pending_Sessions_tail,
- pendingsession);
+ plugin->pending_Sessions_tail,
+ pendingsession);
GNUNET_free(pendingsession);
GNUNET_assert (check == 0);
GNUNET_free(pm);
}
- GNUNET_CONTAINER_DLL_remove(plugin->sessions,
- plugin->sessions_tail,
- queue);
+ GNUNET_CONTAINER_DLL_remove(plugin->sessions,
+ plugin->sessions_tail,
+ queue);
GNUNET_free(queue->content);
GNUNET_free(queue);
plugin->session_count--;
asc(asc_cls, ret);
}
-
/**
* Function to test if fragment number already exists in the fragments received
*
struct FragmentationHeader * fh)
{
-
return testBit((char *) &rx_msg->received_fragments, ntohs(
fh->fragment_off_or_num));
const char * tempmsg;
const struct GNUNET_MessageHeader * temp_hdr;
struct GNUNET_PeerIdentity tmptarget;
+ int crc;
if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_DATA)
{
tempmsg = (char*) &wlanheader[1];
temp_hdr = (const struct GNUNET_MessageHeader *) &wlanheader[1];
-
- if (getcrc32(tempmsg, ntohs(wlanheader->header.size)) != ntohl(
- wlanheader->crc))
+ crc = ntohl(wlanheader->crc);
+ wlanheader->crc = 0;
+ if (getcrc32((char *) wlanheader, ntohs(wlanheader->header.size)) != crc)
{
//wrong crc, dispose message
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
- "Wlan message Header crc was wrong\n");
+ "Wlan message Header crc was wrong: %u != %u\n",getcrc32((char *) wlanheader, ntohs(wlanheader->header.size)), crc);
+ hexdump((void *)hdr, ntohs(hdr->size));
return;
}
static int
wlan_transport_start_wlan_helper(struct Plugin *plugin, int testmode)
{
- const char * filename = "gnunet-transport-wlan-helper";
+ const char * filenamehw = "gnunet-transport-wlan-helper";
+ const char * filenameloopback = "gnunet-transport-wlan-helper-dummy";
plugin->server_stdout = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_NO, GNUNET_YES);
if (plugin->server_stdout == NULL)
return GNUNET_SYSERR;
if (plugin->server_stdin == NULL)
return GNUNET_SYSERR;
+
+ /* Start the server process */
+
+ if (testmode == 0)
+ {
+
#if DEBUG_wlan
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Starting gnunet-wlan-helper process cmd: %s %s %i\n", filename,
+ "Starting gnunet-wlan-helper process cmd: %s %s %i\n", filenamehw,
plugin->interface, testmode);
#endif
- /* Start the server process */
- plugin->server_proc = GNUNET_OS_start_process(plugin->server_stdin,
- plugin->server_stdout, filename, filename, plugin->interface, ((testmode
- == 1) ? "1" : (testmode == 2) ? "2" : "0"), NULL);
+ plugin->server_proc = GNUNET_OS_start_process(plugin->server_stdin,
+ plugin->server_stdout, filenamehw, filenamehw, plugin->interface, NULL);
+ }
+ else if (testmode == 1)
+ {
+
+#if DEBUG_wlan
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Starting gnunet-wlan-helper loopback 1 process cmd: %s %s %i\n", filenameloopback,
+ plugin->interface, testmode);
+#endif
+
+ plugin->server_proc = GNUNET_OS_start_process(plugin->server_stdin,
+ plugin->server_stdout, filenameloopback, filenameloopback, "1", NULL);
+ }
+ else if (testmode == 2)
+ {
+#if DEBUG_wlan
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Starting gnunet-wlan-helper loopback 2 process cmd: %s %s %i\n", filenameloopback,
+ plugin->interface, testmode);
+#endif
+ plugin->server_proc = GNUNET_OS_start_process(plugin->server_stdin,
+ plugin->server_stdout, filenameloopback, filenameloopback, "2", NULL);
+ }
if (plugin->server_proc == NULL)
{
#if DEBUG_wlan
#endif
- GNUNET_OS_process_close(plugin->server_proc);
GNUNET_DISK_pipe_close(plugin->server_stdout);
GNUNET_DISK_pipe_close(plugin->server_stdin);
+ GNUNET_OS_process_kill(plugin->server_proc,9);
+ GNUNET_OS_process_close(plugin->server_proc);
+
GNUNET_assert (cls !=NULL);
//free sessions
plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK;
}
-
if (plugin->suid_tokenizer != NULL)
GNUNET_SERVER_mst_destroy(plugin->suid_tokenizer);
api->address_pretty_printer = &wlan_plugin_address_pretty_printer;
api->check_address = &wlan_plugin_address_suggested;
api->address_to_string = &wlan_plugin_address_to_string;
-
//read config
if (GNUNET_CONFIGURATION_have_value(env->cfg, "transport-wlan", "TESTMODE"))
*/\r
/**\r
* @file transport/test_transport_wlan_dummy.c\r
- * @brief helper for the testcase for plugin_transport_wlan.c\r
+ * @brief helper for the testcases for plugin_transport_wlan.c\r
* @author David Brodski\r
*/\r
\r
+#include <sys/socket.h>\r
+#include <sys/ioctl.h>\r
+#include <sys/types.h>\r
+#include <sys/wait.h>\r
+#include <sys/time.h>\r
+#include <sys/stat.h>\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+\r
+#include <errno.h>\r
+#include <resolv.h>\r
+#include <string.h>\r
+#include <utime.h>\r
+#include <unistd.h>\r
+#include <getopt.h>\r
+\r
#include "platform.h"\r
#include "gnunet_constants.h"\r
#include "gnunet_os_lib.h"\r
#include "gnunet_transport_plugin.h"\r
#include "transport.h"\r
+#include "gnunet_util_lib.h"\r
#include "plugin_transport_wlan.h"\r
#include "gnunet_common.h"\r
#include "gnunet-transport-wlan-helper.h"\r
+#include "gnunet_crypto_lib.h"\r
+#include "wlan/loopback_helper.h"\r
+#include "wlan/helper_common.h"\r
\r
-#include <stdio.h>\r
-#include <stdlib.h>\r
-#include <sys/stat.h>\r
+int first;\r
\r
-#define FIFO_FILE1 "MYFIFOin"\r
-#define FIFO_FILE2 "MYFIFOout"\r
-#define MAXLINE 5000\r
-\r
-int closeprog = 0;\r
+static void\r
+sigfunc(int sig)\r
+{\r
+ closeprog = 1;\r
+ unlink(FIFO_FILE1);\r
+ unlink(FIFO_FILE2);\r
+}\r
\r
-void sigfunc(int sig)\r
+static void\r
+stdin_send(void *cls, void *client, const struct GNUNET_MessageHeader *hdr)\r
{\r
+ struct sendbuf *write_pout = cls;\r
+ int sendsize;\r
+ struct GNUNET_MessageHeader newheader;\r
+ unsigned char * from_data;\r
+ unsigned char * to_data;\r
+ //unsigned char * from_radiotap;\r
+ unsigned char * to_radiotap;\r
+ //unsigned char * from_start;\r
+ unsigned char * to_start;\r
+\r
+ sendsize = ntohs(hdr->size) - sizeof(struct Radiotap_Send)\r
+ + sizeof(struct Radiotap_rx);\r
+\r
+ if (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA != ntohs(hdr->type))\r
+ {\r
+ fprintf(stderr, "Function stdin_send: wrong packet type\n");\r
+ exit(1);\r
+ }\r
+ if ((sendsize + write_pout->size) > MAXLINE * 2)\r
+ {\r
+ fprintf(stderr, "Function stdin_send: Packet too big for buffer\n");\r
+ exit(1);\r
+ }\r
\r
- if(sig != SIGINT || sig != SIGTERM || sig != SIGKILL)\r
- return;\r
- else\r
- {\r
- closeprog = 1;\r
- exit(0);\r
- }\r
+ newheader.size = htons(sendsize);\r
+ newheader.type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA);\r
+\r
+ to_start = write_pout->buf + write_pout->size;\r
+ to_radiotap = to_start + sizeof(struct GNUNET_MessageHeader);\r
+ to_data = to_radiotap + sizeof(struct Radiotap_rx);\r
+\r
+ from_data = ((unsigned char *) hdr) + sizeof(struct Radiotap_Send)\r
+ + sizeof(struct GNUNET_MessageHeader);\r
+\r
+ memcpy(to_start, &newheader, sizeof(struct GNUNET_MessageHeader));\r
+ write_pout->size += sizeof(struct GNUNET_MessageHeader);\r
+\r
+ write_pout->size += sizeof(struct Radiotap_rx);\r
+\r
+ memcpy(to_data, from_data, ntohs(hdr->size) - sizeof(struct Radiotap_Send)\r
+ - sizeof(struct GNUNET_MessageHeader));\r
+ write_pout->size += ntohs(hdr->size) - sizeof(struct Radiotap_Send)\r
+ - sizeof(struct GNUNET_MessageHeader);\r
}\r
\r
+static void\r
+file_in_send(void *cls, void *client, const struct GNUNET_MessageHeader *hdr)\r
+{\r
+ struct sendbuf * write_std = cls;\r
+ uint16_t sendsize;\r
\r
+ sendsize = ntohs(hdr->size);\r
+\r
+ if (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA != ntohs(hdr->type))\r
+ {\r
+ fprintf(stderr, "Function file_in_send: wrong packet type\n");\r
+ exit(1);\r
+ }\r
+ if ((sendsize + write_std->size) > MAXLINE * 2)\r
+ {\r
+ fprintf(stderr, "Function file_in_send: Packet too big for buffer\n");\r
+ exit(1);\r
+ }\r
+\r
+ memcpy(write_std->buf + write_std->size, hdr, sendsize);\r
+ write_std->size += sendsize;\r
+}\r
+\r
+int closeprog;\r
\r
\r
int\r
-main(int argc, char *argv[])\r
+testmode(int argc, char *argv[])\r
{\r
struct stat st;\r
- struct stat st2;\r
int erg;\r
- int first;\r
- FILE *fpin;\r
- FILE *fpout;\r
- pid_t pid;\r
\r
- perror("Test");\r
+ FILE *fpin = NULL;\r
+ FILE *fpout = NULL;\r
\r
+ int fdpin;\r
+ int fdpout;\r
\r
//make the fifos if needed\r
- if (stat(FIFO_FILE1, &st) != 0)\r
+ if (0 != stat(FIFO_FILE1, &st))\r
{\r
- if (stat(FIFO_FILE2, &st2) == 0)\r
+ if (0 == stat(FIFO_FILE2, &st))\r
{\r
- perror("FIFO 2 exists, but FIFO 1 not, blub");\r
+ fprintf(stderr, "FIFO_FILE2 exists, but FIFO_FILE1 not\n");\r
exit(1);\r
}\r
- first = 1;\r
- perror("First");\r
+\r
umask(0);\r
- erg = mknod(FIFO_FILE1, S_IFIFO | 0666, 0);\r
+ //unlink(FIFO_FILE1);\r
+ //unlink(FIFO_FILE2);\r
+ // FIXME: use mkfifo!\r
+ erg = mknod(FIFO_FILE1, S_IFIFO | 0666, 0);\r
+ if (0 != erg)\r
+ {\r
+ fprintf(stderr, "Error at mknode1 \n");\r
+ //exit(1);\r
+ }\r
erg = mknod(FIFO_FILE2, S_IFIFO | 0666, 0);\r
+ if (0 != erg)\r
+ {\r
+ fprintf(stderr, "Error at mknode2 \n");\r
+ //exit(1);\r
+ }\r
\r
- if ((fpin = fopen(FIFO_FILE1, "r")) == NULL)\r
+ }\r
+ else\r
+ {\r
+\r
+ if (0 != stat(FIFO_FILE2, &st))\r
{\r
- perror("fopen");\r
+ fprintf(stderr, "FIFO_FILE1 exists, but FIFO_FILE2 not\n");\r
exit(1);\r
}\r
- if ((fpout = fopen(FIFO_FILE2, "w")) == NULL)\r
+\r
+ }\r
+\r
+ if (strstr(argv[1], "1"))\r
+ {\r
+ //fprintf(stderr, "First\n");\r
+ first = 1;\r
+ fpin = fopen(FIFO_FILE1, "r");\r
+ if (NULL == fpin)\r
+ {\r
+ fprintf(stderr, "fopen of read FIFO_FILE1\n");\r
+ goto end;\r
+ }\r
+ fpout = fopen(FIFO_FILE2, "w");\r
+ if (NULL == fpout)\r
{\r
- perror("fopen");\r
- exit(1);\r
+ fprintf(stderr, "fopen of write FIFO_FILE2\n");\r
+ goto end;\r
}\r
+\r
}\r
else\r
{\r
first = 0;\r
- perror("Second");\r
- if (stat(FIFO_FILE2, &st2) != 0)\r
+ //fprintf(stderr, "Second\n");\r
+ fpout = fopen(FIFO_FILE1, "w");\r
+ if (NULL == fpout)\r
{\r
- perror("FIFO 1 exists, but FIFO 2 not, mäh");\r
- exit(1);\r
+ fprintf(stderr, "fopen of write FIFO_FILE1\n");\r
+ goto end;\r
}\r
- if ((fpout = fopen(FIFO_FILE1, "w")) == NULL)\r
+ fpin = fopen(FIFO_FILE2, "r");\r
+ if (NULL == fpin)\r
{\r
- perror("fopen");\r
- exit(1);\r
- }\r
- if ((fpin = fopen(FIFO_FILE2, "r")) == NULL)\r
- {\r
- perror("fopen");\r
- exit(1);\r
+ fprintf(stderr, "fopen of read FIFO_FILE2\n");\r
+ goto end;\r
}\r
\r
}\r
\r
- // fork\r
+ fdpin = fileno(fpin);\r
+ GNUNET_assert(fpin >= 0);\r
\r
- if ((pid = fork()) < 0)\r
+ if (fdpin >= FD_SETSIZE)\r
{\r
- perror("FORK ERROR");\r
-\r
- //clean up\r
- if (first == 1)\r
- {\r
- unlink(FIFO_FILE1);\r
- unlink(FIFO_FILE2);\r
- }\r
- fclose(fpin);\r
- fclose(fpout);\r
- return -3;\r
+ fprintf(stderr, "File fdpin number too large (%d > %u)\n", fdpin,\r
+ (unsigned int) FD_SETSIZE);\r
+ goto end;\r
}\r
- else if (pid == 0) // CHILD PROCESS\r
+\r
+ fdpout = fileno(fpout);\r
+ GNUNET_assert(fdpout >= 0 );\r
+\r
+ if (fdpout >= FD_SETSIZE)\r
{\r
- perror("Child");\r
- signal(SIGINT, sigfunc);\r
- signal(SIGTERM, sigfunc);\r
- signal(SIGKILL, sigfunc);\r
- int rv = 0;\r
- int readc = 0;\r
- int pos = 0;\r
- char line[MAXLINE];\r
+ fprintf(stderr, "File fdpout number too large (%d > %u)\n", fdpout,\r
+ (unsigned int) FD_SETSIZE);\r
+ goto end;\r
\r
- fd_set rfds;\r
- fd_set wfds;\r
- struct timeval tv;\r
- int retval;\r
+ }\r
\r
+ signal(SIGINT, &sigfunc);\r
+ signal(SIGTERM, &sigfunc);\r
\r
- tv.tv_sec = 5;\r
- tv.tv_usec = 0;\r
+ char readbuf[MAXLINE];\r
+ int readsize = 0;\r
+ struct sendbuf write_std;\r
+ write_std.size = 0;\r
+ write_std.pos = 0;\r
\r
+ struct sendbuf write_pout;\r
+ write_pout.size = 0;\r
+ write_pout.pos = 0;\r
\r
- FD_ZERO(&rfds);\r
- FD_SET(STDIN_FILENO, &rfds);\r
+ int ret = 0;\r
+ int maxfd = 0;\r
\r
- FD_ZERO(&wfds);\r
- FD_SET(STDOUT_FILENO, &wfds);\r
+ fd_set rfds;\r
+ fd_set wfds;\r
+ struct timeval tv;\r
+ int retval;\r
\r
- struct GNUNET_SERVER_MessageStreamTokenizer * stdin_mst;\r
- struct GNUNET_SERVER_MessageStreamTokenizer * file_in_mst;\r
+ struct GNUNET_SERVER_MessageStreamTokenizer * stdin_mst;\r
+ struct GNUNET_SERVER_MessageStreamTokenizer * file_in_mst;\r
\r
- stdin_mst = GNUNET_SERVER_mst_create(&stdin_send, NULL);\r
- file_in_mst = GNUNET_SERVER_mst_create(&file_in_send, NULL);\r
+ stdin_mst = GNUNET_SERVER_mst_create(&stdin_send, &write_pout);\r
+ file_in_mst = GNUNET_SERVER_mst_create(&file_in_send, &write_std);\r
\r
- while (closeprog == 0)\r
- {\r
- readc = 0;\r
+ //send mac first\r
\r
+ struct MacAddress macaddr;\r
\r
- while (readc < sizeof( struct RadiotapHeader) + sizeof(struct GNUNET_MessageHeader)){\r
- if ((rv = read(STDIN_FILENO, line, MAXLINE)) < 0)\r
- {\r
- perror("READ ERROR FROM STDIN");\r
- }\r
- readc += rv;\r
- }\r
+ //Send random mac address\r
+ macaddr.mac[0] = 0x13;\r
+ macaddr.mac[1] = 0x22;\r
+ macaddr.mac[2] = 0x33;\r
+ macaddr.mac[3] = 0x44;\r
+ macaddr.mac[4] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 256);\r
+ macaddr.mac[5] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, 256);\r
\r
- pos = 0;\r
+ write_std.size = send_mac_to_plugin((char *) write_std.buf, macaddr.mac);\r
\r
- //fwrite(&line[pos], 1, sizeof(struct GNUNET_MessageHeader), fpout);\r
+ while (0 == closeprog)\r
+ {\r
\r
- //pos += sizeof(struct GNUNET_MessageHeader);\r
+ maxfd = 0;\r
\r
- //do not send radiotap header\r
- pos += sizeof( struct RadiotapHeader);\r
+ //set timeout\r
+ tv.tv_sec = 5;\r
+ tv.tv_usec = 0;\r
\r
- while (pos < readc)\r
- {\r
- pos += fwrite(&line[pos], 1, readc - pos, fpout);\r
- }\r
+ FD_ZERO(&rfds);\r
+ // if output queue is empty\r
+ if (0 == write_pout.size)\r
+ {\r
+ FD_SET(STDIN_FILENO, &rfds);\r
+\r
+ }\r
+ if (0 == write_std.size)\r
+ {\r
+ FD_SET(fdpin, &rfds);\r
+ maxfd = fdpin;\r
+ }\r
+ FD_ZERO(&wfds);\r
+ // if there is something to write\r
+ if (0 < write_std.size)\r
+ {\r
+ FD_SET(STDOUT_FILENO, &wfds);\r
+ maxfd = MAX(maxfd, STDOUT_FILENO);\r
}\r
\r
+ if (0 < write_pout.size)\r
+ {\r
+ FD_SET(fdpout, &wfds);\r
+ maxfd = MAX(maxfd, fdpout);\r
+ }\r
\r
- //clean up\r
- fclose(fpout);\r
- }\r
- else // PARENT PROCESS\r
- {\r
- perror("Parent");\r
- signal(SIGINT, sigfunc);\r
- signal(SIGTERM, sigfunc);\r
- signal(SIGKILL, sigfunc);\r
- int rv = 0;\r
- ssize_t pos = 0;\r
- char line[MAXLINE];\r
- struct Wlan_Helper_Control_Message macmsg;\r
-\r
-\r
- //Send random mac address\r
- macmsg.mac.mac[0] = 0x13;\r
- macmsg.mac.mac[1] = 0x22;\r
- macmsg.mac.mac[2] = 0x33;\r
- macmsg.mac.mac[3] = 0x44;\r
- macmsg.mac.mac[4] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 255);\r
- macmsg.mac.mac[5] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 255);\r
- macmsg.hdr.size = sizeof(struct Wlan_Helper_Control_Message);\r
-\r
- pos = 0;\r
- /*\r
- while (pos < sizeof(struct Wlan_Helper_Control_Message))\r
+ retval = select(maxfd + 1, &rfds, &wfds, NULL, &tv);\r
+\r
+ if (-1 == retval && EINTR == errno)\r
+ {\r
+ continue;\r
+ }\r
+ if (0 > retval)\r
{\r
- pos += write(STDOUT_FILENO, &macmsg + pos, sizeof(struct Wlan_Helper_Control_Message) - pos);\r
+ fprintf(stderr, "select failed: %s\n", strerror(errno));\r
+ closeprog = 1;\r
+ break;\r
}\r
- */\r
- while (closeprog == 0)\r
+\r
+ if (FD_ISSET(STDOUT_FILENO, &wfds))\r
{\r
- if ((rv = fread(line, 1, MAXLINE, fpin)) < 0)\r
+ ret = write(STDOUT_FILENO, write_std.buf + write_std.pos,\r
+ write_std.size - write_std.pos);\r
+\r
+ if (0 > ret)\r
+ {\r
+ closeprog = 1;\r
+ fprintf(stderr, "Write ERROR to STDOUT\n");\r
+ break;\r
+ }\r
+ else\r
{\r
- perror("READ ERROR FROM fpin");\r
+ write_std.pos += ret;\r
+ // check if finished\r
+ if (write_std.pos == write_std.size)\r
+ {\r
+ write_std.pos = 0;\r
+ write_std.size = 0;\r
+ }\r
}\r
+ }\r
\r
- pos = 0;\r
- while (pos < rv)\r
+ if (FD_ISSET(fdpout, &wfds))\r
+ {\r
+ ret = write(fdpout, write_pout.buf + write_pout.pos, write_pout.size\r
+ - write_pout.pos);\r
+\r
+ if (0 > ret)\r
+ {\r
+ closeprog = 1;\r
+ fprintf(stderr, "Write ERROR to fdpout\n");\r
+ }\r
+ else\r
{\r
- pos += write(STDOUT_FILENO, &line[pos], rv - pos);\r
+ write_pout.pos += ret;\r
+ // check if finished\r
+ if (write_pout.pos == write_pout.size)\r
+ {\r
+ write_pout.pos = 0;\r
+ write_pout.size = 0;\r
+ }\r
}\r
}\r
\r
+ if (FD_ISSET(STDIN_FILENO, &rfds))\r
+ {\r
+ readsize = read(STDIN_FILENO, readbuf, sizeof(readbuf));\r
\r
- //clean up\r
- fclose(fpin);\r
+ if (0 > readsize)\r
+ {\r
+ closeprog = 1;\r
+ fprintf(stderr, "Read ERROR to STDIN_FILENO\n");\r
+ }\r
+ else if (0 < readsize)\r
+ {\r
+ GNUNET_SERVER_mst_receive(stdin_mst, NULL, readbuf, readsize,\r
+ GNUNET_NO, GNUNET_NO);\r
\r
- if (first == 1)\r
+ }\r
+ else\r
+ {\r
+ //eof\r
+ closeprog = 1;\r
+ }\r
+ }\r
+\r
+ if (FD_ISSET(fdpin, &rfds))\r
{\r
- unlink(FIFO_FILE1);\r
- unlink(FIFO_FILE2);\r
+ readsize = read(fdpin, readbuf, sizeof(readbuf));\r
+\r
+ if (0 > readsize)\r
+ {\r
+ closeprog = 1;\r
+ fprintf(stderr, "Read ERROR to fdpin: %s\n", strerror(errno));\r
+ break;\r
+ }\r
+ else if (0 < readsize)\r
+ {\r
+ GNUNET_SERVER_mst_receive(file_in_mst, NULL, readbuf, readsize,\r
+ GNUNET_NO, GNUNET_NO);\r
+\r
+ }\r
+ else\r
+ {\r
+ //eof\r
+ closeprog = 1;\r
+ }\r
}\r
+\r
}\r
\r
- // Write the input to the output\r
+ //clean up\r
+\r
+ GNUNET_SERVER_mst_destroy(stdin_mst);\r
+ GNUNET_SERVER_mst_destroy(file_in_mst);\r
+\r
+ end: if (fpout != NULL)\r
+ fclose(fpout);\r
+ if (fpin != NULL)\r
+ fclose(fpin);\r
+\r
+ if (1 == first)\r
+ {\r
+ unlink(FIFO_FILE1);\r
+ unlink(FIFO_FILE2);\r
+ }\r
\r
return (0);\r
}\r
\r
+int\r
+main(int argc, char *argv[])\r
+{\r
+ if (2 != argc)\r
+ {\r
+ fprintf (stderr,\r
+ "This program must be started with the operating mode as argument.\n");\r
+ fprintf (stderr,\r
+ "Usage: options\n"\r
+ "options:\n"\r
+ "1 = first loopback file\n"\r
+ "2 = second loopback file\n"\r
+ "\n");\r
+ return 1;\r
+ }\r
+ if (strstr(argv[1], "1") || strstr(argv[1], "2"))\r
+ return testmode(argc, argv);\r
+ return 1;\r
+}\r
static int is_unix;
+static int is_wlan;
+
static int connected;
static unsigned long long total_bytes;
setup_peer (&p1, "test_transport_api_tcp_nat_peer1.conf");
setup_peer (&p2, "test_transport_api_tcp_nat_peer2.conf");
}
+ else if (is_wlan)
+ {
+ setup_peer (&p1, "test_transport_api_wlan_peer1.conf");
+ setup_peer (&p2, "test_transport_api_wlan_peer2.conf");
+ }
else
GNUNET_assert (0);
GNUNET_assert(p1.th != NULL);
is_unix = GNUNET_YES;
GNUNET_asprintf(&test_name, "unix");
}
+ else if (strstr(argv[0], "wlan") != NULL)
+ {
+ is_wlan = GNUNET_YES;
+ }
GNUNET_log_setup ("test-transport-api-reliability",
#if VERBOSE
"DEBUG",
projects / oweals / gnunet.git / commitdiff