void
stop_broadcast (struct Plugin *plugin)
{
if (plugin->broadcast_ipv4)
{
if (plugin->send_ipv4_broadcast_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (plugin->send_ipv4_broadcast_task);
plugin->send_ipv4_broadcast_task = GNUNET_SCHEDULER_NO_TASK;
}
if (plugin->broadcast_ipv4_mst != NULL)
GNUNET_SERVER_mst_destroy (plugin->broadcast_ipv4_mst);
while (plugin->ipv4_broadcast_head != NULL)
{
struct BroadcastAddress *p = plugin->ipv4_broadcast_head;
GNUNET_CONTAINER_DLL_remove (plugin->ipv4_broadcast_head,
plugin->ipv4_broadcast_tail, p);
GNUNET_free (p->addr);
GNUNET_free (p);
}
}
if (plugin->broadcast_ipv6)
{
/* Create IPv6 multicast request */
struct ipv6_mreq multicastRequest;
multicastRequest.ipv6mr_multiaddr =
plugin->ipv6_multicast_address.sin6_addr;
multicastRequest.ipv6mr_interface = 0;
/* Join the multicast address */
if (GNUNET_NETWORK_socket_setsockopt
(plugin->sockv6, IPPROTO_IPV6, IPV6_LEAVE_GROUP,
(char *) &multicastRequest, sizeof (multicastRequest)) != GNUNET_OK)
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, setsockopt);
}
else
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "IPv6 Broadcasting stopped\n");
}
if (plugin->send_ipv6_broadcast_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (plugin->send_ipv6_broadcast_task);
plugin->send_ipv6_broadcast_task = GNUNET_SCHEDULER_NO_TASK;
}
if (plugin->broadcast_ipv6_mst != NULL)
GNUNET_SERVER_mst_destroy (plugin->broadcast_ipv6_mst);
}
}
/**
* Free's the resources occupied by the helper handle
*
* @param h the helper handle to free
*/
void
GNUNET_HELPER_destroy (struct GNUNET_HELPER_Handle *h)
{
unsigned int c;
struct GNUNET_HELPER_SendHandle *sh;
if (NULL != h->write_task)
{
GNUNET_SCHEDULER_cancel (h->write_task);
h->write_task = NULL;
}
GNUNET_assert (NULL == h->read_task);
GNUNET_assert (NULL == h->restart_task);
while (NULL != (sh = h->sh_head))
{
GNUNET_CONTAINER_DLL_remove (h->sh_head,
h->sh_tail,
sh);
if (NULL != sh->cont)
sh->cont (sh->cont_cls, GNUNET_SYSERR);
GNUNET_free (sh);
}
if (NULL != h->mst)
GNUNET_SERVER_mst_destroy (h->mst);
GNUNET_free (h->binary_name);
for (c = 0; h->binary_argv[c] != NULL; c++)
GNUNET_free (h->binary_argv[c]);
GNUNET_free (h->binary_argv);
GNUNET_free (h);
}
/**
* Stop broadcasting subsystem.
*
* @param plugin
*/
void
stop_broadcast (struct Plugin *plugin)
{
if (GNUNET_YES == plugin->enable_broadcasting)
{
/* Disable broadcasting */
while (plugin->broadcast_head != NULL)
{
struct BroadcastAddress *p = plugin->broadcast_head;
if (p->broadcast_task != NULL)
{
GNUNET_SCHEDULER_cancel (p->broadcast_task);
p->broadcast_task = NULL;
}
if ((GNUNET_YES == plugin->enable_ipv6) &&
(NULL != plugin->sockv6) &&
(p->addrlen == sizeof (struct sockaddr_in6)))
{
/* Create IPv6 multicast request */
struct ipv6_mreq multicastRequest;
const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *) p->addr;
multicastRequest.ipv6mr_multiaddr =
plugin->ipv6_multicast_address.sin6_addr;
multicastRequest.ipv6mr_interface = s6->sin6_scope_id;
/* Leave the multicast group */
if (GNUNET_OK ==
GNUNET_NETWORK_socket_setsockopt
(plugin->sockv6, IPPROTO_IPV6, IPV6_LEAVE_GROUP,
&multicastRequest, sizeof (multicastRequest)))
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsockopt");
}
else
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "IPv6 multicasting stopped\n");
}
}
#if LINUX
GNUNET_DISK_file_close(p->cryogenic_fd);
#endif
GNUNET_CONTAINER_DLL_remove (plugin->broadcast_head,
plugin->broadcast_tail, p);
GNUNET_free (p->addr);
GNUNET_free (p);
}
}
/* Destroy MSTs */
if (NULL != plugin->broadcast_mst)
{
GNUNET_SERVER_mst_destroy (plugin->broadcast_mst);
plugin->broadcast_mst = NULL;
}
}
void
delete_session (struct Session *s)
{
stop_session_timeout(s);
if (s->msg_tk != NULL)
{
GNUNET_SERVER_mst_destroy (s->msg_tk);
s->msg_tk = NULL;
}
GNUNET_free (s->addr);
GNUNET_free_non_null (s->server_recv);
GNUNET_free_non_null (s->server_send);
GNUNET_free (s);
}
/**
* Delete session s
*
* @param s the session to delete
*/
static void
client_delete_session (struct Session *s)
{
struct HTTP_Client_Plugin *plugin = s->plugin;
struct HTTP_Message *pos;
struct HTTP_Message *next;
client_stop_session_timeout (s);
if (GNUNET_SCHEDULER_NO_TASK != s->put_disconnect_task)
{
GNUNET_SCHEDULER_cancel (s->put_disconnect_task);
s->put_disconnect_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_CONTAINER_DLL_remove (plugin->head, plugin->tail, s);
next = s->msg_head;
while (NULL != (pos = next))
{
next = pos->next;
GNUNET_CONTAINER_DLL_remove (s->msg_head, s->msg_tail, pos);
if (pos->transmit_cont != NULL)
pos->transmit_cont (pos->transmit_cont_cls, &s->target, GNUNET_SYSERR,
pos->size, pos->pos + s->overhead);
s->overhead = 0;
GNUNET_free (pos);
}
if (s->msg_tk != NULL)
{
GNUNET_SERVER_mst_destroy (s->msg_tk);
s->msg_tk = NULL;
}
GNUNET_free (s->addr);
GNUNET_free (s->url);
GNUNET_free (s);
}
/**
* We're done with a particular client, clean up.
*
* @param sc client to clean up
*/
static void
terminate_stream (struct StreamClient *sc)
{
GNUNET_STATISTICS_update (GSF_stats,
gettext_noop ("# stream connections active"), -1,
GNUNET_NO);
if (GNUNET_SCHEDULER_NO_TASK != sc->terminate_task)
GNUNET_SCHEDULER_cancel (sc->terminate_task);
if (GNUNET_SCHEDULER_NO_TASK != sc->timeout_task)
GNUNET_SCHEDULER_cancel (sc->timeout_task);
if (NULL != sc->rh)
GNUNET_STREAM_io_read_cancel (sc->rh);
if (NULL != sc->wh)
GNUNET_STREAM_io_write_cancel (sc->wh);
if (NULL != sc->qe)
GNUNET_DATASTORE_cancel (sc->qe);
GNUNET_SERVER_mst_destroy (sc->mst);
GNUNET_STREAM_close (sc->socket);
GNUNET_CONTAINER_DLL_remove (sc_head,
sc_tail,
sc);
sc_count--;
GNUNET_free (sc);
}
/**
* Main function of a program that pretends to be a WLAN card.
*
* @param argc should be 2
* @param argv either '1' or '2', depending on which of the two cards this dummy is to emulate
* @return 1 on error, 0 if terminated normally via signal
*/
int
main (int argc, char *argv[])
{
struct stat st;
int erg;
FILE *fpin = NULL;
FILE *fpout = NULL;
int fdpin;
int fdpout;
char readbuf[MAXLINE];
int readsize;
struct SendBuffer write_std;
struct SendBuffer write_pout;
int ret;
int maxfd;
fd_set rfds;
fd_set wfds;
struct timeval tv;
int retval;
struct GNUNET_SERVER_MessageStreamTokenizer *stdin_mst = NULL;
struct GNUNET_SERVER_MessageStreamTokenizer *file_in_mst = NULL;
struct GNUNET_TRANSPORT_WLAN_MacAddress macaddr;
int first;
if ( (2 != argc) ||
((0 != strcmp (argv[1], "1")) && (0 != strcmp (argv[1], "2"))) )
{
FPRINTF (stderr,
"%s",
"This program must be started with the operating mode (1 or 2) as the only argument.\n");
return 1;
}
/* make the fifos if needed */
umask (0);
if ( (GNUNET_OK != GNUNET_DISK_directory_create_for_file (FIFO_FILE1)) ||
(GNUNET_OK != GNUNET_DISK_directory_create_for_file (FIFO_FILE2)) )
{
FPRINTF (stderr, "Failed to create directory for file `%s'\n", FIFO_FILE1);
return 1;
}
if (0 == strcmp (argv[1], "1") )
{
if (0 != stat (FIFO_FILE1, &st))
{
erg = mkfifo (FIFO_FILE1, 0666);
if ( (0 != erg) && (EEXIST != errno) )
FPRINTF (stderr, "Error in mkfifo(%s): %s\n", FIFO_FILE1,
strerror (errno));
}
}
else
{
if (0 != stat (FIFO_FILE2, &st))
{
erg = mkfifo (FIFO_FILE2, 0666);
if ( (0 != erg) && (EEXIST != errno) )
FPRINTF (stderr, "Error in mkfifo(%s): %s\n", FIFO_FILE2,
strerror (errno));
}
}
if (0 == strcmp (argv[1], "1"))
{
first = 1;
fpin = fopen (FIFO_FILE1, "r");
if (NULL == fpin)
{
FPRINTF (stderr, "fopen of read FIFO_FILE1 failed: %s\n", STRERROR (errno));
goto end;
}
if (NULL == (fpout = fopen (FIFO_FILE2, "w")))
{
erg = mkfifo (FIFO_FILE2, 0666);
fpout = fopen (FIFO_FILE2, "w");
}
if (NULL == fpout)
{
FPRINTF (stderr, "fopen of write FIFO_FILE2 failed: %s\n", STRERROR (errno));
goto end;
}
}
else
{
first = 0;
if (NULL == (fpout = fopen (FIFO_FILE1, "w")))
{
erg = mkfifo (FIFO_FILE1, 0666);
fpout = fopen (FIFO_FILE1, "w");
}
if (NULL == fpout)
{
FPRINTF (stderr, "fopen of write FIFO_FILE1 failed: %s\n", STRERROR (errno));
goto end;
}
fpin = fopen (FIFO_FILE2, "r");
if (NULL == fpin)
{
FPRINTF (stderr, "fopen of read FIFO_FILE2 failed: %s\n", STRERROR (errno));
goto end;
}
}
fdpin = fileno (fpin);
GNUNET_assert (fpin >= 0);
if (fdpin >= FD_SETSIZE)
{
FPRINTF (stderr, "File fdpin number too large (%d > %u)\n", fdpin,
(unsigned int) FD_SETSIZE);
goto end;
}
fdpout = fileno (fpout);
GNUNET_assert (fdpout >= 0);
if (fdpout >= FD_SETSIZE)
{
FPRINTF (stderr, "File fdpout number too large (%d > %u)\n", fdpout,
(unsigned int) FD_SETSIZE);
goto end;
}
signal (SIGINT, &sigfunc);
signal (SIGTERM, &sigfunc);
write_std.size = 0;
write_std.pos = 0;
write_pout.size = 0;
write_pout.pos = 0;
stdin_mst = GNUNET_SERVER_mst_create (&stdin_send, &write_pout);
file_in_mst = GNUNET_SERVER_mst_create (&file_in_send, &write_std);
/* Send 'random' mac address */
macaddr.mac[0] = 0x13;
macaddr.mac[1] = 0x22;
macaddr.mac[2] = 0x33;
macaddr.mac[3] = 0x44;
macaddr.mac[4] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 256);
macaddr.mac[5] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, 256);
write_std.size = send_mac_to_plugin (write_std.buf, &macaddr);
while (0 == closeprog)
{
maxfd = -1;
tv.tv_sec = 5;
tv.tv_usec = 0;
FD_ZERO (&rfds);
FD_ZERO (&wfds);
/* if output queue is empty, read */
if (0 == write_pout.size)
{
FD_SET (STDIN_FILENO, &rfds);
maxfd = MAX (STDIN_FILENO, maxfd);
}
if (0 == write_std.size)
{
FD_SET (fdpin, &rfds);
maxfd = MAX (fdpin, maxfd);
}
/* if there is something to write, try to write */
if (0 < write_std.size)
{
FD_SET (STDOUT_FILENO, &wfds);
maxfd = MAX (maxfd, STDOUT_FILENO);
}
if (0 < write_pout.size)
{
FD_SET (fdpout, &wfds);
maxfd = MAX (maxfd, fdpout);
}
retval = select (maxfd + 1, &rfds, &wfds, NULL, &tv);
if ((-1 == retval) && (EINTR == errno))
continue;
if (0 > retval)
{
FPRINTF (stderr, "select failed: %s\n", STRERROR (errno));
closeprog = 1;
break;
}
if (FD_ISSET (STDOUT_FILENO, &wfds))
{
ret =
write (STDOUT_FILENO, write_std.buf + write_std.pos,
write_std.size - write_std.pos);
if (0 > ret)
{
closeprog = 1;
FPRINTF (stderr, "Write ERROR to STDOUT_FILENO: %s\n",
STRERROR (errno));
break;
}
else
{
write_std.pos += ret;
/* check if finished writing */
if (write_std.pos == write_std.size)
{
write_std.pos = 0;
write_std.size = 0;
}
}
}
if (FD_ISSET (fdpout, &wfds))
{
ret =
write (fdpout, write_pout.buf + write_pout.pos,
write_pout.size - write_pout.pos);
if (0 > ret)
{
closeprog = 1;
FPRINTF (stderr, "Write ERROR to fdpout failed: %s\n", STRERROR (errno));
}
else
{
write_pout.pos += ret;
/* check if finished writing */
if (write_pout.pos == write_pout.size)
{
write_pout.pos = 0;
write_pout.size = 0;
}
}
}
if (FD_ISSET (STDIN_FILENO, &rfds))
{
readsize = read (STDIN_FILENO, readbuf, sizeof (readbuf));
if (0 > readsize)
{
closeprog = 1;
FPRINTF (stderr, "Error reading from STDIN_FILENO: %s\n",
STRERROR (errno));
}
else if (0 < readsize)
{
GNUNET_SERVER_mst_receive (stdin_mst, NULL, readbuf, readsize,
GNUNET_NO, GNUNET_NO);
}
else
{
/* eof */
closeprog = 1;
}
}
if (FD_ISSET (fdpin, &rfds))
{
readsize = read (fdpin, readbuf, sizeof (readbuf));
if (0 > readsize)
{
closeprog = 1;
FPRINTF (stderr, "Error reading from fdpin: %s\n", STRERROR (errno));
break;
}
else if (0 < readsize)
{
GNUNET_SERVER_mst_receive (file_in_mst, NULL, readbuf, readsize,
GNUNET_NO, GNUNET_NO);
}
else
{
/* eof */
closeprog = 1;
}
}
}
end:
/* clean up */
if (NULL != stdin_mst)
GNUNET_SERVER_mst_destroy (stdin_mst);
if (NULL != file_in_mst)
GNUNET_SERVER_mst_destroy (file_in_mst);
if (NULL != fpout)
fclose (fpout);
if (NULL != fpin)
fclose (fpin);
if (1 == first)
{
(void) unlink (FIFO_FILE1);
(void) unlink (FIFO_FILE2);
}
return 0;
}
