struct GNUNET_BIO_ReadHandle *h;
fd = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_READ,
- GNUNET_DISK_PERM_NONE);
- h = GNUNET_malloc (sizeof(struct GNUNET_BIO_ReadHandle) + BIO_BUFFER_SIZE);
- h->buffer = (char*) &h[1];
+ GNUNET_DISK_PERM_NONE);
+ h = GNUNET_malloc (sizeof (struct GNUNET_BIO_ReadHandle) + BIO_BUFFER_SIZE);
+ h->buffer = (char *) &h[1];
h->size = BIO_BUFFER_SIZE;
h->fd = fd;
return h;
* @param emsg set to the error message
* @return GNUNET_OK on success, GNUNET_SYSERR otherwise
*/
-int GNUNET_BIO_read_close (struct GNUNET_BIO_ReadHandle *h,
- char **emsg)
+int
+GNUNET_BIO_read_close (struct GNUNET_BIO_ReadHandle *h, char **emsg)
{
*emsg = h->emsg;
GNUNET_DISK_file_close (h->fd);
* @param len the number of bytes to read
* @return GNUNET_OK on success, GNUNET_SYSERR on failure
*/
-int GNUNET_BIO_read (struct GNUNET_BIO_ReadHandle *h,
- const char *what,
- void *result,
- size_t len)
+int
+GNUNET_BIO_read (struct GNUNET_BIO_ReadHandle *h,
+ const char *what, void *result, size_t len)
{
char *dst = result;
size_t min;
pos += min;
}
if (pos == len)
- return GNUNET_OK; /* done! */
+ return GNUNET_OK; /* done! */
GNUNET_assert (h->have == h->pos);
/* fill buffer */
- ret = GNUNET_DISK_file_read (h->fd,
- h->buffer,
- h->size);
+ ret = GNUNET_DISK_file_read (h->fd, h->buffer, h->size);
if (ret == -1)
{
- GNUNET_asprintf (&h->emsg,
- _("Error reading `%s': %s"),
- what,
- STRERROR (errno));
- return GNUNET_SYSERR;
+ GNUNET_asprintf (&h->emsg,
+ _("Error reading `%s': %s"),
+ what, STRERROR (errno));
+ return GNUNET_SYSERR;
}
if (ret == 0)
- {
- GNUNET_asprintf (&h->emsg,
- _("Error reading `%s': %s"),
- what,
- _("End of file"));
- return GNUNET_SYSERR;
- }
+ {
+ GNUNET_asprintf (&h->emsg,
+ _("Error reading `%s': %s"),
+ what, _("End of file"));
+ return GNUNET_SYSERR;
+ }
h->pos = 0;
h->have = ret;
}
- while (pos < len); /* should always be true */
+ while (pos < len); /* should always be true */
return GNUNET_OK;
}
* @param maxLen maximum allowed length for the string
* @return GNUNET_OK on success, GNUNET_SYSERR on failure
*/
-int GNUNET_BIO_read_string (struct GNUNET_BIO_ReadHandle *h,
- const char *what,
- char **result,
- size_t maxLen)
+int
+GNUNET_BIO_read_string (struct GNUNET_BIO_ReadHandle *h,
+ const char *what, char **result, size_t maxLen)
{
char *buf;
uint32_t big;
if (big > maxLen)
{
GNUNET_asprintf (&h->emsg,
- _("String `%s' longer than allowed (%u > %u)"),
- what,
- big,
- maxLen);
+ _("String `%s' longer than allowed (%u > %u)"),
+ what, big, maxLen);
return GNUNET_SYSERR;
}
buf = GNUNET_malloc (big);
buf[--big] = '\0';
+ if (big == 0)
+ return GNUNET_OK;
if (GNUNET_OK != GNUNET_BIO_read (h, what, buf, big))
{
GNUNET_free (buf);
* @param result the buffer to store a pointer to the (allocated) metadata
* @return GNUNET_OK on success, GNUNET_SYSERR on failure
*/
-int GNUNET_BIO_read_meta_data (struct GNUNET_BIO_ReadHandle *h,
- const char *what,
- struct GNUNET_CONTAINER_MetaData **result)
+int
+GNUNET_BIO_read_meta_data (struct GNUNET_BIO_ReadHandle *h,
+ const char *what,
+ struct GNUNET_CONTAINER_MetaData **result)
{
uint32_t size;
char *buf;
struct GNUNET_CONTAINER_MetaData *meta;
- if (GNUNET_BIO_read_int32__ (h,
- what,
- (int32_t*) &size) != GNUNET_OK)
+ if (GNUNET_BIO_read_int32__ (h, what, (int32_t *) & size) != GNUNET_OK)
return GNUNET_SYSERR;
if (size > MAX_META_DATA)
{
GNUNET_asprintf (&h->emsg,
- _("Serialized metadata `%s' larger than allowed (%u > %u)"),
- what,
- size,
- MAX_META_DATA);
+ _
+ ("Serialized metadata `%s' larger than allowed (%u > %u)"),
+ what, size, MAX_META_DATA);
return GNUNET_SYSERR;
}
buf = GNUNET_malloc (size);
- if (GNUNET_OK !=
- GNUNET_BIO_read (h, what, buf, size))
+ if (GNUNET_OK != GNUNET_BIO_read (h, what, buf, size))
{
GNUNET_free (buf);
return GNUNET_SYSERR;
{
GNUNET_free (buf);
GNUNET_asprintf (&h->emsg,
- _("Metadata `%s' failed to deserialize"),
- what);
+ _("Metadata `%s' failed to deserialize"), what);
return GNUNET_SYSERR;
}
GNUNET_free (buf);
* @param what describes what is being read (for error message creation)
* @param i address of 32-bit integer to read
* @return GNUNET_OK on success, GNUNET_SYSERR on error
- */
-int GNUNET_BIO_read_int32__ (struct GNUNET_BIO_ReadHandle *h,
- const char *what,
- int32_t *i)
+ */
+int
+GNUNET_BIO_read_int32__ (struct GNUNET_BIO_ReadHandle *h,
+ const char *what, int32_t * i)
{
int32_t big;
- if (GNUNET_OK !=
- GNUNET_BIO_read (h,
- what,
- &big,
- sizeof (int32_t)))
+ if (GNUNET_OK != GNUNET_BIO_read (h, what, &big, sizeof (int32_t)))
return GNUNET_SYSERR;
*i = ntohl (big);
return GNUNET_OK;
* @param what describes what is being read (for error message creation)
* @param i address of 64-bit integer to read
* @return GNUNET_OK on success, GNUNET_SYSERR on error
- */
-int GNUNET_BIO_read_int64__ (struct GNUNET_BIO_ReadHandle *h,
- const char *what,
- int64_t *i)
+ */
+int
+GNUNET_BIO_read_int64__ (struct GNUNET_BIO_ReadHandle *h,
+ const char *what, int64_t * i)
{
int64_t big;
- if (GNUNET_OK !=
- GNUNET_BIO_read (h,
- what,
- &big,
- sizeof (int64_t)))
+ if (GNUNET_OK != GNUNET_BIO_read (h, what, &big, sizeof (int64_t)))
return GNUNET_SYSERR;
*i = GNUNET_ntohll (big);
return GNUNET_OK;
* @param fn file name to be opened
* @return IO handle on success, NULL on error
*/
-struct GNUNET_BIO_WriteHandle *GNUNET_BIO_write_open (const char *fn)
+struct GNUNET_BIO_WriteHandle *
+GNUNET_BIO_write_open (const char *fn)
{
struct GNUNET_DISK_FileHandle *fd;
struct GNUNET_BIO_WriteHandle *h;
- fd = GNUNET_DISK_file_open (fn,
- GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_TRUNCATE | GNUNET_DISK_OPEN_CREATE,
- GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
- h = GNUNET_malloc (sizeof(struct GNUNET_BIO_WriteHandle) + BIO_BUFFER_SIZE);
- h->buffer = (char*) &h[1];
+ fd = GNUNET_DISK_file_open (fn,
+ GNUNET_DISK_OPEN_WRITE |
+ GNUNET_DISK_OPEN_TRUNCATE |
+ GNUNET_DISK_OPEN_CREATE,
+ GNUNET_DISK_PERM_USER_READ |
+ GNUNET_DISK_PERM_USER_WRITE);
+ h =
+ GNUNET_malloc (sizeof (struct GNUNET_BIO_WriteHandle) + BIO_BUFFER_SIZE);
+ h->buffer = (char *) &h[1];
h->size = BIO_BUFFER_SIZE;
h->fd = fd;
* @param h file handle
* @return GNUNET_OK on success, GNUNET_SYSERR otherwise
*/
-int GNUNET_BIO_write_close (struct GNUNET_BIO_WriteHandle *h)
+int
+GNUNET_BIO_write_close (struct GNUNET_BIO_WriteHandle *h)
{
ssize_t wrt;
int ret;
{
wrt = GNUNET_DISK_file_write (h->fd, h->buffer, h->have);
if (wrt == h->have)
- ret = GNUNET_OK;
+ ret = GNUNET_OK;
else
- ret = GNUNET_SYSERR;
+ ret = GNUNET_SYSERR;
GNUNET_DISK_file_close (h->fd);
}
GNUNET_free (h);
* @param n number of bytes to write
* @return GNUNET_OK on success, GNUNET_SYSERR on error
*/
-int GNUNET_BIO_write (struct GNUNET_BIO_WriteHandle *h,
- const void *buffer,
- size_t n)
+int
+GNUNET_BIO_write (struct GNUNET_BIO_WriteHandle *h,
+ const void *buffer, size_t n)
{
const char *src = buffer;
size_t min;
pos += min;
h->have += min;
if (pos == n)
- return GNUNET_OK; /* done */
+ return GNUNET_OK; /* done */
GNUNET_assert (h->have == h->size);
ret = GNUNET_DISK_file_write (h->fd, h->buffer, h->size);
if (ret != h->size)
{
GNUNET_DISK_file_close (h->fd);
h->fd = NULL;
- return GNUNET_SYSERR; /* error */
+ return GNUNET_SYSERR; /* error */
}
h->have = 0;
}
- while (pos < n); /* should always be true */
+ while (pos < n); /* should always be true */
return GNUNET_OK;
}
* @param s string to write (can be NULL)
* @return GNUNET_OK on success, GNUNET_SYSERR on error
*/
-int GNUNET_BIO_write_string (struct GNUNET_BIO_WriteHandle *h,
- const char *s)
+int
+GNUNET_BIO_write_string (struct GNUNET_BIO_WriteHandle *h, const char *s)
{
uint32_t slen;
- slen = (uint32_t) ((s == NULL) ? 0 : strlen(s) + 1);
- if (GNUNET_OK !=
- GNUNET_BIO_write_int32 (h, slen))
+ slen = (uint32_t) ((s == NULL) ? 0 : strlen (s) + 1);
+ if (GNUNET_OK != GNUNET_BIO_write_int32 (h, slen))
return GNUNET_SYSERR;
if (0 != slen)
return GNUNET_BIO_write (h, s, slen - 1);
* @param m metadata to write
* @return GNUNET_OK on success, GNUNET_SYSERR on error
*/
-int GNUNET_BIO_write_meta_data (struct GNUNET_BIO_WriteHandle *h,
- const struct GNUNET_CONTAINER_MetaData *m)
+int
+GNUNET_BIO_write_meta_data (struct GNUNET_BIO_WriteHandle *h,
+ const struct GNUNET_CONTAINER_MetaData *m)
{
unsigned int size;
char *buf;
size = GNUNET_CONTAINER_meta_data_get_serialized_size (m,
- GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL
- |
- GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS);
+ GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL
+ |
+ GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS);
if (size > MAX_META_DATA)
size = MAX_META_DATA;
buf = GNUNET_malloc (size);
GNUNET_CONTAINER_meta_data_serialize (m,
- buf,
- size,
- GNUNET_CONTAINER_META_DATA_SERIALIZE_PART |
- GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS);
- if ( (GNUNET_OK !=
- GNUNET_BIO_write_int32 (h, size)) ||
- (GNUNET_OK !=
- GNUNET_BIO_write (h, buf, size)) )
+ buf,
+ size,
+ GNUNET_CONTAINER_META_DATA_SERIALIZE_PART
+ |
+ GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS);
+ if ((GNUNET_OK != GNUNET_BIO_write_int32 (h, size))
+ || (GNUNET_OK != GNUNET_BIO_write (h, buf, size)))
{
GNUNET_free (buf);
return GNUNET_SYSERR;
* @param h hande to open file
* @param i address of 32-bit integer to write
* @return GNUNET_OK on success, GNUNET_SYSERR on error
- */
-int GNUNET_BIO_write_int32 (struct GNUNET_BIO_WriteHandle *h,
- int32_t i)
+ */
+int
+GNUNET_BIO_write_int32 (struct GNUNET_BIO_WriteHandle *h, int32_t i)
{
int32_t big;
big = htonl (i);
* @param h hande to open file
* @param i address of 64-bit integer to write
* @return GNUNET_OK on success, GNUNET_SYSERR on error
- */
-int GNUNET_BIO_write_int64 (struct GNUNET_BIO_WriteHandle *h,
- int64_t i)
+ */
+int
+GNUNET_BIO_write_int64 (struct GNUNET_BIO_WriteHandle *h, int64_t i)
{
int64_t big;
big = GNUNET_htonll (i);
/**
* Handle for a transmission request.
*/
-struct GNUNET_CLIENT_TransmitHandle
+struct GNUNET_CLIENT_TransmitHandle
{
/**
* Connection state.
* Our configuration.
*/
struct GNUNET_CONFIGURATION_Handle *cfg;
-
+
/**
* Name of the service we interact with.
*/
static struct GNUNET_CONNECTION_Handle *
do_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const char *service_name,
- const struct GNUNET_CONFIGURATION_Handle *cfg)
+ const char *service_name,
+ const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct GNUNET_CONNECTION_Handle *sock;
char *hostname;
"HOSTNAME", &hostname)))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Could not determine valid hostname and port for service `%s' from configuration.\n"),
+ _
+ ("Could not determine valid hostname and port for service `%s' from configuration.\n"),
service_name);
return NULL;
}
GNUNET_free (hostname);
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("Need a non-empty hostname for service `%s'.\n"),
- service_name);
+ service_name);
return NULL;
}
sock = GNUNET_CONNECTION_create_from_connect (sched,
- cfg,
- hostname,
- port,
- GNUNET_SERVER_MAX_MESSAGE_SIZE);
+ cfg,
+ hostname,
+ port,
+ GNUNET_SERVER_MAX_MESSAGE_SIZE);
GNUNET_free (hostname);
return sock;
}
struct GNUNET_CLIENT_Connection *sock = cls;
if (sock->th != NULL)
- GNUNET_CLIENT_notify_transmit_ready_cancel (sock->th);
+ GNUNET_CLIENT_notify_transmit_ready_cancel (sock->th);
GNUNET_array_grow (sock->received_buf, sock->received_size, 0);
GNUNET_free (sock->service_name);
GNUNET_CONFIGURATION_destroy (sock->cfg);
sock->in_receive = GNUNET_SYSERR;
else
GNUNET_SCHEDULER_add_after (sock->sched,
- GNUNET_YES,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- &finish_cleanup, sock);
+ GNUNET_YES,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ &finish_cleanup, sock);
}
{
if ((conn->received_pos >= sizeof (struct GNUNET_MessageHeader)) &&
(conn->received_pos >=
- ntohs (((const struct GNUNET_MessageHeader *) conn->
- received_buf)->size)))
+ ntohs (((const struct GNUNET_MessageHeader *) conn->received_buf)->
+ size)))
conn->msg_complete = GNUNET_YES;
}
GNUNET_assert (conn->msg_complete == GNUNET_NO);
if (GNUNET_SYSERR == conn->in_receive)
GNUNET_SCHEDULER_add_after (conn->sched,
- GNUNET_YES,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- &finish_cleanup,
- conn);
+ GNUNET_YES,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ &finish_cleanup, conn);
conn->in_receive = GNUNET_NO;
if ((available == 0) || (conn->sock == NULL) || (errCode != 0))
{
{
struct GNUNET_CLIENT_Connection *sock = scls;
GNUNET_CLIENT_MessageHandler handler = sock->receiver_handler;
- const struct GNUNET_MessageHeader *cmsg = (const struct GNUNET_MessageHeader *) sock->received_buf;
+ const struct GNUNET_MessageHeader *cmsg =
+ (const struct GNUNET_MessageHeader *) sock->received_buf;
void *cls = sock->receiver_handler_cls;
uint16_t msize = ntohs (cmsg->size);
char mbuf[msize];
- struct GNUNET_MessageHeader *msg = (struct GNUNET_MessageHeader*) mbuf;
+ struct GNUNET_MessageHeader *msg = (struct GNUNET_MessageHeader *) mbuf;
if (GNUNET_SYSERR == sock->in_receive)
GNUNET_SCHEDULER_add_after (sock->sched,
- GNUNET_YES,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- &finish_cleanup,
- sock);
+ GNUNET_YES,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ &finish_cleanup, sock);
sock->in_receive = GNUNET_NO;
GNUNET_assert (GNUNET_YES == sock->msg_complete);
GNUNET_assert (sock->received_pos >= msize);
memcpy (msg, cmsg, msize);
memmove (sock->received_buf,
- &sock->received_buf[msize], sock->received_pos - msize);
+ &sock->received_buf[msize], sock->received_pos - msize);
sock->received_pos -= msize;
sock->msg_complete = GNUNET_NO;
- sock->receiver_handler = NULL;
+ sock->receiver_handler = NULL;
check_complete (sock);
if (handler != NULL)
handler (cls, msg);
sock->in_receive = GNUNET_YES;
if (GNUNET_YES == sock->msg_complete)
GNUNET_SCHEDULER_add_after (sock->sched,
- GNUNET_YES,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- &receive_task, sock);
+ GNUNET_YES,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ &receive_task, sock);
else
GNUNET_CONNECTION_receive (sock->sock,
- GNUNET_SERVER_MAX_MESSAGE_SIZE,
- timeout,
- &receive_helper, sock);
+ GNUNET_SERVER_MAX_MESSAGE_SIZE,
+ timeout, &receive_helper, sock);
}
if (size < sizeof (struct GNUNET_MessageHeader))
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Failed to transmit shutdown request to client.\n"));
- return 0; /* client disconnected */
+ _("Failed to transmit shutdown request to client.\n"));
+ return 0; /* client disconnected */
}
msg = (struct GNUNET_MessageHeader *) buf;
msg->type = htons (GNUNET_MESSAGE_TYPE_SHUTDOWN);
GNUNET_CLIENT_service_shutdown (struct GNUNET_CLIENT_Connection *sock)
{
GNUNET_CONNECTION_notify_transmit_ready (sock->sock,
- sizeof (struct GNUNET_MessageHeader),
- GNUNET_TIME_UNIT_FOREVER_REL,
- &write_shutdown, sock);
+ sizeof (struct
+ GNUNET_MessageHeader),
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ &write_shutdown, sock);
}
conn->test_cb_cls = task_cls;
if (NULL ==
GNUNET_CONNECTION_notify_transmit_ready (conn->sock,
- sizeof (struct
- GNUNET_MessageHeader),
- timeout, &write_test, NULL))
+ sizeof (struct
+ GNUNET_MessageHeader),
+ timeout, &write_test, NULL))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("Failure to transmit request to service `%s'\n"),
* @param buf where to write them
* @return number of bytes written to buf
*/
-static size_t
-client_notify (void *cls,
- size_t size,
- void *buf);
+static size_t client_notify (void *cls, size_t size, void *buf);
*/
static void
client_delayed_retry (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_CLIENT_TransmitHandle *th = cls;
th->task = GNUNET_SCHEDULER_NO_TASK;
th->th = GNUNET_CONNECTION_notify_transmit_ready (th->sock->sock,
- th->size,
- GNUNET_TIME_absolute_get_remaining (th->timeout),
- &client_notify,
- th);
+ th->size,
+ GNUNET_TIME_absolute_get_remaining
+ (th->timeout),
+ &client_notify, th);
if (th->th == NULL)
{
GNUNET_break (0);
th->notify (th->notify_cls, 0, NULL);
GNUNET_free (th);
- return;
+ return;
}
}
* @return number of bytes written to buf
*/
static size_t
-client_notify (void *cls,
- size_t size,
- void *buf)
+client_notify (void *cls, size_t size, void *buf)
{
struct GNUNET_CLIENT_TransmitHandle *th = cls;
size_t ret;
struct GNUNET_TIME_Relative delay;
-
+
th->th = NULL;
th->sock->th = NULL;
if (buf == NULL)
{
delay = GNUNET_TIME_absolute_get_remaining (th->timeout);
delay.value /= 2;
- if ( (GNUNET_YES != th->auto_retry) ||
- (0 == --th->attempts_left) ||
- (delay.value < 1) )
- {
- GNUNET_break (0 == th->notify (th->notify_cls,
- 0,
- NULL));
- GNUNET_free (th);
- return 0;
- }
+ if ((GNUNET_YES != th->auto_retry) ||
+ (0 == --th->attempts_left) || (delay.value < 1))
+ {
+ GNUNET_break (0 == th->notify (th->notify_cls, 0, NULL));
+ GNUNET_free (th);
+ return 0;
+ }
/* auto-retry */
GNUNET_CONNECTION_destroy (th->sock->sock);
- th->sock->sock = do_connect (th->sock->sched,
- th->sock->service_name,
- th->sock->cfg);
+ th->sock->sock = do_connect (th->sock->sched,
+ th->sock->service_name, th->sock->cfg);
GNUNET_assert (NULL != th->sock->sock);
delay = GNUNET_TIME_relative_min (delay, GNUNET_TIME_UNIT_SECONDS);
th->task = GNUNET_SCHEDULER_add_delayed (th->sock->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- delay,
- &client_delayed_retry,
- th);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ delay,
+ &client_delayed_retry, th);
th->sock->th = th;
return 0;
}
GNUNET_assert (size >= th->size);
- ret = th->notify (th->notify_cls,
- size,
- buf);
+ ret = th->notify (th->notify_cls, size, buf);
GNUNET_free (th);
return ret;
}
GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock,
size_t size,
struct GNUNET_TIME_Relative timeout,
- int auto_retry,
+ int auto_retry,
GNUNET_CONNECTION_TransmitReadyNotify
notify, void *notify_cls)
{
th->notify_cls = notify_cls;
th->attempts_left = MAX_ATTEMPTS;
th->th = GNUNET_CONNECTION_notify_transmit_ready (sock->sock,
- size,
- timeout,
- &client_notify,
- th);
+ size,
+ timeout,
+ &client_notify, th);
if (NULL == th->th)
{
GNUNET_break (0);
* @param th handle from the original request.
*/
void
-GNUNET_CLIENT_notify_transmit_ready_cancel (struct GNUNET_CLIENT_TransmitHandle *th)
+GNUNET_CLIENT_notify_transmit_ready_cancel (struct
+ GNUNET_CLIENT_TransmitHandle *th)
{
if (th->task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_break (NULL == th->th);
- GNUNET_SCHEDULER_cancel (th->sock->sched,
- th->task);
+ GNUNET_SCHEDULER_cancel (th->sock->sched, th->task);
}
else
{
* @return number of bytes written to buf
*/
static size_t
-transmit_for_response (void *cls,
- size_t size,
- void *buf)
+transmit_for_response (void *cls, size_t size, void *buf)
{
struct TARCtx *tc = cls;
uint16_t msize;
- msize = ntohs(tc->hdr->size);
+ msize = ntohs (tc->hdr->size);
if (NULL == buf)
{
tc->rn (tc->rn_cls, NULL);
GNUNET_assert (size >= msize);
memcpy (buf, tc->hdr, msize);
GNUNET_CLIENT_receive (tc->sock,
- tc->rn,
- tc->rn_cls,
- GNUNET_TIME_absolute_get_remaining (tc->timeout));
+ tc->rn,
+ tc->rn_cls,
+ GNUNET_TIME_absolute_get_remaining (tc->timeout));
GNUNET_free (tc);
return msize;
}
* is already pending
*/
int
-GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *sock,
- const struct GNUNET_MessageHeader *hdr,
- struct GNUNET_TIME_Relative timeout,
- int auto_retry,
- GNUNET_CLIENT_MessageHandler rn,
- void *rn_cls)
+GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection
+ *sock,
+ const struct GNUNET_MessageHeader
+ *hdr,
+ struct GNUNET_TIME_Relative timeout,
+ int auto_retry,
+ GNUNET_CLIENT_MessageHandler rn,
+ void *rn_cls)
{
struct TARCtx *tc;
uint16_t msize;
if (NULL != sock->th)
return GNUNET_SYSERR;
- msize = ntohs(hdr->size);
- tc = GNUNET_malloc(sizeof (struct TARCtx) + msize);
+ msize = ntohs (hdr->size);
+ tc = GNUNET_malloc (sizeof (struct TARCtx) + msize);
tc->sock = sock;
- tc->hdr = (const struct GNUNET_MessageHeader*) &tc[1];
+ tc->hdr = (const struct GNUNET_MessageHeader *) &tc[1];
memcpy (&tc[1], hdr, msize);
tc->timeout = GNUNET_TIME_relative_to_absolute (timeout);
tc->rn = rn;
tc->rn_cls = rn_cls;
if (NULL == GNUNET_CLIENT_notify_transmit_ready (sock,
- msize,
- timeout,
- auto_retry,
- &transmit_for_response,
- tc))
+ msize,
+ timeout,
+ auto_retry,
+ &transmit_for_response,
+ tc))
{
GNUNET_break (0);
GNUNET_free (tc);
{
/* As a security precaution, we generally do not allow very large
allocations using the default 'GNUNET_malloc' macro */
- GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename,
- linenumber);
+ GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
return GNUNET_xmalloc_unchecked_ (size, filename, linenumber);
}
* @return string form; will be overwritten by next call to GNUNET_h2s.
*/
const char *
-GNUNET_h2s (const GNUNET_HashCode *hc)
+GNUNET_h2s (const GNUNET_HashCode * hc)
{
static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
GNUNET_CRYPTO_hash_to_enc (hc, &ret);
* @return nicely formatted string for the address
* will be overwritten by next call to GNUNET_a2s.
*/
-const char *GNUNET_a2s (const struct sockaddr *addr,
- socklen_t addrlen)
+const char *
+GNUNET_a2s (const struct sockaddr *addr, socklen_t addrlen)
{
- static char buf[INET6_ADDRSTRLEN+8];
+ static char buf[INET6_ADDRSTRLEN + 8];
static char b2[6];
- const struct sockaddr_in * v4;
+ const struct sockaddr_in *v4;
const struct sockaddr_in6 *v6;
if (addr == NULL)
switch (addr->sa_family)
{
case AF_INET:
- v4 = (const struct sockaddr_in*)addr;
- inet_ntop(AF_INET, &v4->sin_addr, buf, INET_ADDRSTRLEN);
- if (0 == ntohs(v4->sin_port))
- return buf;
+ v4 = (const struct sockaddr_in *) addr;
+ inet_ntop (AF_INET, &v4->sin_addr, buf, INET_ADDRSTRLEN);
+ if (0 == ntohs (v4->sin_port))
+ return buf;
strcat (buf, ":");
- sprintf (b2, "%u", ntohs(v4->sin_port));
+ sprintf (b2, "%u", ntohs (v4->sin_port));
strcat (buf, b2);
return buf;
case AF_INET6:
- v6 = (const struct sockaddr_in6*)addr;
+ v6 = (const struct sockaddr_in6 *) addr;
buf[0] = '[';
- inet_ntop(AF_INET6, &v6->sin6_addr, &buf[1], INET6_ADDRSTRLEN);
- if (0 == ntohs(v6->sin6_port))
- return &buf[1];
+ inet_ntop (AF_INET6, &v6->sin6_addr, &buf[1], INET6_ADDRSTRLEN);
+ if (0 == ntohs (v6->sin6_port))
+ return &buf[1];
strcat (buf, "]:");
- sprintf (b2, "%u", ntohs(v6->sin6_port));
+ sprintf (b2, "%u", ntohs (v6->sin6_port));
strcat (buf, b2);
- return buf;
+ return buf;
default:
return _("invalid address");
}
/**
* Initializer
*/
-void __attribute__ ((constructor))
-GNUNET_util_cl_init()
+void __attribute__ ((constructor)) GNUNET_util_cl_init ()
{
GNUNET_stderr = stderr;
}
GNUNET_assert (0 == fclose (fp));
if (error != 0)
{
- cfg->dirty = GNUNET_SYSERR; /* last write failed */
+ cfg->dirty = GNUNET_SYSERR; /* last write failed */
return GNUNET_SYSERR;
}
- cfg->dirty = GNUNET_NO; /* last write succeeded */
+ cfg->dirty = GNUNET_NO; /* last write succeeded */
return GNUNET_OK;
}
* @param iter function to call on each option
* @param iter_cls closure for iter
*/
-void GNUNET_CONFIGURATION_iterate (const struct GNUNET_CONFIGURATION_Handle *cfg,
- GNUNET_CONFIGURATION_Iterator iter,
- void *iter_cls)
+void
+GNUNET_CONFIGURATION_iterate (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ GNUNET_CONFIGURATION_Iterator iter,
+ void *iter_cls)
{
struct ConfigSection *spos;
struct ConfigEntry *epos;
{
epos = spos->entries;
while (epos != NULL)
- {
- iter (iter_cls, spos->name, epos->key, epos->val);
- epos = epos->next;
- }
+ {
+ iter (iter_cls, spos->name, epos->key, epos->val);
+ epos = epos->next;
+ }
spos = spos->next;
}
}
*/
static void
copy_entry (void *cls,
- const char *section,
- const char *option,
- const char *value)
+ const char *section, const char *option, const char *value)
{
struct GNUNET_CONFIGURATION_Handle *dst = cls;
GNUNET_CONFIGURATION_set_value_string (dst, section, option, value);
* @return matching entry, NULL if not found
*/
static struct ConfigSection *
-findSection (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section)
+findSection (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ const char *section)
{
struct ConfigSection *pos;
* @return GNUNET_OK on success, GNUNET_SYSERR on error
*/
int
-GNUNET_CONFIGURATION_get_value_number (const struct GNUNET_CONFIGURATION_Handle
- *cfg, const char *section,
+GNUNET_CONFIGURATION_get_value_number (const struct
+ GNUNET_CONFIGURATION_Handle *cfg,
+ const char *section,
const char *option,
unsigned long long *number)
{
*/
int
GNUNET_CONFIGURATION_get_value_time (const struct GNUNET_CONFIGURATION_Handle
- *cfg, const char *section,
- const char *option,
- struct GNUNET_TIME_Relative *time)
+ *cfg, const char *section,
+ const char *option,
+ struct GNUNET_TIME_Relative *time)
{
unsigned long long num;
int ret;
- ret = GNUNET_CONFIGURATION_get_value_number (cfg,
- section,
- option,
- &num);
+ ret = GNUNET_CONFIGURATION_get_value_number (cfg, section, option, &num);
if (ret == GNUNET_OK)
time->value = (uint64_t) num;
return ret;
* @return GNUNET_OK on success, GNUNET_SYSERR on error
*/
int
-GNUNET_CONFIGURATION_get_value_string (const struct GNUNET_CONFIGURATION_Handle
- *cfg, const char *section,
+GNUNET_CONFIGURATION_get_value_string (const struct
+ GNUNET_CONFIGURATION_Handle *cfg,
+ const char *section,
const char *option, char **value)
{
struct ConfigEntry *e;
* @return GNUNET_OK on success, GNUNET_SYSERR on error
*/
int
-GNUNET_CONFIGURATION_get_value_choice (const struct GNUNET_CONFIGURATION_Handle
- *cfg, const char *section,
+GNUNET_CONFIGURATION_get_value_choice (const struct
+ GNUNET_CONFIGURATION_Handle *cfg,
+ const char *section,
const char *option,
const char **choices,
const char **value)
* @return GNUNET_YES if so, GNUNET_NO if not.
*/
int
-GNUNET_CONFIGURATION_have_value (const struct GNUNET_CONFIGURATION_Handle *cfg,
- const char *section, const char *option)
+GNUNET_CONFIGURATION_have_value (const struct GNUNET_CONFIGURATION_Handle
+ *cfg, const char *section,
+ const char *option)
{
struct ConfigEntry *e;
if ((NULL == (e = findEntry (cfg, section, option))) || (e->val == NULL))
* @return $-expanded string
*/
char *
-GNUNET_CONFIGURATION_expand_dollar (const struct GNUNET_CONFIGURATION_Handle *cfg,
- char *orig)
+GNUNET_CONFIGURATION_expand_dollar (const struct GNUNET_CONFIGURATION_Handle
+ *cfg, char *orig)
{
int i;
char *prefix;
* @return GNUNET_OK on success, GNUNET_SYSERR on error
*/
int
-GNUNET_CONFIGURATION_get_value_filename (const struct GNUNET_CONFIGURATION_Handle
- *cfg, const char *section,
+GNUNET_CONFIGURATION_get_value_filename (const struct
+ GNUNET_CONFIGURATION_Handle *cfg,
+ const char *section,
const char *option, char **value)
{
int ret;
* @return GNUNET_YES, GNUNET_NO or GNUNET_SYSERR
*/
int
-GNUNET_CONFIGURATION_get_value_yesno (const struct GNUNET_CONFIGURATION_Handle *cfg,
- const char *section, const char *option)
+GNUNET_CONFIGURATION_get_value_yesno (const struct GNUNET_CONFIGURATION_Handle
+ *cfg, const char *section,
+ const char *option)
{
static const char *yesno[] = { "YES", "NO", NULL };
const char *val;
GNUNET_CONFIGURATION_iterate_value_filenames (const struct
GNUNET_CONFIGURATION_Handle
*cfg, const char *section,
- const char *option,
+ const char *option,
GNUNET_FileNameCallback cb,
void *cb_cls)
{
* Possible functions to call after connect failed or succeeded.
*/
enum ConnectContinuations
- {
+{
/**
* Call nothing.
*/
- COCO_NONE = 0,
+ COCO_NONE = 0,
/**
* Call "receive_again".
*/
- COCO_RECEIVE_AGAIN = 1,
+ COCO_RECEIVE_AGAIN = 1,
/**
* Call "transmit_ready".
*/
- COCO_TRANSMIT_READY = 2,
+ COCO_TRANSMIT_READY = 2,
/**
* Call "destroy_continuation".
*/
- COCO_DESTROY_CONTINUATION = 4
- };
+ COCO_DESTROY_CONTINUATION = 4
+};
/**
* Transmission handle. There can only be one for each connection.
- */
+ */
struct GNUNET_CONNECTION_TransmitHandle
{
/**
* Configuration to use.
- */
+ */
const struct GNUNET_CONFIGURATION_Handle *cfg;
/**
* Timeout for receiving (in absolute time).
*/
struct GNUNET_TIME_Absolute receive_timeout;
-
+
/**
* Functions to call after connect failed or succeeded.
*/
enum ConnectContinuations ccs;
-
+
/**
* Maximum number of bytes to read (for receiving).
*/
*/
struct GNUNET_CONNECTION_Handle *
GNUNET_CONNECTION_create_from_existing (struct GNUNET_SCHEDULER_Handle
- *sched, struct GNUNET_NETWORK_Handle *osSocket,
- size_t maxbuf)
+ *sched,
+ struct GNUNET_NETWORK_Handle
+ *osSocket, size_t maxbuf)
{
struct GNUNET_CONNECTION_Handle *ret;
ret = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle) + maxbuf);
*/
struct GNUNET_CONNECTION_Handle *
GNUNET_CONNECTION_create_from_accept (struct GNUNET_SCHEDULER_Handle
- *sched,
- GNUNET_CONNECTION_AccessCheck access,
- void *access_cls, struct GNUNET_NETWORK_Handle *lsock,
- size_t maxbuf)
+ *sched,
+ GNUNET_CONNECTION_AccessCheck access,
+ void *access_cls,
+ struct GNUNET_NETWORK_Handle *lsock,
+ size_t maxbuf)
{
struct GNUNET_CONNECTION_Handle *ret;
char addr[32];
void *uaddr;
addrlen = sizeof (addr);
- sock = GNUNET_NETWORK_socket_accept (lsock, (struct sockaddr *) &addr, &addrlen);
+ sock =
+ GNUNET_NETWORK_socket_accept (lsock, (struct sockaddr *) &addr, &addrlen);
if (NULL == sock)
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "accept");
(GNUNET_YES != (aret = access (access_cls, uaddr, addrlen))))
{
if (aret == GNUNET_NO)
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Access denied to `%s'\n"),
- GNUNET_a2s(uaddr, addrlen));
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_shutdown (sock, SHUT_RDWR));
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ _("Access denied to `%s'\n"),
+ GNUNET_a2s (uaddr, addrlen));
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_shutdown (sock, SHUT_RDWR));
GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
GNUNET_free (uaddr);
return NULL;
ret->sched = sched;
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Accepting connection from `%s': %p\n"),
- GNUNET_a2s(uaddr, addrlen),
- ret);
+ _("Accepting connection from `%s': %p\n"),
+ GNUNET_a2s (uaddr, addrlen), ret);
#endif
return ret;
}
*/
int
GNUNET_CONNECTION_get_address (struct GNUNET_CONNECTION_Handle *sock,
- void **addr, size_t * addrlen)
+ void **addr, size_t * addrlen)
{
if ((sock->addr == NULL) || (sock->addrlen == 0))
return GNUNET_NO;
*/
static void
retry_connect_continuation (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc);
+ const struct GNUNET_SCHEDULER_TaskContext *tc);
/**
if (0 != (sock->ccs & COCO_TRANSMIT_READY))
{
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Destroy waits for CCS-TR to be done (%p)\n",
- sock);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Destroy waits for CCS-TR to be done (%p)\n", sock);
#endif
sock->ccs |= COCO_DESTROY_CONTINUATION;
return;
if (sock->write_task != GNUNET_SCHEDULER_NO_TASK)
{
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Destroy waits for write_task to be done (%p)\n",
- sock);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Destroy waits for write_task to be done (%p)\n", sock);
#endif
GNUNET_SCHEDULER_add_after (sock->sched,
GNUNET_YES,
if (sock->sock != NULL)
{
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Shutting down socket (%p)\n",
- sock);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Shutting down socket (%p)\n", sock);
#endif
GNUNET_NETWORK_socket_shutdown (sock->sock, SHUT_RDWR);
}
return;
}
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Destroy actually runs (%p)!\n",
- sock);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Destroy actually runs (%p)!\n", sock);
#endif
GNUNET_assert (sock->nth.timeout_task == GNUNET_SCHEDULER_NO_TASK);
GNUNET_assert (sock->ccs == COCO_NONE);
GNUNET_free_non_null (sock->hostname);
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Freeing memory of connection %p.\n",
- sock);
+ "Freeing memory of connection %p.\n", sock);
#endif
GNUNET_free (sock);
}
{
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Failed to establish TCP connection to `%s:%u', no further addresses to try (%p).\n",
- h->hostname,
- h->port,
- h);
+ "Failed to establish TCP connection to `%s:%u', no further addresses to try (%p).\n",
+ h->hostname, h->port, h);
#endif
/* connect failed / timed out */
GNUNET_break (h->ap_head == NULL);
if (0 != (h->ccs & COCO_RECEIVE_AGAIN))
{
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "connect_timeout_continuation triggers receive_again (%p)\n",
- h);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "connect_timeout_continuation triggers receive_again (%p)\n",
+ h);
#endif
h->ccs -= COCO_RECEIVE_AGAIN;
h->read_task = GNUNET_SCHEDULER_add_after (h->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- &receive_again,
- h);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ &receive_again, h);
}
if (0 != (h->ccs & COCO_TRANSMIT_READY))
{
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "connect_timeout_continuation cancels timeout_task, triggers transmit_ready (%p)\n",
- h);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "connect_timeout_continuation cancels timeout_task, triggers transmit_ready (%p)\n",
+ h);
#endif
- GNUNET_assert (h->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK);
+ GNUNET_assert (h->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK);
GNUNET_SCHEDULER_cancel (h->sched, h->nth.timeout_task);
h->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
h->ccs -= COCO_TRANSMIT_READY;
h->write_task = GNUNET_SCHEDULER_add_after (h->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- &transmit_ready,
- h);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ &transmit_ready, h);
}
if (0 != (h->ccs & COCO_DESTROY_CONTINUATION))
{
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "connect_timeout_continuation runs destroy_continuation (%p)\n",
- h);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "connect_timeout_continuation runs destroy_continuation (%p)\n",
+ h);
#endif
h->ccs -= COCO_DESTROY_CONTINUATION;
GNUNET_SCHEDULER_add_continuation (h->sched,
- GNUNET_NO,
- &destroy_continuation,
- h,
- GNUNET_SCHEDULER_REASON_TIMEOUT);
+ GNUNET_NO,
+ &destroy_continuation,
+ h, GNUNET_SCHEDULER_REASON_TIMEOUT);
}
}
{
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Connection to `%s' succeeded! (%p)\n",
- GNUNET_a2s(h->addr, h->addrlen),
- h);
+ "Connection to `%s' succeeded! (%p)\n",
+ GNUNET_a2s (h->addr, h->addrlen), h);
#endif
/* trigger jobs that waited for the connection */
if (0 != (h->ccs & COCO_RECEIVE_AGAIN))
{
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "connect_success_continuation runs receive_again (%p)\n",
- h);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "connect_success_continuation runs receive_again (%p)\n",
+ h);
#endif
h->ccs -= COCO_RECEIVE_AGAIN;
h->read_task = GNUNET_SCHEDULER_add_after (h->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- &receive_again,
- h);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ &receive_again, h);
}
if (0 != (h->ccs & COCO_TRANSMIT_READY))
{
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "connect_success_continuation runs transmit_ready, cancels timeout_task (%p)\n",
- h);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "connect_success_continuation runs transmit_ready, cancels timeout_task (%p)\n",
+ h);
#endif
- GNUNET_assert (h->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK);
+ GNUNET_assert (h->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK);
GNUNET_SCHEDULER_cancel (h->sched, h->nth.timeout_task);
h->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
h->ccs -= COCO_TRANSMIT_READY;
h->write_task =
- GNUNET_SCHEDULER_add_write_net (h->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_absolute_get_remaining (h->nth.transmit_timeout),
- h->sock, &transmit_ready, h);
+ GNUNET_SCHEDULER_add_write_net (h->sched,
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_absolute_get_remaining
+ (h->nth.transmit_timeout), h->sock,
+ &transmit_ready, h);
}
if (0 != (h->ccs & COCO_DESTROY_CONTINUATION))
{
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "connect_success_continuation runs destroy_continuation (%p)\n",
- h);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "connect_success_continuation runs destroy_continuation (%p)\n",
+ h);
#endif
h->ccs -= COCO_DESTROY_CONTINUATION;
GNUNET_SCHEDULER_add_continuation (h->sched,
- GNUNET_NO,
- &destroy_continuation,
- h,
- GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+ GNUNET_NO,
+ &destroy_continuation,
+ h,
+ GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
}
*/
static void
connect_probe_continuation (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct AddressProbe *ap = cls;
struct GNUNET_CONNECTION_Handle *h = ap->h;
len = sizeof (error);
errno = 0;
error = 0;
- if ( (0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
- (GNUNET_OK != GNUNET_NETWORK_socket_getsockopt (ap->sock, SOL_SOCKET, SO_ERROR, &error, &len)) ||
- (error != 0) || (errno != 0) )
+ if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
+ (GNUNET_OK !=
+ GNUNET_NETWORK_socket_getsockopt (ap->sock, SOL_SOCKET, SO_ERROR,
+ &error, &len)) || (error != 0)
+ || (errno != 0))
{
GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ap->sock));
GNUNET_free (ap);
- if ( (NULL == h->ap_head) &&
- (h->dns_active == GNUNET_NO) )
- connect_fail_continuation (h);
+ if ((NULL == h->ap_head) && (h->dns_active == GNUNET_NO))
+ connect_fail_continuation (h);
return;
}
h->sock = ap->sock;
*/
static void
try_connect_using_address (void *cls,
- const struct sockaddr * addr,
- socklen_t addrlen)
+ const struct sockaddr *addr, socklen_t addrlen)
{
struct GNUNET_CONNECTION_Handle *h = cls;
struct AddressProbe *ap;
struct GNUNET_TIME_Relative delay;
-
+
if (addr == NULL)
{
if (h->dns_active == GNUNET_SYSERR)
- {
- h->dns_active = GNUNET_NO;
- GNUNET_SCHEDULER_add_after (h->sched,
- GNUNET_YES,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- h->read_task,
- &destroy_continuation,
- h);
- return;
- }
+ {
+ h->dns_active = GNUNET_NO;
+ GNUNET_SCHEDULER_add_after (h->sched,
+ GNUNET_YES,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ h->read_task, &destroy_continuation, h);
+ return;
+ }
h->dns_active = GNUNET_NO;
if (NULL == h->ap_head)
- connect_fail_continuation (h);
+ connect_fail_continuation (h);
return;
}
if (h->sock != NULL)
- return; /* already connected */
+ return; /* already connected */
if (h->dns_active == GNUNET_SYSERR)
{
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Connection %p has already been destroyed.\n",
- h);
+ "Connection %p has already been destroyed.\n", h);
#endif
- return; /* already destroyed */
+ return; /* already destroyed */
}
/* try to connect */
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Trying to connect using address `%s:%u/%s:%u'\n",
- h->hostname,
- h->port,
- GNUNET_a2s (addr, addrlen),
- h->port);
+ "Trying to connect using address `%s:%u/%s:%u'\n",
+ h->hostname, h->port, GNUNET_a2s (addr, addrlen), h->port);
#endif
ap = GNUNET_malloc (sizeof (struct AddressProbe) + addrlen);
- ap->addr = (const struct sockaddr*) &ap[1];
+ ap->addr = (const struct sockaddr *) &ap[1];
memcpy (&ap[1], addr, addrlen);
- ap->addrlen = addrlen;
+ ap->addrlen = addrlen;
ap->h = h;
switch (ap->addr->sa_family)
default:
GNUNET_break (0);
GNUNET_free (ap);
- return; /* not supported by us */
+ return; /* not supported by us */
}
- ap->sock = GNUNET_NETWORK_socket_create (ap->addr->sa_family, SOCK_STREAM, 0);
+ ap->sock =
+ GNUNET_NETWORK_socket_create (ap->addr->sa_family, SOCK_STREAM, 0);
if (ap->sock == NULL)
{
GNUNET_free (ap);
- return; /* not supported by OS */
+ return; /* not supported by OS */
}
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Trying to connect to `%s' (%p)\n"),
- GNUNET_a2s(ap->addr,
- ap->addrlen),
- h);
+ _("Trying to connect to `%s' (%p)\n"),
+ GNUNET_a2s (ap->addr, ap->addrlen), h);
#endif
- if ( (GNUNET_OK != GNUNET_NETWORK_socket_connect (ap->sock,
- ap->addr,
- ap->addrlen)) &&
- (errno != EINPROGRESS))
+ if ((GNUNET_OK != GNUNET_NETWORK_socket_connect (ap->sock,
+ ap->addr,
+ ap->addrlen)) &&
+ (errno != EINPROGRESS))
{
/* maybe refused / unsupported address, try next */
GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "connect");
delay = GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT;
if (h->nth.notify_ready != NULL)
delay = GNUNET_TIME_relative_min (delay,
- GNUNET_TIME_absolute_get_remaining (h->nth.transmit_timeout));
+ GNUNET_TIME_absolute_get_remaining (h->
+ nth.
+ transmit_timeout));
if (h->receiver != NULL)
delay = GNUNET_TIME_relative_min (delay,
- GNUNET_TIME_absolute_get_remaining (h->receive_timeout));
- ap->task = GNUNET_SCHEDULER_add_write_net (h->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- delay,
- ap->sock,
- &connect_probe_continuation,
- ap);
+ GNUNET_TIME_absolute_get_remaining (h->
+ receive_timeout));
+ ap->task =
+ GNUNET_SCHEDULER_add_write_net (h->sched, GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK, delay, ap->sock,
+ &connect_probe_continuation, ap);
}
*/
static void
retry_connect_continuation (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_CONNECTION_Handle *sock = cls;
sock->dns_active = GNUNET_YES;
GNUNET_RESOLVER_ip_get (sock->sched,
- sock->cfg,
- sock->hostname,
- AF_UNSPEC,
- GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT,
- &try_connect_using_address,
- sock);
+ sock->cfg,
+ sock->hostname,
+ AF_UNSPEC,
+ GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT,
+ &try_connect_using_address, sock);
}
* @return the socket handle
*/
struct GNUNET_CONNECTION_Handle *
-GNUNET_CONNECTION_create_from_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- const char *hostname,
- uint16_t port, size_t maxbuf)
+GNUNET_CONNECTION_create_from_connect (struct GNUNET_SCHEDULER_Handle *sched,
+ const struct
+ GNUNET_CONFIGURATION_Handle *cfg,
+ const char *hostname, uint16_t port,
+ size_t maxbuf)
{
struct GNUNET_CONNECTION_Handle *ret;
- GNUNET_assert (0 < strlen (hostname)); /* sanity check */
+ GNUNET_assert (0 < strlen (hostname)); /* sanity check */
ret = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle) + maxbuf);
ret->cfg = cfg;
ret->sched = sched;
*/
struct GNUNET_CONNECTION_Handle *
GNUNET_CONNECTION_create_from_sockaddr (struct GNUNET_SCHEDULER_Handle
- *sched, int af_family,
- const struct sockaddr *serv_addr,
- socklen_t addrlen, size_t maxbuf)
+ *sched, int af_family,
+ const struct sockaddr *serv_addr,
+ socklen_t addrlen, size_t maxbuf)
{
struct GNUNET_NETWORK_Handle *s;
struct GNUNET_CONNECTION_Handle *ret;
GNUNET_ERROR_TYPE_BULK, "socket");
return NULL;
}
- if ((GNUNET_OK != GNUNET_NETWORK_socket_connect (s, serv_addr, addrlen)) && (errno != EINPROGRESS))
+ if ((GNUNET_OK != GNUNET_NETWORK_socket_connect (s, serv_addr, addrlen))
+ && (errno != EINPROGRESS))
{
/* maybe refused / unsupported address, try next */
GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "connect");
ret->addrlen = addrlen;
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Trying to connect to `%s' (%p)\n"),
- GNUNET_a2s(serv_addr, addrlen),
- ret);
+ _("Trying to connect to `%s' (%p)\n"),
+ GNUNET_a2s (serv_addr, addrlen), ret);
#endif
return ret;
}
int
GNUNET_CONNECTION_check (struct GNUNET_CONNECTION_Handle *sock)
{
- if ( (sock->ap_head != NULL) ||
- (sock->dns_active == GNUNET_YES) )
+ if ((sock->ap_head != NULL) || (sock->dns_active == GNUNET_YES))
return GNUNET_YES; /* still trying to connect */
return (sock->sock == NULL) ? GNUNET_NO : GNUNET_YES;
}
void
GNUNET_CONNECTION_destroy (struct GNUNET_CONNECTION_Handle *sock)
{
- if ( (sock->write_buffer_off == 0) &&
- (sock->dns_active == GNUNET_YES) )
+ if ((sock->write_buffer_off == 0) && (sock->dns_active == GNUNET_YES))
{
- sock->dns_active = GNUNET_SYSERR; /* if we're still trying to connect and have
- no message pending, stop trying! */
+ sock->dns_active = GNUNET_SYSERR; /* if we're still trying to connect and have
+ no message pending, stop trying! */
return;
}
GNUNET_assert (sock->sched != NULL);
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Network signals time out to receiver (%p)!\n",
- sh);
+ "Network signals time out to receiver (%p)!\n", sh);
#endif
GNUNET_assert (NULL != (receiver = sh->receiver));
sh->receiver = NULL;
sh->read_task = GNUNET_SCHEDULER_NO_TASK;
now = GNUNET_TIME_absolute_get ();
- if ( (now.value > sh->receive_timeout.value) ||
- (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) ||
- (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) )
+ if ((now.value > sh->receive_timeout.value) ||
+ (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) ||
+ (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)))
{
#if DEBUG_CONNECTION
if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Receive from `%s' encounters error: time out by %llums... (%p)\n",
- GNUNET_a2s (sh->addr, sh->addrlen),
- GNUNET_TIME_absolute_get_duration (sh->receive_timeout).value,
- sh);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Receive from `%s' encounters error: time out by %llums... (%p)\n",
+ GNUNET_a2s (sh->addr, sh->addrlen),
+ GNUNET_TIME_absolute_get_duration (sh->receive_timeout).
+ value, sh);
#endif
signal_timeout (sh);
return;
/* connect failed for good */
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Receive encounters error, socket closed... (%p)\n",
- sh);
+ "Receive encounters error, socket closed... (%p)\n", sh);
#endif
signal_error (sh, ECONNREFUSED);
return;
goto RETRY;
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Error receiving: %s\n",
- STRERROR (errno));
+ "Error receiving: %s\n", STRERROR (errno));
#endif
signal_error (sh, errno);
return;
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"receive_ready read %u/%u bytes from `%s' (%p)!\n",
- (unsigned int) ret,
- sh->max,
- GNUNET_a2s(sh->addr, sh->addrlen),
- sh);
+ (unsigned int) ret,
+ sh->max, GNUNET_a2s (sh->addr, sh->addrlen), sh);
#endif
GNUNET_assert (NULL != (receiver = sh->receiver));
sh->receiver = NULL;
struct GNUNET_TIME_Absolute now;
sh->read_task = GNUNET_SCHEDULER_NO_TASK;
- if (sh->sock == NULL)
+ if (sh->sock == NULL)
{
/* not connected and no longer trying */
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Receive encounters error, socket closed (%p)...\n",
- sh);
+ "Receive encounters error, socket closed (%p)...\n", sh);
#endif
signal_error (sh, ECONNREFUSED);
return;
{
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Receive encounters error: time out (%p)...\n",
- sh);
+ "Receive encounters error: time out (%p)...\n", sh);
#endif
signal_timeout (sh);
return;
GNUNET_assert (sh->sock != NULL);
/* connect succeeded, wait for data! */
sh->read_task = GNUNET_SCHEDULER_add_read_net (tc->sched,
- GNUNET_YES,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_absolute_get_remaining
- (sh->receive_timeout),
- sh->sock,
- &receive_ready,
- sh);
+ GNUNET_YES,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_absolute_get_remaining
+ (sh->receive_timeout),
+ sh->sock,
+ &receive_ready, sh);
}
*/
void
GNUNET_CONNECTION_receive (struct GNUNET_CONNECTION_Handle *sock,
- size_t max,
- struct GNUNET_TIME_Relative timeout,
- GNUNET_CONNECTION_Receiver receiver, void *receiver_cls)
+ size_t max,
+ struct GNUNET_TIME_Relative timeout,
+ GNUNET_CONNECTION_Receiver receiver,
+ void *receiver_cls)
{
struct GNUNET_SCHEDULER_TaskContext tc;
GNUNET_assert ((sock->read_task == GNUNET_SCHEDULER_NO_TASK) &&
- (0 == (sock->ccs & COCO_RECEIVE_AGAIN)) &&
+ (0 == (sock->ccs & COCO_RECEIVE_AGAIN)) &&
(sock->receiver == NULL));
sock->receiver = receiver;
sock->receiver_cls = receiver_cls;
receive_again (sock, &tc);
return;
}
- if ( (sock->dns_active != GNUNET_YES) &&
- (sock->ap_head == NULL) )
+ if ((sock->dns_active != GNUNET_YES) && (sock->ap_head == NULL))
{
receiver (receiver_cls, NULL, 0, NULL, 0, ETIMEDOUT);
return;
{
if (sock->read_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_assert (sock == GNUNET_SCHEDULER_cancel (sock->sched,
- sock->read_task));
+ GNUNET_assert (sock == GNUNET_SCHEDULER_cancel (sock->sched,
+ sock->read_task));
sock->read_task = GNUNET_SCHEDULER_NO_TASK;
}
else
- {
+ {
GNUNET_assert (0 != (sock->ccs & COCO_RECEIVE_AGAIN));
sock->ccs -= COCO_RECEIVE_AGAIN;
}
* This task notifies the client about the timeout.
*/
static void
-transmit_timeout (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+transmit_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_CONNECTION_Handle *sock = cls;
GNUNET_CONNECTION_TransmitReadyNotify notify;
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "transmit_timeout running (%p)\n",
- sock);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "transmit_timeout running (%p)\n", sock);
#endif
sock->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Transmit to `%s:%u/%s' fails, time out reached (%p).\n",
- sock->hostname,
- sock->port,
- GNUNET_a2s (sock->addr, sock->addrlen),
- sock);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Transmit to `%s:%u/%s' fails, time out reached (%p).\n",
+ sock->hostname,
+ sock->port, GNUNET_a2s (sock->addr, sock->addrlen), sock);
#endif
GNUNET_assert (0 != (sock->ccs & COCO_TRANSMIT_READY));
- sock->ccs -= COCO_TRANSMIT_READY; /* remove request */
+ sock->ccs -= COCO_TRANSMIT_READY; /* remove request */
notify = sock->nth.notify_ready;
sock->nth.notify_ready = NULL;
notify (sock->nth.notify_ready_cls, 0, NULL);
* This task notifies the client about the error.
*/
static void
-connect_error (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+connect_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_CONNECTION_Handle *sock = cls;
GNUNET_CONNECTION_TransmitReadyNotify notify;
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Transmission request of size %u fails, connection failed (%p).\n",
- sock->nth.notify_size,
- sock);
+ "Transmission request of size %u fails, connection failed (%p).\n",
+ sock->nth.notify_size, sock);
#endif
sock->write_task = GNUNET_SCHEDULER_NO_TASK;
notify = sock->nth.notify_ready;
size_t have;
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "transmit_ready running (%p).\n",
- sock);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "transmit_ready running (%p).\n", sock);
#endif
GNUNET_assert (sock->write_task != GNUNET_SCHEDULER_NO_TASK);
sock->write_task = GNUNET_SCHEDULER_NO_TASK;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
{
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Transmit to `%s' fails, time out reached (%p).\n",
- GNUNET_a2s (sock->addr, sock->addrlen),
- sock);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Transmit to `%s' fails, time out reached (%p).\n",
+ GNUNET_a2s (sock->addr, sock->addrlen), sock);
#endif
notify = sock->nth.notify_ready;
sock->nth.notify_ready = NULL;
if (tc->write_ready == NULL)
{
/* special circumstances (in particular,
- PREREQ_DONE after connect): not yet ready to write,
- but no "fatal" error either. Hence retry. */
+ PREREQ_DONE after connect): not yet ready to write,
+ but no "fatal" error either. Hence retry. */
goto SCHEDULE_WRITE;
}
- if (! GNUNET_NETWORK_fdset_isset (tc->write_ready,
- sock->sock))
+ if (!GNUNET_NETWORK_fdset_isset (tc->write_ready, sock->sock))
{
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Could not satisfy pending transmission request, socket closed or connect failed (%p).\n"),
- sock);
+ _
+ ("Could not satisfy pending transmission request, socket closed or connect failed (%p).\n"),
+ sock);
#endif
if (NULL != sock->sock)
- {
- GNUNET_NETWORK_socket_shutdown (sock->sock, SHUT_RDWR);
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock->sock));
- sock->sock = NULL;
- }
+ {
+ GNUNET_NETWORK_socket_shutdown (sock->sock, SHUT_RDWR);
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (sock->sock));
+ sock->sock = NULL;
+ }
transmit_error (sock);
return; /* connect failed for good, we're finished */
}
have = sock->write_buffer_off - sock->write_buffer_pos;
if (have == 0)
{
- /* no data ready for writing, terminate write loop */
+ /* no data ready for writing, terminate write loop */
return;
}
RETRY:
ret = GNUNET_NETWORK_socket_send (sock->sock,
- &sock->write_buffer[sock->write_buffer_pos],
- have);
+ &sock->write_buffer[sock->
+ write_buffer_pos],
+ have);
if (ret == -1)
{
if (errno == EINTR)
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"transmit_ready transmitted %u/%u bytes to `%s' (%p)\n",
- (unsigned int) ret,
- have,
- GNUNET_a2s(sock->addr, sock->addrlen),
- sock);
+ (unsigned int) ret,
+ have, GNUNET_a2s (sock->addr, sock->addrlen), sock);
#endif
sock->write_buffer_pos += ret;
if (sock->write_buffer_pos == sock->write_buffer_off)
sock->write_buffer_pos = 0;
sock->write_buffer_off = 0;
}
- if ( (sock->write_buffer_off == 0) &&
- (NULL == sock->nth.notify_ready))
- return; /* all data sent! */
+ if ((sock->write_buffer_off == 0) && (NULL == sock->nth.notify_ready))
+ return; /* all data sent! */
/* not done writing, schedule more */
SCHEDULE_WRITE:
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Re-scheduling transmit_ready (more to do) (%p).\n",
- sock);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Re-scheduling transmit_ready (more to do) (%p).\n", sock);
#endif
if (sock->write_task == GNUNET_SCHEDULER_NO_TASK)
sock->write_task =
GNUNET_SCHEDULER_add_write_net (tc->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_absolute_get_remaining (sock->nth.transmit_timeout),
- sock->sock,
- &transmit_ready, sock);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_absolute_get_remaining
+ (sock->nth.transmit_timeout),
+ sock->sock, &transmit_ready, sock);
}
*/
struct GNUNET_CONNECTION_TransmitHandle *
GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle
- *sock, size_t size,
- struct GNUNET_TIME_Relative timeout,
- GNUNET_CONNECTION_TransmitReadyNotify
- notify, void *notify_cls)
+ *sock, size_t size,
+ struct GNUNET_TIME_Relative timeout,
+ GNUNET_CONNECTION_TransmitReadyNotify
+ notify, void *notify_cls)
{
if (sock->nth.notify_ready != NULL)
return NULL;
sock->nth.notify_size = size;
sock->nth.transmit_timeout = GNUNET_TIME_relative_to_absolute (timeout);
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->nth.timeout_task);
- if ( (sock->sock == NULL) &&
- (sock->ap_head == NULL) &&
- (sock->dns_active != GNUNET_YES) )
- {
+ if ((sock->sock == NULL) &&
+ (sock->ap_head == NULL) && (sock->dns_active != GNUNET_YES))
+ {
sock->write_task = GNUNET_SCHEDULER_add_delayed (sock->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_UNIT_ZERO,
- &connect_error,
- sock);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_UNIT_ZERO,
+ &connect_error, sock);
return &sock->nth;
}
if (GNUNET_SCHEDULER_NO_TASK != sock->write_task)
if (sock->sock != NULL)
{
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Scheduling transmit_ready (%p).\n",
- sock);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Scheduling transmit_ready (%p).\n", sock);
#endif
sock->write_task = GNUNET_SCHEDULER_add_write_net (sock->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_absolute_get_remaining (sock->nth.transmit_timeout),
- sock->sock,
- &transmit_ready, sock);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_absolute_get_remaining
+ (sock->nth.
+ transmit_timeout),
+ sock->sock,
+ &transmit_ready,
+ sock);
}
else
{
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "CCS-Scheduling transmit_ready, adding timeout task (%p).\n",
- sock);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "CCS-Scheduling transmit_ready, adding timeout task (%p).\n",
+ sock);
#endif
sock->ccs |= COCO_TRANSMIT_READY;
sock->nth.timeout_task = GNUNET_SCHEDULER_add_delayed (sock->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- timeout,
- &transmit_timeout,
- sock);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ timeout,
+ &transmit_timeout,
+ sock);
}
return &sock->nth;
}
*/
void
GNUNET_CONNECTION_notify_transmit_ready_cancel (struct
- GNUNET_CONNECTION_TransmitHandle *h)
+ GNUNET_CONNECTION_TransmitHandle
+ *h)
{
GNUNET_assert (h->notify_ready != NULL);
if (0 != (h->sh->ccs & COCO_TRANSMIT_READY))
{
#if DEBUG_CONNECTION
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "notify_transmit_ready_cancel cancels timeout_task (%p)\n",
- h);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "notify_transmit_ready_cancel cancels timeout_task (%p)\n",
+ h);
#endif
GNUNET_SCHEDULER_cancel (h->sh->sched, h->timeout_task);
h->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
else
{
- GNUNET_SCHEDULER_cancel (h->sh->sched,
- h->sh->write_task);
+ GNUNET_SCHEDULER_cancel (h->sh->sched, h->sh->write_task);
h->sh->write_task = GNUNET_SCHEDULER_NO_TASK;
}
h->notify_ready = NULL;
* @param fh A file to keep the 4 bit address usage counters in
*/
static void
-incrementBit (char *bitArray, unsigned int bitIdx, const struct GNUNET_DISK_FileHandle *fh)
+incrementBit (char *bitArray, unsigned int bitIdx,
+ const struct GNUNET_DISK_FileHandle *fh)
{
off_t fileSlot;
unsigned char value;
fileSlot = bitIdx / 2;
targetLoc = bitIdx % 2;
- GNUNET_assert (fileSlot ==
- GNUNET_DISK_file_seek (fh, fileSlot, GNUNET_DISK_SEEK_SET));
+ GNUNET_assert (fileSlot ==
+ GNUNET_DISK_file_seek (fh, fileSlot, GNUNET_DISK_SEEK_SET));
if (1 != GNUNET_DISK_file_read (fh, &value, 1))
value = 0;
low = value & 0xF;
high++;
}
value = ((high << 4) | low);
- GNUNET_assert (fileSlot == GNUNET_DISK_file_seek (fh,
- fileSlot,
- GNUNET_DISK_SEEK_SET));
+ GNUNET_assert (fileSlot == GNUNET_DISK_file_seek (fh,
+ fileSlot,
+ GNUNET_DISK_SEEK_SET));
GNUNET_assert (1 == GNUNET_DISK_file_write (fh, &value, 1));
}
* @param fh A file to keep the 4bit address usage counters in
*/
static void
-decrementBit (char *bitArray, unsigned int bitIdx, const struct GNUNET_DISK_FileHandle *fh)
+decrementBit (char *bitArray, unsigned int bitIdx,
+ const struct GNUNET_DISK_FileHandle *fh)
{
off_t fileSlot;
unsigned char value;
* @return GNUNET_OK if created ok, GNUNET_SYSERR otherwise
*/
static int
-makeEmptyFile (const struct GNUNET_DISK_FileHandle *fh,
- size_t size)
+makeEmptyFile (const struct GNUNET_DISK_FileHandle *fh, size_t size)
{
char *buffer;
size_t bytesleft = size;
* @param bit the current bit
*/
typedef void (*BitIterator) (void *cls,
- struct GNUNET_CONTAINER_BloomFilter * bf,
+ struct GNUNET_CONTAINER_BloomFilter * bf,
unsigned int bit);
/**
{
while (slot < (sizeof (GNUNET_HashCode) / sizeof (uint32_t)))
{
- callback (arg,
- bf,
- (((uint32_t *) &tmp[round & 1])[slot]) &
+ callback (arg,
+ bf,
+ (((uint32_t *) & tmp[round & 1])[slot]) &
((bf->bitArraySize * 8) - 1));
slot++;
bitCount--;
*/
static void
incrementBitCallback (void *cls,
- struct GNUNET_CONTAINER_BloomFilter *bf,
+ struct GNUNET_CONTAINER_BloomFilter *bf,
unsigned int bit)
{
incrementBit (bf->bitArray, bit, bf->fh);
*/
static void
decrementBitCallback (void *cls,
- struct GNUNET_CONTAINER_BloomFilter *bf,
+ struct GNUNET_CONTAINER_BloomFilter *bf,
unsigned int bit)
{
decrementBit (bf->bitArray, bit, bf->fh);
*/
static void
testBitCallback (void *cls,
- struct GNUNET_CONTAINER_BloomFilter *bf, unsigned int bit)
+ struct GNUNET_CONTAINER_BloomFilter *bf, unsigned int bit)
{
int *arg = cls;
if (GNUNET_NO == testBit (bf->bitArray, bit))
* @return the bloomfilter
*/
struct GNUNET_CONTAINER_BloomFilter *
-GNUNET_CONTAINER_bloomfilter_load (const char *filename,
- size_t size,
- unsigned int k)
+GNUNET_CONTAINER_bloomfilter_load (const char *filename,
+ size_t size, unsigned int k)
{
struct GNUNET_CONTAINER_BloomFilter *bf;
char *rbuff;
if (filename != NULL)
{
bf->fh = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READWRITE
- | GNUNET_DISK_OPEN_CREATE,
- GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+ | GNUNET_DISK_OPEN_CREATE,
+ GNUNET_DISK_PERM_USER_READ |
+ GNUNET_DISK_PERM_USER_WRITE);
if (NULL == bf->fh)
{
GNUNET_free (bf);
int res;
res = GNUNET_DISK_file_read (bf->fh, rbuff, BUFFSIZE);
- if (res == -1)
- {
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "read",
- bf->filename);
- }
+ if (res == -1)
+ {
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+ "read", bf->filename);
+ }
if (res == 0)
break; /* is ok! we just did not use that many bits yet */
for (i = 0; i < res; i++)
*/
struct GNUNET_CONTAINER_BloomFilter *
GNUNET_CONTAINER_bloomfilter_init (const char *data,
- size_t size,
- unsigned int k)
+ size_t size, unsigned int k)
{
struct GNUNET_CONTAINER_BloomFilter *bf;
size_t ui;
*/
int
GNUNET_CONTAINER_bloomfilter_get_raw_data (struct GNUNET_CONTAINER_BloomFilter
- *bf, char *data,
- size_t size)
+ *bf, char *data, size_t size)
{
if (NULL == bf)
return GNUNET_SYSERR;
*/
int
GNUNET_CONTAINER_bloomfilter_or (struct GNUNET_CONTAINER_BloomFilter *bf,
- const char *data,
- size_t size)
+ const char *data, size_t size)
{
unsigned int i;
void
GNUNET_CONTAINER_bloomfilter_resize (struct GNUNET_CONTAINER_BloomFilter *bf,
GNUNET_HashCodeIterator iterator,
- void *iterator_cls,
- size_t size,
- unsigned int k)
+ void *iterator_cls,
+ size_t size, unsigned int k)
{
GNUNET_HashCode hc;
unsigned int i;
* @param heap the heap
* @return NULL if the heap is empty
*/
-void *GNUNET_CONTAINER_heap_peek (struct GNUNET_CONTAINER_Heap *heap)
+void *
+GNUNET_CONTAINER_heap_peek (struct GNUNET_CONTAINER_Heap *heap)
{
if ((heap == NULL) || (heap->root == NULL))
return NULL;
}
static int
-next_power_of_2(int v)
+next_power_of_2 (int v)
{
v |= v >> 1;
v |= v >> 2;
GNUNET_CONTAINER_heap_destroy (struct GNUNET_CONTAINER_Heap *heap)
{
while (heap->size > 0)
- GNUNET_CONTAINER_heap_remove_root (heap);
+ GNUNET_CONTAINER_heap_remove_root (heap);
GNUNET_free (heap);
return;
}
else
{
parent = root->root;
- for (i = next_power_of_2(pos) >> 2; i > 1; i >>= 1)
+ for (i = next_power_of_2 (pos) >> 2; i > 1; i >>= 1)
{
if (((pos / i) % 2) == 0)
parent = parent->left_child;
else
{
ret = root->root;
- for (i = next_power_of_2(pos) >> 2; i > 0; i >>= 1)
+ for (i = next_power_of_2 (pos) >> 2; i > 0; i >>= 1)
{
if (((pos / i) % 2) == 0)
ret = ret->left_child;
{
if ((iter != NULL) &&
(GNUNET_OK != iter (iter_cls,
- md->items[i].type,
- md->items[i].data)))
+ md->items[i].type, md->items[i].data)))
return GNUNET_SYSERR;
}
else
hdr->version = htonl (md == NULL ? 1 : 0);
hdr->entries = htonl (ic);
for (i = 0; i < ic; i++)
- ((uint32_t *) &hdr[1])[i] =
- htonl ((uint32_t) md->items[i].type);
+ ((uint32_t *) & hdr[1])[i] = htonl ((uint32_t) md->items[i].type);
pos = sizeof (struct MetaDataHeader);
pos += sizeof (unsigned int) * ic;
for (i = 0; i < ic; i++)
*/
ssize_t
GNUNET_CONTAINER_meta_data_get_serialized_size (const struct
- GNUNET_CONTAINER_MetaData *md,
+ GNUNET_CONTAINER_MetaData *
+ md,
enum
GNUNET_CONTAINER_MetaDataSerializationOptions
opt)
hdr->version = htonl (md == NULL ? 1 : 0);
hdr->entries = htonl (ic);
for (i = 0; i < ic; i++)
- ((uint32_t *) &hdr[1])[i] = htonl ((uint32_t) md->items[i].type);
+ ((uint32_t *) & hdr[1])[i] = htonl ((uint32_t) md->items[i].type);
pos = sizeof (struct MetaDataHeader);
pos += sizeof (uint32_t) * ic;
for (i = 0; i < ic; i++)
e = map->map[i];
while (e != NULL)
{
- if ( (NULL != it) &&
- (GNUNET_OK != it (it_cls, &e->key, e->value)) )
+ if ((NULL != it) && (GNUNET_OK != it (it_cls, &e->key, e->value)))
return GNUNET_SYSERR;
count++;
e = e->next;
e = map->map[i];
while (e != NULL)
{
- if ( (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) &&
- (value == e->value))
+ if ((0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) &&
+ (value == e->value))
{
if (p == NULL)
map->map[i] = e->next;
while (NULL != (e = old_map[i]))
{
old_map[i] = e->next;
- idx = idx_of (map, &e->key);
+ idx = idx_of (map, &e->key);
e->next = new_map[idx];
new_map[idx] = e;
}
unsigned int i;
i = idx_of (map, key);
- if ( (opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE) &&
- (opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST) )
+ if ((opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE) &&
+ (opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
{
e = map->map[i];
while (e != NULL)
if (map->size / 3 >= map->map_length / 4)
{
grow (map);
- i = idx_of (map, key);
+ i = idx_of (map, key);
}
e = GNUNET_malloc (sizeof (struct MapEntry));
e->key = *key;
{
if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode)))
{
- if ( (it != NULL) &&
- (GNUNET_OK != it (it_cls, &e->key, e->value)) )
+ if ((it != NULL) && (GNUNET_OK != it (it_cls, &e->key, e->value)))
return GNUNET_SYSERR;
count++;
}
{
/**
* This is a linked list.
- */
+ */
struct GNUNET_CONTAINER_SList_Elem *next;
/**
* @return a new element
*/
static struct GNUNET_CONTAINER_SList_Elem *
-create_elem (enum GNUNET_CONTAINER_SListDisposition disp,
- const void *buf,
- size_t len)
+create_elem (enum GNUNET_CONTAINER_SListDisposition disp,
+ const void *buf, size_t len)
{
struct GNUNET_CONTAINER_SList_Elem *e;
{
e = GNUNET_malloc (sizeof (struct GNUNET_CONTAINER_SList_Elem) + len);
memcpy (&e[1], buf, len);
- e->elem = (void*) &e[1];
+ e->elem = (void *) &e[1];
}
else
{
e = GNUNET_malloc (sizeof (struct GNUNET_CONTAINER_SList_Elem));
- e->elem = (void*) buf;
+ e->elem = (void *) buf;
}
e->disp = disp;
e->len = len;
* @param len length of the buffer
*/
void
-GNUNET_CONTAINER_slist_add (struct GNUNET_CONTAINER_SList *l,
- enum GNUNET_CONTAINER_SListDisposition disp,
+GNUNET_CONTAINER_slist_add (struct GNUNET_CONTAINER_SList *l,
+ enum GNUNET_CONTAINER_SListDisposition disp,
const void *buf, size_t len)
{
struct GNUNET_CONTAINER_SList_Elem *e;
{
n = e->next;
if (e->disp == GNUNET_CONTAINER_SLIST_DISPOSITION_DYNAMIC)
- GNUNET_free (e->elem);
+ GNUNET_free (e->elem);
GNUNET_free (e);
e = n;
}
struct GNUNET_CONTAINER_SList_Elem *e;
for (e = l->head; e != NULL; e = e->next)
- if ( (e->len == len) &&
- (memcmp (buf, e->elem, len) == 0) )
+ if ((e->len == len) && (memcmp (buf, e->elem, len) == 0))
return GNUNET_YES;
return GNUNET_NO;
}
*/
void
GNUNET_CONTAINER_slist_insert (struct GNUNET_CONTAINER_SList_Iterator *before,
- enum GNUNET_CONTAINER_SListDisposition disp,
- const void *buf, size_t len)
+ enum GNUNET_CONTAINER_SListDisposition disp,
+ const void *buf, size_t len)
{
struct GNUNET_CONTAINER_SList_Elem *e;
GNUNET_CRYPTO_aes_encrypt (const void *block,
size_t len,
const struct GNUNET_CRYPTO_AesSessionKey
- *sessionkey,
+ * sessionkey,
const struct GNUNET_CRYPTO_AesInitializationVector
- *iv, void *result)
+ * iv, void *result)
{
gcry_cipher_hd_t handle;
int rc;
* @return -1 on failure, size of decrypted block on success
*/
ssize_t
-GNUNET_CRYPTO_aes_decrypt (const void *block,
- size_t size,
+GNUNET_CRYPTO_aes_decrypt (const void *block,
+ size_t size,
const struct GNUNET_CRYPTO_AesSessionKey
- *sessionkey,
- const struct GNUNET_CRYPTO_AesInitializationVector
- *iv, void *result)
+ * sessionkey,
+ const struct GNUNET_CRYPTO_AesInitializationVector
+ * iv, void *result)
{
gcry_cipher_hd_t handle;
int rc;
* @param ret pointer to where to write the hashcode
*/
void
-GNUNET_CRYPTO_hash (const void *block,
- size_t size,
- GNUNET_HashCode * ret)
+GNUNET_CRYPTO_hash (const void *block, size_t size, GNUNET_HashCode * ret)
{
struct sha512_ctx ctx;
-
+
sha512_init (&ctx);
sha512_update (&ctx, block, size);
sha512_final (&ctx, (unsigned char *) ret);
* Current offset.
*/
uint64_t offset;
-
+
/**
* Run on shutdown?
*/
GNUNET_SCHEDULER_add_after (tc->sched,
fhc->run_on_shutdown,
GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- &file_hash_task, fhc);
+ GNUNET_SCHEDULER_NO_TASK, &file_hash_task, fhc);
}
}
fhc->run_on_shutdown = run_on_shutdown;
fhc->fh = GNUNET_DISK_file_open (filename,
- GNUNET_DISK_OPEN_READ,
- GNUNET_DISK_PERM_NONE);
+ GNUNET_DISK_OPEN_READ,
+ GNUNET_DISK_PERM_NONE);
if (!fhc->fh)
{
file_hash_finish (fhc, NULL);
GNUNET_SCHEDULER_add_after (sched,
run_on_shutdown,
priority,
- GNUNET_SCHEDULER_NO_TASK,
- &file_hash_task, fhc);
+ GNUNET_SCHEDULER_NO_TASK, &file_hash_task, fhc);
}
}
void
-GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode, GNUNET_HashCode * result)
+GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode,
+ GNUNET_HashCode * result)
{
int i;
- for (i = (sizeof (GNUNET_HashCode) / sizeof (uint32_t)) - 1; i >= 0;
- i--)
- result->bits[i] = GNUNET_CRYPTO_random_u32 (mode, (uint32_t)-1);
+ for (i = (sizeof (GNUNET_HashCode) / sizeof (uint32_t)) - 1; i >= 0; i--)
+ result->bits[i] = GNUNET_CRYPTO_random_u32 (mode, (uint32_t) - 1);
}
void
GNUNET_CRYPTO_hash_difference (const GNUNET_HashCode * a,
- const GNUNET_HashCode * b,
- GNUNET_HashCode * result)
+ const GNUNET_HashCode * b,
+ GNUNET_HashCode * result)
{
int i;
for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0;
void
GNUNET_CRYPTO_hash_sum (const GNUNET_HashCode * a,
- const GNUNET_HashCode * delta,
- GNUNET_HashCode * result)
+ const GNUNET_HashCode * delta,
+ GNUNET_HashCode * result)
{
int i;
for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0;
void
GNUNET_CRYPTO_hash_xor (const GNUNET_HashCode * a,
- const GNUNET_HashCode * b, GNUNET_HashCode * result)
+ const GNUNET_HashCode * b, GNUNET_HashCode * result)
{
int i;
for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0;
*/
void
GNUNET_CRYPTO_hash_to_aes_key (const GNUNET_HashCode * hc,
- struct GNUNET_CRYPTO_AesSessionKey *skey,
- struct GNUNET_CRYPTO_AesInitializationVector
- *iv)
+ struct GNUNET_CRYPTO_AesSessionKey *skey,
+ struct GNUNET_CRYPTO_AesInitializationVector
+ *iv)
{
GNUNET_assert (sizeof (GNUNET_HashCode) >=
- GNUNET_CRYPTO_AES_KEY_LENGTH +
- sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
+ GNUNET_CRYPTO_AES_KEY_LENGTH +
+ sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
memcpy (skey, hc, GNUNET_CRYPTO_AES_KEY_LENGTH);
skey->crc32 =
htonl (GNUNET_CRYPTO_crc32_n (skey, GNUNET_CRYPTO_AES_KEY_LENGTH));
memcpy (iv, &((char *) hc)[GNUNET_CRYPTO_AES_KEY_LENGTH],
- sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
+ sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
}
/**
*/
int
GNUNET_CRYPTO_hash_cmp (const GNUNET_HashCode * h1,
- const GNUNET_HashCode * h2)
+ const GNUNET_HashCode * h2)
{
unsigned int *i1;
unsigned int *i2;
int i;
-
+
i1 = (unsigned int *) h1;
i2 = (unsigned int *) h2;
for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0;
i--)
{
if (i1[i] > i2[i])
- return 1;
+ return 1;
if (i1[i] < i2[i])
- return -1;
+ return -1;
}
return 0;
}
*/
int
GNUNET_CRYPTO_hash_xorcmp (const GNUNET_HashCode * h1,
- const GNUNET_HashCode * h2,
- const GNUNET_HashCode * target)
+ const GNUNET_HashCode * h2,
+ const GNUNET_HashCode * target)
{
int i;
unsigned int d1;
unsigned int d2;
-
+
for (i = sizeof (GNUNET_HashCode) / sizeof (unsigned int) - 1; i >= 0; i--)
{
d1 = ((unsigned int *) h1)[i] ^ ((unsigned int *) target)[i];
d2 = ((unsigned int *) h2)[i] ^ ((unsigned int *) target)[i];
if (d1 > d2)
- return 1;
+ return 1;
else if (d1 < d2)
- return -1;
+ return -1;
}
return 0;
}
* blocked gathering entropy.
*/
static void
-entropy_generator (void *cls,
- const char *what,
- int printchar,
- int current,
- int total)
+entropy_generator (void *cls,
+ const char *what, int printchar, int current, int total)
{
unsigned long code;
enum GNUNET_OS_ProcessStatusType type;
if (current == total)
{
if (genproc != 0)
- {
- if (0 != PLIBC_KILL(genproc, SIGTERM))
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
- "kill");
- GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (genproc));
- genproc = 0;
- }
+ {
+ if (0 != PLIBC_KILL (genproc, SIGTERM))
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "kill");
+ GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (genproc));
+ genproc = 0;
+ }
return;
}
if (genproc != 0)
{
- ret = GNUNET_OS_process_status (genproc,
- &type,
- &code);
+ ret = GNUNET_OS_process_status (genproc, &type, &code);
if (ret == GNUNET_NO)
- return; /* still running */
+ return; /* still running */
if (ret == GNUNET_SYSERR)
- {
- GNUNET_break (0);
- return;
- }
- if (0 != PLIBC_KILL(genproc, SIGTERM))
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
- "kill");
+ {
+ GNUNET_break (0);
+ return;
+ }
+ if (0 != PLIBC_KILL (genproc, SIGTERM))
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "kill");
GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (genproc));
- genproc = 0;
+ genproc = 0;
}
- GNUNET_log(GNUNET_ERROR_TYPE_INFO,
- _("Starting `%s' process to generate entropy\n"),
- "find");
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ _("Starting `%s' process to generate entropy\n"), "find");
genproc = GNUNET_OS_start_process ("sh",
- "sh",
- "-c",
- "exec find / -mount -type f -exec cp {} /dev/null \\; 2>/dev/null",
- NULL);
+ "sh",
+ "-c",
+ "exec find / -mount -type f -exec cp {} /dev/null \\; 2>/dev/null",
+ NULL);
}
-static void
+static void
killfind ()
{
if (genproc != 0)
{
- PLIBC_KILL(genproc, SIGKILL);
+ PLIBC_KILL (genproc, SIGKILL);
genproc = 0;
}
}
* @return a random value in the interval [0,i[.
*/
uint32_t
-GNUNET_CRYPTO_random_u32 (enum GNUNET_CRYPTO_Quality mode,
- uint32_t i)
+GNUNET_CRYPTO_random_u32 (enum GNUNET_CRYPTO_Quality mode, uint32_t i)
{
#ifdef gcry_fast_random_poll
static unsigned int invokeCount;
gcry_fast_random_poll ();
#endif
gcry_randomize ((unsigned char *) &ret,
- sizeof (uint32_t),
- GCRY_STRONG_RANDOM);
+ sizeof (uint32_t), GCRY_STRONG_RANDOM);
return ret % i;
}
else
* @return random 64-bit number
*/
uint64_t
-GNUNET_CRYPTO_random_u64 (enum GNUNET_CRYPTO_Quality mode,
- uint64_t max)
+GNUNET_CRYPTO_random_u64 (enum GNUNET_CRYPTO_Quality mode, uint64_t max)
{
uint64_t ret;
if (mode == GNUNET_CRYPTO_QUALITY_STRONG)
{
gcry_randomize ((unsigned char *) &ret,
- sizeof (uint64_t),
- GCRY_STRONG_RANDOM);
+ sizeof (uint64_t), GCRY_STRONG_RANDOM);
return ret % max;
}
else
/**
* Initializer
*/
-void __attribute__ ((constructor))
-GNUNET_util_random_init()
+void __attribute__ ((constructor)) GNUNET_util_random_init ()
{
SRANDOM (time (NULL));
}
return NULL;
while (GNUNET_YES != GNUNET_DISK_file_test (filename))
{
- fd = GNUNET_DISK_file_open (filename,
- GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_FAILIFEXISTS,
- GNUNET_DISK_PERM_USER_READ| GNUNET_DISK_PERM_USER_WRITE | GNUNET_DISK_PERM_GROUP_READ);
+ fd = GNUNET_DISK_file_open (filename,
+ GNUNET_DISK_OPEN_WRITE |
+ GNUNET_DISK_OPEN_CREATE |
+ GNUNET_DISK_OPEN_FAILIFEXISTS,
+ GNUNET_DISK_PERM_USER_READ |
+ GNUNET_DISK_PERM_USER_WRITE |
+ GNUNET_DISK_PERM_GROUP_READ);
if (NULL == fd)
{
if (errno == EEXIST)
}
cnt = 0;
- while (GNUNET_YES != GNUNET_DISK_file_lock (fd, 0, sizeof (struct RsaPrivateKeyBinaryEncoded), GNUNET_YES))
+ while (GNUNET_YES !=
+ GNUNET_DISK_file_lock (fd, 0,
+ sizeof (struct
+ RsaPrivateKeyBinaryEncoded),
+ GNUNET_YES))
{
sleep (1);
if (0 == ++cnt % 10)
GNUNET_assert (ret != NULL);
enc = rsa_encode_key (ret);
GNUNET_assert (enc != NULL);
- GNUNET_assert (ntohs (enc->len) == GNUNET_DISK_file_write (fd, enc, ntohs (enc->len)));
+ GNUNET_assert (ntohs (enc->len) ==
+ GNUNET_DISK_file_write (fd, enc, ntohs (enc->len)));
GNUNET_free (enc);
GNUNET_DISK_file_sync (fd);
- if (GNUNET_YES != GNUNET_DISK_file_unlock (fd, 0, sizeof (struct RsaPrivateKeyBinaryEncoded)))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "fcntl", filename);
+ if (GNUNET_YES !=
+ GNUNET_DISK_file_unlock (fd, 0,
+ sizeof (struct
+ RsaPrivateKeyBinaryEncoded)))
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "fcntl",
+ filename);
GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Stored new private key in `%s'.\n"), filename);
}
/* hostkey file exists already, read it! */
fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
- GNUNET_DISK_PERM_NONE);
+ GNUNET_DISK_PERM_NONE);
if (NULL == fd)
{
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", filename);
cnt = 0;
while (1)
{
- if (GNUNET_YES != GNUNET_DISK_file_lock (fd, 0, sizeof (struct RsaPrivateKeyBinaryEncoded), GNUNET_NO))
+ if (GNUNET_YES !=
+ GNUNET_DISK_file_lock (fd, 0,
+ sizeof (struct RsaPrivateKeyBinaryEncoded),
+ GNUNET_NO))
{
if (0 == ++cnt % 10)
{
/* eh, what!? File we opened is now gone!? */
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
"stat", filename);
- if (GNUNET_YES != GNUNET_DISK_file_unlock (fd, 0, sizeof (struct RsaPrivateKeyBinaryEncoded)))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "fcntl", filename);
+ if (GNUNET_YES !=
+ GNUNET_DISK_file_unlock (fd, 0,
+ sizeof (struct
+ RsaPrivateKeyBinaryEncoded)))
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "fcntl",
+ filename);
GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fd));
return NULL;
{
/* maybe we got the read lock before the hostkey generating
process had a chance to get the write lock; give it up! */
- if (GNUNET_YES != GNUNET_DISK_file_unlock (fd, 0, sizeof (struct RsaPrivateKeyBinaryEncoded)))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "fcntl", filename);
+ if (GNUNET_YES !=
+ GNUNET_DISK_file_unlock (fd, 0,
+ sizeof (struct
+ RsaPrivateKeyBinaryEncoded)))
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "fcntl",
+ filename);
if (0 == ++cnt % 10)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
filename);
}
GNUNET_free (enc);
- if (GNUNET_YES != GNUNET_DISK_file_unlock (fd, 0, sizeof (struct RsaPrivateKeyBinaryEncoded)))
+ if (GNUNET_YES !=
+ GNUNET_DISK_file_unlock (fd, 0,
+ sizeof (struct RsaPrivateKeyBinaryEncoded)))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
return ret;
* @return the size of the decrypted block, -1 on error
*/
ssize_t
-GNUNET_CRYPTO_rsa_decrypt (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
- const struct GNUNET_CRYPTO_RsaEncryptedData *block,
- void *result,
- size_t max)
+GNUNET_CRYPTO_rsa_decrypt (const struct GNUNET_CRYPTO_RsaPrivateKey * key,
+ const struct GNUNET_CRYPTO_RsaEncryptedData *
+ block, void *result, size_t max)
{
gcry_sexp_t resultsexp;
gcry_sexp_t data;
/**
* File descriptors for the pipe.
*/
- struct GNUNET_DISK_FileHandle * fd[2];
+ struct GNUNET_DISK_FileHandle *fd[2];
};
* @return the new position on success, GNUNET_SYSERR otherwise
*/
off_t
-GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle *h, off_t offset,
- enum GNUNET_DISK_Seek whence)
+GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle * h, off_t offset,
+ enum GNUNET_DISK_Seek whence)
{
if (h == NULL)
{
#ifdef MINGW
DWORD ret;
- static DWORD t[] = { [GNUNET_DISK_SEEK_SET] = FILE_BEGIN,
- [GNUNET_DISK_SEEK_CUR] = FILE_CURRENT, [GNUNET_DISK_SEEK_END] = FILE_END };
+ static DWORD t[] = {[GNUNET_DISK_SEEK_SET] = FILE_BEGIN,
+ [GNUNET_DISK_SEEK_CUR] = FILE_CURRENT,[GNUNET_DISK_SEEK_END] = FILE_END
+ };
ret = SetFilePointer (h->h, offset, NULL, t[whence]);
if (ret == INVALID_SET_FILE_POINTER)
}
return ret;
#else
- static int t[] = { [GNUNET_DISK_SEEK_SET] = SEEK_SET,
- [GNUNET_DISK_SEEK_CUR] = SEEK_CUR, [GNUNET_DISK_SEEK_END] = SEEK_END };
+ static int t[] = {[GNUNET_DISK_SEEK_SET] = SEEK_SET,
+ [GNUNET_DISK_SEEK_CUR] = SEEK_CUR,[GNUNET_DISK_SEEK_END] = SEEK_END
+ };
return lseek (h->fd, offset, t[whence]);
#endif
*/
int
GNUNET_DISK_file_size (const char *filename,
- uint64_t *size,
- int includeSymLinks)
+ uint64_t * size, int includeSymLinks)
{
struct GetFileSizeData gfsd;
int ret;
* @param ino set to the inode ID
* @return GNUNET_OK on success
*/
-int GNUNET_DISK_file_get_identifiers (const char *filename,
- uint32_t *dev,
- uint64_t *ino)
+int
+GNUNET_DISK_file_get_identifiers (const char *filename,
+ uint32_t * dev, uint64_t * ino)
{
#if LINUX
struct stat sbuf;
struct statvfs fbuf;
- if ( (0 == stat(filename,
- &sbuf)) &&
- (0 == statvfs (filename,
- &fbuf) ) )
+ if ((0 == stat (filename, &sbuf)) && (0 == statvfs (filename, &fbuf)))
{
*dev = (uint32_t) fbuf.f_fsid;
*ino = (uint64_t) sbuf.st_ino;
return GNUNET_OK;
}
-#endif
+#endif
return GNUNET_SYSERR;
}
-
+
/**
* Create an (empty) temporary file on disk.
tmpdir = getenv ("TMPDIR");
tmpdir = tmpdir ? tmpdir : "/tmp";
- GNUNET_asprintf (&tmpl,
- "%s%s%s%s",
- tmpdir,
- DIR_SEPARATOR_STR,
- t,
- "XXXXXX");
+ GNUNET_asprintf (&tmpl, "%s%s%s%s", tmpdir, DIR_SEPARATOR_STR, t, "XXXXXX");
#ifdef MINGW
fn = (char *) GNUNET_malloc (MAX_PATH + 1);
plibc_conv_to_win_path (tmpl, fn);
fd = mkstemp (fn);
if (fd == -1)
{
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
- "mkstemp",
- fn);
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "mkstemp", fn);
GNUNET_free (fn);
return NULL;
}
if (0 != CLOSE (fd))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "close",
- fn);
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "close", fn);
return fn;
}
if (!GetDiskFreeSpace (szDrive, &dwDummy, &dwDummy, &dwBlocks, &dwDummy))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("`%s' failed for drive `%s': %u\n"),
- "GetDiskFreeSpace", szDrive, GetLastError ());
+ _("`%s' failed for drive `%s': %u\n"),
+ "GetDiskFreeSpace", szDrive, GetLastError ());
return -1;
}
* @return the number of bytes read on success, GNUNET_SYSERR on failure
*/
ssize_t
-GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle *h, void *result,
- size_t len)
+GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle * h, void *result,
+ size_t len)
{
if (h == NULL)
{
* @return number of bytes read, GNUNET_SYSERR on failure
*/
ssize_t
-GNUNET_DISK_fn_read (const char * fn,
- void *result,
- size_t len)
+GNUNET_DISK_fn_read (const char *fn, void *result, size_t len)
{
struct GNUNET_DISK_FileHandle *fh;
ssize_t ret;
fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_READ,
- GNUNET_DISK_PERM_NONE);
+ GNUNET_DISK_PERM_NONE);
if (!fh)
return GNUNET_SYSERR;
ret = GNUNET_DISK_file_read (fh, result, len);
- GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fh));
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
return ret;
}
* @return number of bytes written on success, GNUNET_SYSERR on error
*/
ssize_t
-GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle *h, const void *buffer,
- size_t n)
+GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle * h,
+ const void *buffer, size_t n)
{
if (h == NULL)
{
* @return number of bytes written on success, GNUNET_SYSERR on error
*/
ssize_t
-GNUNET_DISK_fn_write (const char * fn, const void *buffer,
- size_t n,
- enum GNUNET_DISK_AccessPermissions mode)
+GNUNET_DISK_fn_write (const char *fn, const void *buffer,
+ size_t n, enum GNUNET_DISK_AccessPermissions mode)
{
struct GNUNET_DISK_FileHandle *fh;
ssize_t ret;
- fh = GNUNET_DISK_file_open (fn,
- GNUNET_DISK_OPEN_WRITE
- | GNUNET_DISK_OPEN_TRUNCATE
- | GNUNET_DISK_OPEN_CREATE, mode);
+ fh = GNUNET_DISK_file_open (fn,
+ GNUNET_DISK_OPEN_WRITE
+ | GNUNET_DISK_OPEN_TRUNCATE
+ | GNUNET_DISK_OPEN_CREATE, mode);
if (!fh)
return GNUNET_SYSERR;
ret = GNUNET_DISK_file_write (fh, buffer, n);
- GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fh));
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
return ret;
}
int
GNUNET_DISK_directory_scan (const char *dirName,
GNUNET_FileNameCallback callback,
- void *callback_cls)
+ void *callback_cls)
{
DIR *dinfo;
struct dirent *finfo;
return GNUNET_SYSERR;
}
if (GNUNET_SYSERR ==
- GNUNET_DISK_directory_scan (fileName,
- &remove_helper,
- NULL))
+ GNUNET_DISK_directory_scan (fileName, &remove_helper, NULL))
return GNUNET_SYSERR;
if (0 != RMDIR (fileName))
{
return GNUNET_SYSERR;
pos = 0;
in = GNUNET_DISK_file_open (src, GNUNET_DISK_OPEN_READ,
- GNUNET_DISK_PERM_NONE);
+ GNUNET_DISK_PERM_NONE);
if (!in)
return GNUNET_SYSERR;
out = GNUNET_DISK_file_open (dst, GNUNET_DISK_OPEN_WRITE
- | GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_FAILIFEXISTS,
- GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE
- | GNUNET_DISK_PERM_GROUP_READ | GNUNET_DISK_PERM_GROUP_WRITE);
+ | GNUNET_DISK_OPEN_CREATE |
+ GNUNET_DISK_OPEN_FAILIFEXISTS,
+ GNUNET_DISK_PERM_USER_READ |
+ GNUNET_DISK_PERM_USER_WRITE |
+ GNUNET_DISK_PERM_GROUP_READ |
+ GNUNET_DISK_PERM_GROUP_WRITE);
if (!out)
{
GNUNET_DISK_file_close (in);
*/
int
GNUNET_DISK_file_lock (struct GNUNET_DISK_FileHandle *fh, off_t lockStart,
- off_t lockEnd, int excl)
+ off_t lockEnd, int excl)
{
if (fh == NULL)
{
#ifndef MINGW
struct flock fl;
- memset (&fl, 0, sizeof(struct flock));
+ memset (&fl, 0, sizeof (struct flock));
fl.l_type = excl ? F_WRLCK : F_RDLCK;
fl.l_whence = SEEK_SET;
fl.l_start = lockStart;
#else
OVERLAPPED o;
- memset (&o, 0, sizeof(OVERLAPPED));
+ memset (&o, 0, sizeof (OVERLAPPED));
o.Offset = lockStart;
if (!LockFileEx (fh->h, (excl ? LOCKFILE_EXCLUSIVE_LOCK : 0)
- | LOCKFILE_FAIL_IMMEDIATELY, 0, lockEnd - lockStart, 0, &o))
+ | LOCKFILE_FAIL_IMMEDIATELY, 0, lockEnd - lockStart, 0,
+ &o))
{
SetErrnoFromWinError (GetLastError ());
return GNUNET_SYSERR;
*/
int
GNUNET_DISK_file_unlock (struct GNUNET_DISK_FileHandle *fh, off_t unlockStart,
- off_t unlockEnd)
+ off_t unlockEnd)
{
if (fh == NULL)
{
#ifndef MINGW
struct flock fl;
- memset (&fl, 0, sizeof(struct flock));
+ memset (&fl, 0, sizeof (struct flock));
fl.l_type = F_UNLCK;
fl.l_whence = SEEK_SET;
fl.l_start = unlockStart;
#else
OVERLAPPED o;
- memset (&o, 0, sizeof(OVERLAPPED));
+ memset (&o, 0, sizeof (OVERLAPPED));
o.Offset = unlockStart;
if (!UnlockFileEx (fh->h, 0, unlockEnd - unlockStart, 0, &o))
*/
struct GNUNET_DISK_FileHandle *
GNUNET_DISK_file_open (const char *fn,
- enum GNUNET_DISK_OpenFlags flags,
- enum GNUNET_DISK_AccessPermissions perm)
+ enum GNUNET_DISK_OpenFlags flags,
+ enum GNUNET_DISK_AccessPermissions perm)
{
char *expfn;
struct GNUNET_DISK_FileHandle *ret;
#ifndef MINGW
mode = 0;
if (GNUNET_DISK_OPEN_READWRITE == (flags & GNUNET_DISK_OPEN_READWRITE))
- oflags = O_RDWR; /* note: O_RDWR is NOT always O_RDONLY | O_WRONLY */
+ oflags = O_RDWR; /* note: O_RDWR is NOT always O_RDONLY | O_WRONLY */
else if (flags & GNUNET_DISK_OPEN_READ)
oflags = O_RDONLY;
else if (flags & GNUNET_DISK_OPEN_WRITE)
fd = open (expfn, oflags | O_LARGEFILE, mode);
if (fd == -1)
- {
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", expfn);
- GNUNET_free (expfn);
- return NULL;
- }
+ {
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", expfn);
+ GNUNET_free (expfn);
+ return NULL;
+ }
#else
access = 0;
disp = OPEN_ALWAYS;
disp = TRUNCATE_EXISTING;
}
else
- {
- disp = OPEN_ALWAYS;
- }
+ {
+ disp = OPEN_ALWAYS;
+ }
/* TODO: access priviledges? */
h = CreateFile (expfn, access, FILE_SHARE_DELETE | FILE_SHARE_READ
- | FILE_SHARE_WRITE, NULL, disp, FILE_ATTRIBUTE_NORMAL, NULL);
+ | FILE_SHARE_WRITE, NULL, disp, FILE_ATTRIBUTE_NORMAL,
+ NULL);
if (h == INVALID_HANDLE_VALUE)
- {
- SetErrnoFromWinError (GetLastError ());
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", expfn);
- GNUNET_free (expfn);
- return NULL;
- }
-
- if (flags & GNUNET_DISK_OPEN_APPEND)
- if (SetFilePointer (h, 0, 0, FILE_END) == INVALID_SET_FILE_POINTER)
{
SetErrnoFromWinError (GetLastError ());
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "SetFilePointer", expfn);
- CloseHandle (h);
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", expfn);
GNUNET_free (expfn);
return NULL;
}
+
+ if (flags & GNUNET_DISK_OPEN_APPEND)
+ if (SetFilePointer (h, 0, 0, FILE_END) == INVALID_SET_FILE_POINTER)
+ {
+ SetErrnoFromWinError (GetLastError ());
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "SetFilePointer",
+ expfn);
+ CloseHandle (h);
+ GNUNET_free (expfn);
+ return NULL;
+ }
#endif
- ret = GNUNET_malloc(sizeof(struct GNUNET_DISK_FileHandle));
+ ret = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
#ifdef MINGW
ret->h = h;
#else
#if MINGW
if (!CloseHandle (h->h))
- {
- SetErrnoFromWinError (GetLastError ());
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "close");
- GNUNET_free (h);
- return GNUNET_SYSERR;
- }
+ {
+ SetErrnoFromWinError (GetLastError ());
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "close");
+ GNUNET_free (h);
+ return GNUNET_SYSERR;
+ }
#else
if (close (h->fd) != 0)
- {
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "close");
- GNUNET_free (h);
- return GNUNET_SYSERR;
- }
+ {
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "close");
+ GNUNET_free (h);
+ return GNUNET_SYSERR;
+ }
#endif
GNUNET_free (h);
return GNUNET_OK;
* @return pointer to the mapped memory region, NULL on failure
*/
void *
-GNUNET_DISK_file_map (const struct GNUNET_DISK_FileHandle *h, struct GNUNET_DISK_MapHandle **m,
- enum GNUNET_DISK_MapType access, size_t len)
+GNUNET_DISK_file_map (const struct GNUNET_DISK_FileHandle *h,
+ struct GNUNET_DISK_MapHandle **m,
+ enum GNUNET_DISK_MapType access, size_t len)
{
if (h == NULL)
{
DWORD mapAccess, protect;
void *ret;
- if ((access & GNUNET_DISK_MAP_TYPE_READ) &&
+ if ((access & GNUNET_DISK_MAP_TYPE_READ) &&
(access & GNUNET_DISK_MAP_TYPE_WRITE))
{
protect = PAGE_READWRITE;
struct GNUNET_DISK_PipeHandle *p;
struct GNUNET_DISK_FileHandle *fds;
- p = GNUNET_malloc (sizeof (struct GNUNET_DISK_PipeHandle) + 2 * sizeof (struct GNUNET_DISK_FileHandle));
+ p =
+ GNUNET_malloc (sizeof (struct GNUNET_DISK_PipeHandle) +
+ 2 * sizeof (struct GNUNET_DISK_FileHandle));
fds = (struct GNUNET_DISK_FileHandle *) &p[1];
p->fd[0] = &fds[0];
p->fd[1] = &fds[1];
flags |= O_NONBLOCK;
ret = fcntl (fd[0], F_SETFL, flags);
if (ret != -1)
- {
- flags = fcntl (fd[1], F_GETFL);
- flags |= O_NONBLOCK;
- ret = fcntl (fd[1], F_SETFL, flags);
- }
+ {
+ flags = fcntl (fd[1], F_GETFL);
+ flags |= O_NONBLOCK;
+ ret = fcntl (fd[1], F_SETFL, flags);
+ }
if (ret == -1)
- {
- eno = errno;
- GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "fcntl");
- GNUNET_break (0 == close (p->fd[0]->fd));
- GNUNET_break (0 == close (p->fd[1]->fd));
- GNUNET_free (p);
- errno = eno;
- return NULL;
- }
+ {
+ eno = errno;
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fcntl");
+ GNUNET_break (0 == close (p->fd[0]->fd));
+ GNUNET_break (0 == close (p->fd[1]->fd));
+ GNUNET_free (p);
+ errno = eno;
+ return NULL;
+ }
}
#else
BOOL ret;
ret = CreatePipe (&p->fd[0]->h, &p->fd[1]->h, NULL, 0);
- if (! ret)
+ if (!ret)
{
GNUNET_free (p);
SetErrnoFromWinError (GetLastError ());
if (!blocking)
{
DWORD mode;
-
+
mode = PIPE_NOWAIT;
- p->fd[0] = GNUNET_malloc(sizeof(struct GNUNET_DISK_FileHandle));
- p->fd[1] = GNUNET_malloc(sizeof(struct GNUNET_DISK_FileHandle));
+ p->fd[0] = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
+ p->fd[1] = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
SetNamedPipeHandleState (p->fd[0]->h, &mode, NULL, NULL);
SetNamedPipeHandleState (p->fd[1]->h, &mode, NULL, NULL);
/* this always fails on Windows 95, so we don't care about error handling */
{
int ret = GNUNET_OK;
int save;
-
+
#ifdef MINGW
if (!CloseHandle (p->fd[0]->h))
{
* @param n end to access
*/
const struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_pipe_handle (const struct GNUNET_DISK_PipeHandle *p,
- enum GNUNET_DISK_PipeEnd n)
+GNUNET_DISK_pipe_handle (const struct GNUNET_DISK_PipeHandle *p,
+ enum GNUNET_DISK_PipeEnd n)
{
switch (n)
{
*/
int
GNUNET_DISK_internal_file_handle_ (const struct GNUNET_DISK_FileHandle *fh,
- void *dst,
- size_t dst_len)
+ void *dst, size_t dst_len)
{
#ifdef MINGW
if (dst_len < sizeof (HANDLE))
return GNUNET_SYSERR;
*((HANDLE *) dst) = fh->h;
#else
- if (dst_len < sizeof(int))
+ if (dst_len < sizeof (int))
return GNUNET_SYSERR;
*((int *) dst) = fh->fd;
#endif
along with GNUnet; see the file COPYING. If not, write to the\r
Free Software Foundation, Inc., 59 Temple Place - Suite 330,\r
Boston, MA 02111-1307, USA.\r
-*/\r
-\r
+*/ \r
+ \r
/**\r
* @file util/disk.h\r
* @brief Internal DISK related helper functions\r
* @author Nils Durner\r
- */\r
-\r
-\r
+ */ \r
+ \r\r
#ifndef GNUNET_DISK_H_\r
#define GNUNET_DISK_H_\r
-\r
+ \r
#include "gnunet_disk_lib.h"\r
-\r
-\r
+ \r\r
/**\r
* Handle used to access files (and pipes). \r
- */\r
-struct GNUNET_DISK_FileHandle\r
-{\r
+ */ \r
+struct GNUNET_DISK_FileHandle \r
+{
+ \r
#ifdef MINGW\r
/**\r
* File handle under W32.\r
- */\r
- HANDLE h;\r
-#else\r
+ */ \r
+ HANDLE h;
+ \r
+#else /* \r */
/**\r
* File handle on other OSes.\r
- */\r
- int fd;\r
-#endif\r
-};\r
-\r
-\r
-\r
+ */ \r
+ int fd;
+ \r
+#endif /* \r */
+};
+\r\r\r\r
/**\r
* Retrieve OS file handle\r
*\r
* @param dst destination buffer\r
* @param dst_len length of dst\r
* @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
- */\r
-int GNUNET_DISK_internal_file_handle_ (const struct GNUNET_DISK_FileHandle *fh,\r
- void *dst,\r
- size_t dst_len);\r
-\r
-#endif /* GNUNET_DISK_H_ */\r
+ */ \r
+int GNUNET_DISK_internal_file_handle_ (const struct GNUNET_DISK_FileHandle
+ *fh, \rvoid *dst, \rsize_t dst_len);
+\r\r
+#endif /* GNUNET_DISK_H_ */\r
* This is a linked list.
*/
struct IPCache *next;
-
+
/**
* Hostname in human-readable form.
*/
* Hostname in binary format.
*/
struct sockaddr *sa;
-
+
/**
* Last time this entry was updated.
*/
{
char hostname[256];
- if (0 == getnameinfo (cache->sa,
- cache->salen,
- hostname,
- sizeof(hostname),
- NULL, 0, 0))
+ if (0 == getnameinfo (cache->sa,
+ cache->salen,
+ hostname, sizeof (hostname), NULL, 0, 0))
cache->addr = GNUNET_strdup (hostname);
}
#endif
// FIXME NILS
1
#endif
- )
+ )
return GNUNET_NO; /* other function may still succeed */
return GNUNET_SYSERR;
}
along with GNUnet; see the file COPYING. If not, write to the\r
Free Software Foundation, Inc., 59 Temple Place - Suite 330,\r
Boston, MA 02111-1307, USA.\r
-*/\r
-\r
+*/ \r
+ \r
/**\r
* @file util/network.c\r
* @brief basic, low-level networking interface\r
* @author Nils Durner\r
- */\r
-\r
+ */ \r
+ \r
#include "platform.h"\r
#include "gnunet_disk_lib.h"\r
#include "disk.h"\r
#include "gnunet_container_lib.h"\r
-\r
+ \r
#define DEBUG_NETWORK GNUNET_NO\r
-\r
+ \r
#ifndef INVALID_SOCKET\r
#define INVALID_SOCKET -1\r
-#endif\r
-\r
-struct GNUNET_NETWORK_Handle\r
-{\r
- int fd;\r
-};\r
-\r
-struct GNUNET_NETWORK_FDSet\r
-{\r
- /* socket descriptors */\r
- int nsds;\r
- fd_set sds;\r
+#endif /* \r */
+\rstruct GNUNET_NETWORK_Handle \r
+{
+ \rint fd;
+ \r};
+\r\rstruct GNUNET_NETWORK_FDSet \r
+{
+ \r
+ /* socket descriptors */ \r
+ int nsds;
+ \rfd_set sds;
+ \r
#ifdef WINDOWS\r
- /* handles */\r
- struct GNUNET_CONTAINER_SList *handles;\r
-#endif\r
-};\r
-\r
+ /* handles */ \r
+ struct GNUNET_CONTAINER_SList *handles;
+ \r
+#endif /* \r */
+};
+\r\r
#ifndef FD_COPY\r
#define FD_COPY(s, d) (memcpy ((d), (s), sizeof (fd_set)))\r
-#endif\r
-\r
-\r
-\r
+#endif /* \r */
+ \r\r\r
/**\r
* Set if a socket should use blocking or non-blocking IO.\r
* @param fd socket\r
* @param doBlock blocking mode\r
* @return GNUNET_OK on success, GNUNET_SYSERR on error\r
- */\r
-static int\r
-socket_set_blocking (struct GNUNET_NETWORK_Handle *fd,\r
- int doBlock)\r
-{\r
+ */ \r
+static int \r
+socket_set_blocking (struct GNUNET_NETWORK_Handle *fd, \rint doBlock) \r
+{
+ \r
#if MINGW\r
- u_long mode;\r
- mode = !doBlock;\r
- if (ioctlsocket (fd->fd, FIONBIO, &mode) == SOCKET_ERROR)\r
- {\r
- SetErrnoFromWinsockError (WSAGetLastError ());\r
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "ioctlsocket");\r
- return GNUNET_SYSERR;\r
- }\r
- return GNUNET_OK;\r
-\r
-#else\r
- /* not MINGW */\r
- int flags = fcntl (fd->fd, F_GETFL);\r
- if (flags == -1)\r
- {\r
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");\r
- return GNUNET_SYSERR;\r
- }\r
- if (doBlock)\r
- flags &= ~O_NONBLOCK;\r
- else\r
- flags |= O_NONBLOCK;\r
- if (0 != fcntl (fd->fd, F_SETFL, flags))\r
- {\r
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");\r
- return GNUNET_SYSERR;\r
- }\r
- return GNUNET_OK;\r
-#endif\r
-}\r
-\r
-\r
+ u_long mode;
+ \rmode = !doBlock;
+ \rif (ioctlsocket (fd->fd, FIONBIO, &mode) == SOCKET_ERROR)
+ \r
+ {
+ \rSetErrnoFromWinsockError (WSAGetLastError ());
+ \rGNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "ioctlsocket");
+ \rreturn GNUNET_SYSERR;
+ \r}
+ \rreturn GNUNET_OK;
+ \r\r
+#else /* \r */
+ /* not MINGW */ \r
+ int flags = fcntl (fd->fd, F_GETFL);
+ \rif (flags == -1)
+ \r
+ {
+ \rGNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");
+ \rreturn GNUNET_SYSERR;
+ \r}
+ \rif (doBlock)
+ \rflags &= ~O_NONBLOCK;
+ \r
+ else
+ \rflags |= O_NONBLOCK;
+ \rif (0 != fcntl (fd->fd, F_SETFL, flags))
+ \r
+ {
+ \rGNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");
+ \rreturn GNUNET_SYSERR;
+ \r}
+ \rreturn GNUNET_OK;
+ \r
+#endif /* \r */
+}
+
+\r\r\r
#ifndef MINGW\r
/**\r
* Make a socket non-inheritable to child processes\r
* @param h the socket to make non-inheritable\r
* @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
* @warning Not implemented on Windows\r
- */\r
-static int\r
-socket_set_inheritable (const struct GNUNET_NETWORK_Handle\r
- *h)\r
-{\r
- int i;\r
-\r
- i = fcntl (h->fd, F_GETFD);\r
- if (i == (i | FD_CLOEXEC))\r
- return GNUNET_OK;\r
- return (fcntl (h->fd, F_SETFD, i | FD_CLOEXEC) == 0)\r
- ? GNUNET_OK : GNUNET_SYSERR;\r
-}\r
-#endif\r
-\r
-\r
-\r
+ */ \r
+static int \r
+socket_set_inheritable (const struct GNUNET_NETWORK_Handle \r*h) \r
+{
+ \rint i;
+ \r\ri = fcntl (h->fd, F_GETFD);
+ \rif (i == (i | FD_CLOEXEC))
+ \rreturn GNUNET_OK;
+ \rreturn (fcntl (h->fd, F_SETFD, i | FD_CLOEXEC) == 0) \r
+ ? GNUNET_OK : GNUNET_SYSERR;
+\r}
+
+\r
+#endif /* \r */
+ \r\r\r
#ifdef DARWIN\r
/**\r
* The MSG_NOSIGNAL equivalent on Mac OS X\r
*\r
* @param h the socket to make non-delaying\r
- */\r
-static void\r
-socket_set_nosigpipe (const struct GNUNET_NETWORK_Handle\r
- *h)\r
-{\r
- int value = 1;\r
- if (0 != setsockopt (h->fd, SOL_SOCKET, SO_NOSIGPIPE, &value, sizeof(value)))\r
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,\r
- "setsockopt");\r
-}\r
-#endif\r
-\r
-\r
-\r
+ */ \r
+static void \r
+socket_set_nosigpipe (const struct GNUNET_NETWORK_Handle \r*h) \r
+{
+ \rint value = 1;
+ \rif (0 !=
+ setsockopt (h->fd, SOL_SOCKET, SO_NOSIGPIPE, &value, sizeof (value)))
+ \rGNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, \r"setsockopt");
+\r}
+
+\r
+#endif /* \r */
+ \r\r\r
/**\r
* Disable delays when sending data via the socket.\r
* (GNUnet makes sure that messages are as big as\r
* possible already).\r
*\r
* @param h the socket to make non-delaying\r
- */\r
-static void\r
-socket_set_nodelay (const struct GNUNET_NETWORK_Handle\r
- *h)\r
-{\r
- int value = 1;\r
- if (0 != setsockopt (h->fd, IPPROTO_TCP, TCP_NODELAY, &value, sizeof(value)))\r
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,\r
- "setsockopt");\r
-\r
-}\r
-\r
-\r
-\r
+ */ \r
+static void \r
+socket_set_nodelay (const struct GNUNET_NETWORK_Handle \r*h) \r
+{
+ \rint value = 1;
+ \rif (0 !=
+ setsockopt (h->fd, IPPROTO_TCP, TCP_NODELAY, &value, sizeof (value)))
+ \rGNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, \r"setsockopt");
+\r\r}
+
+\r\r\r\r
/**\r
* accept a new connection on a socket\r
*\r
* @param address address of the connecting peer, may be NULL\r
* @param address_len length of address\r
* @return client socket\r
- */\r
+ */ \r
struct GNUNET_NETWORK_Handle *\r
-GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,\r
- struct sockaddr *address,\r
- socklen_t * address_len)\r
-{\r
- struct GNUNET_NETWORK_Handle *ret;\r
-\r
- ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle));\r
- ret->fd = accept (desc->fd, address, address_len);\r
- if (ret->fd == INVALID_SOCKET)\r
- {\r
+GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,
+ \rstruct sockaddr *address,
+ \rsocklen_t * address_len) \r
+{
+ \rstruct GNUNET_NETWORK_Handle *ret;
+ \r\rret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle));
+ \rret->fd = accept (desc->fd, address, address_len);
+ \rif (ret->fd == INVALID_SOCKET)
+ \r
+ {
+ \r
#ifdef MINGW\r
- SetErrnoFromWinsockError (WSAGetLastError ());\r
-#endif\r
- GNUNET_free (ret);\r
- return NULL;\r
- }\r
+ SetErrnoFromWinsockError (WSAGetLastError ());
+ \r
+#endif /* \r */
+ GNUNET_free (ret);
+ \rreturn NULL;
+ \r}
+ \r
#ifndef MINGW\r
- if (ret->fd >= FD_SETSIZE)\r
- {\r
- GNUNET_break (0 == close (ret->fd));\r
- GNUNET_free (ret);\r
- errno = EMFILE;\r
- return NULL;\r
- }\r
-#endif\r
- if (GNUNET_SYSERR == socket_set_blocking (ret, GNUNET_NO))\r
- {\r
- /* we might want to treat this one as fatal... */\r
- GNUNET_break (0);\r
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ret));\r
- return NULL; \r
- }\r
+ if (ret->fd >= FD_SETSIZE)
+ \r
+ {
+ \rGNUNET_break (0 == close (ret->fd));
+ \rGNUNET_free (ret);
+ \rerrno = EMFILE;
+ \rreturn NULL;
+ \r}
+ \r
+#endif /* \r */
+ if (GNUNET_SYSERR == socket_set_blocking (ret, GNUNET_NO))
+ \r
+ {
+ \r
+ /* we might want to treat this one as fatal... */ \r
+ GNUNET_break (0);
+ \rGNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ret));
+ \rreturn NULL;
+ \r}
+ \r
#ifndef MINGW\r
- if (GNUNET_OK != socket_set_inheritable (ret))\r
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,\r
- "socket_set_inheritable");\r
-#endif\r
+ if (GNUNET_OK != socket_set_inheritable (ret))
+ \rGNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+ \r"socket_set_inheritable");
+ \r
+#endif /* \r */
#ifdef DARWIN\r
- socket_set_nosigpipe (ret); \r
-#endif\r
- socket_set_nodelay (ret);\r
- return ret;\r
-}\r
-\r
+ socket_set_nosigpipe (ret);
+ \r
+#endif /* \r */
+ socket_set_nodelay (ret);
+ \rreturn ret;
+\r}
+
+\r\r
/**\r
* Bind to a connected socket\r
* @param desc socket\r
* @param address address to be bound\r
* @param address_len length of address\r
* @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
- */\r
-int\r
-GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,\r
- const struct sockaddr *address,\r
- socklen_t address_len)\r
-{\r
- int ret;\r
-\r
- ret = bind (desc->fd, address, address_len);\r
+ */ \r
+int \r
+GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,
+ \rconst struct sockaddr *address,
+ \rsocklen_t address_len) \r
+{
+ \rint ret;
+ \r\rret = bind (desc->fd, address, address_len);
+ \r
#ifdef MINGW\r
- if (SOCKET_ERROR == ret)\r
- SetErrnoFromWinsockError (WSAGetLastError ());\r
-#endif\r
- return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
-}\r
-\r
-\r
+ if (SOCKET_ERROR == ret)
+ \rSetErrnoFromWinsockError (WSAGetLastError ());
+ \r
+#endif /* \r */
+ return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
+\r}
+
+\r\r\r
/**\r
* Close a socket\r
* @param desc socket\r
* @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
- */\r
-int\r
-GNUNET_NETWORK_socket_close (struct GNUNET_NETWORK_Handle *desc)\r
-{\r
- int ret;\r
- int eno;\r
-\r
+ */ \r
+int \r
+GNUNET_NETWORK_socket_close (struct GNUNET_NETWORK_Handle *desc) \r
+{
+ \rint ret;
+ \rint eno;
+ \r\r
#ifdef MINGW\r
- ret = closesocket (desc->fd);\r
- SetErrnoFromWinsockError (WSAGetLastError ()); \r
-#else\r
- ret = close (desc->fd);\r
-#endif \r
- eno = errno;\r
- GNUNET_free (desc);\r
- errno = eno;\r
- return (ret == 0) ? GNUNET_OK : GNUNET_SYSERR;\r
-}\r
-\r
+ ret = closesocket (desc->fd);
+ \rSetErrnoFromWinsockError (WSAGetLastError ());
+ \r
+#else /* \r */
+ ret = close (desc->fd);
+ \r
+#endif /* \r */
+ eno = errno;
+ \rGNUNET_free (desc);
+ \rerrno = eno;
+ \rreturn (ret == 0) ? GNUNET_OK : GNUNET_SYSERR;
+\r}
+
+\r\r
/**\r
* Connect a socket\r
* @param desc socket\r
* @param address peer address\r
* @param address_len length of address\r
* @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
- */\r
-int\r
-GNUNET_NETWORK_socket_connect (const struct GNUNET_NETWORK_Handle *desc,\r
- const struct sockaddr *address,\r
- socklen_t address_len)\r
-{\r
- int ret;\r
-\r
- ret = connect (desc->fd, address, address_len);\r
+ */ \r
+int \r
+GNUNET_NETWORK_socket_connect (const struct GNUNET_NETWORK_Handle *desc,
+ \rconst struct sockaddr *address,
+ \rsocklen_t address_len) \r
+{
+ \rint ret;
+ \r\rret = connect (desc->fd, address, address_len);
+ \r
#ifdef MINGW\r
- if (SOCKET_ERROR == ret)\r
- {\r
- SetErrnoFromWinsockError (WSAGetLastError ());\r
- if (errno == EWOULDBLOCK)\r
- errno = EINPROGRESS;\r
- }\r
-#endif\r
- return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
-}\r
-\r
+ if (SOCKET_ERROR == ret)
+ \r
+ {
+ \rSetErrnoFromWinsockError (WSAGetLastError ());
+ \rif (errno == EWOULDBLOCK)
+ \rerrno = EINPROGRESS;
+ \r}
+ \r
+#endif /* \r */
+ return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
+\r}
+
+\r\r
/**\r
* Get socket options\r
*\r
* @param optval options\r
* @param optlen length of optval\r
* @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
- */\r
-int\r
-GNUNET_NETWORK_socket_getsockopt (const struct GNUNET_NETWORK_Handle *desc,\r
- int level, int optname, void *optval,\r
- socklen_t * optlen)\r
-{\r
- int ret;\r
-\r
- ret = getsockopt (desc->fd, level, optname, optval, optlen);\r
+ */ \r
+int \r
+GNUNET_NETWORK_socket_getsockopt (const struct GNUNET_NETWORK_Handle *desc,
+ \rint level, int optname, void *optval,
+ \rsocklen_t * optlen) \r
+{
+ \rint ret;
+ \r\rret = getsockopt (desc->fd, level, optname, optval, optlen);
+ \r
#ifdef MINGW\r
- if (ret == 0 && level == SOL_SOCKET && optname == SO_ERROR)\r
- *((int *) optval) = GetErrnoFromWinsockError (*((int *) optval));\r
- else if (SOCKET_ERROR == ret)\r
- SetErrnoFromWinsockError (WSAGetLastError ());\r
-#endif\r
- return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
-}\r
-\r
+ if (ret == 0 && level == SOL_SOCKET && optname == SO_ERROR)
+ \r*((int *) optval) = GetErrnoFromWinsockError (*((int *) optval));
+ \r
+ else if (SOCKET_ERROR == ret)
+ \rSetErrnoFromWinsockError (WSAGetLastError ());
+ \r
+#endif /* \r */
+ return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
+\r}
+
+\r\r
/**\r
* Listen on a socket\r
* @param desc socket\r
* @param backlog length of the listen queue\r
* @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
- */\r
-int\r
-GNUNET_NETWORK_socket_listen (const struct GNUNET_NETWORK_Handle *desc,\r
- int backlog)\r
-{\r
- int ret;\r
-\r
- ret = listen (desc->fd, backlog);\r
+ */ \r
+int \r
+GNUNET_NETWORK_socket_listen (const struct GNUNET_NETWORK_Handle *desc,
+ \rint backlog) \r
+{
+ \rint ret;
+ \r\rret = listen (desc->fd, backlog);
+ \r
#ifdef MINGW\r
- if (SOCKET_ERROR == ret)\r
- SetErrnoFromWinsockError (WSAGetLastError ());\r
-#endif\r
-\r
- return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
-}\r
-\r
+ if (SOCKET_ERROR == ret)
+ \rSetErrnoFromWinsockError (WSAGetLastError ());
+ \r
+#endif /* \r */
+ \rreturn ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
+\r}
+
+\r\r
/**\r
* Read data from a connected socket (always non-blocking).\r
* @param desc socket\r
* @param buffer buffer\r
* @param length length of buffer\r
- */\r
-ssize_t\r
-GNUNET_NETWORK_socket_recv (const struct GNUNET_NETWORK_Handle * desc,\r
- void *buffer, size_t length)\r
-{\r
- int ret;\r
- int flags;\r
-\r
- flags = 0;\r
+ */ \r
+ ssize_t \r
+GNUNET_NETWORK_socket_recv (const struct GNUNET_NETWORK_Handle * desc,
+ \rvoid *buffer, size_t length) \r
+{
+ \rint ret;
+ \rint flags;
+ \r\rflags = 0;
+ \r
#ifdef MSG_DONTWAIT\r
- flags |= MSG_DONTWAIT;\r
-#endif\r
- ret = recv (desc->fd, buffer, length, flags);\r
+ flags |= MSG_DONTWAIT;
+ \r
+#endif /* \r */
+ ret = recv (desc->fd, buffer, length, flags);
+ \r
#ifdef MINGW\r
- if (SOCKET_ERROR == ret)\r
- SetErrnoFromWinsockError (WSAGetLastError ());\r
-#endif\r
-\r
- return ret;\r
-}\r
-\r
+ if (SOCKET_ERROR == ret)
+ \rSetErrnoFromWinsockError (WSAGetLastError ());
+ \r
+#endif /* \r */
+ \rreturn ret;
+\r}
+
+\r\r
/**\r
* Send data (always non-blocking).\r
*\r
* @param buffer data to send\r
* @param length size of the buffer\r
* @return number of bytes sent, GNUNET_SYSERR on error\r
- */\r
-ssize_t\r
-GNUNET_NETWORK_socket_send (const struct GNUNET_NETWORK_Handle * desc,\r
- const void *buffer, size_t length)\r
-{\r
- int ret;\r
- int flags;\r
-\r
- flags = 0;\r
+ */ \r
+ ssize_t \r
+GNUNET_NETWORK_socket_send (const struct GNUNET_NETWORK_Handle * desc,
+ \rconst void *buffer, size_t length) \r
+{
+ \rint ret;
+ \rint flags;
+ \r\rflags = 0;
+ \r
#ifdef MSG_DONTWAIT\r
- flags |= MSG_DONTWAIT;\r
-#endif\r
+ flags |= MSG_DONTWAIT;
+ \r
+#endif /* \r */
#ifdef MSG_NOSIGNAL\r
- flags |= MSG_NOSIGNAL;\r
-#endif\r
- ret = send (desc->fd, buffer, length, flags);\r
+ flags |= MSG_NOSIGNAL;
+ \r
+#endif /* \r */
+ ret = send (desc->fd, buffer, length, flags);
+ \r
#ifdef MINGW\r
- if (SOCKET_ERROR == ret)\r
- SetErrnoFromWinsockError (WSAGetLastError ());\r
-#endif\r
-\r
- return ret;\r
-}\r
-\r
-\r
+ if (SOCKET_ERROR == ret)
+ \rSetErrnoFromWinsockError (WSAGetLastError ());
+ \r
+#endif /* \r */
+ \rreturn ret;
+\r}
+
+\r\r\r
/**\r
* Send data to a particular destination (always non-blocking).\r
* This function only works for UDP sockets.\r
* @param dest_addr destination address\r
* @param dest_len length of address\r
* @return number of bytes sent, GNUNET_SYSERR on error\r
- */\r
-ssize_t\r
-GNUNET_NETWORK_socket_sendto (const struct GNUNET_NETWORK_Handle * desc,\r
- const void *message, size_t length,\r
- const struct sockaddr * dest_addr,\r
- socklen_t dest_len)\r
-{\r
- int ret;\r
- int flags;\r
-\r
- flags = 0;\r
+ */ \r
+ ssize_t \r
+GNUNET_NETWORK_socket_sendto (const struct GNUNET_NETWORK_Handle * desc,
+ \rconst void *message, size_t length,
+ \rconst struct sockaddr * dest_addr,
+ \rsocklen_t dest_len) \r
+{
+ \rint ret;
+ \rint flags;
+ \r\rflags = 0;
+ \r
#ifdef MSG_DONTWAIT\r
- flags |= MSG_DONTWAIT;\r
-#endif\r
+ flags |= MSG_DONTWAIT;
+ \r
+#endif /* \r */
#ifdef MSG_NOSIGNAL\r
- flags |= MSG_NOSIGNAL;\r
-#endif\r
- ret = sendto (desc->fd, message, length, flags, dest_addr, dest_len);\r
+ flags |= MSG_NOSIGNAL;
+ \r
+#endif /* \r */
+ ret = sendto (desc->fd, message, length, flags, dest_addr, dest_len);
+ \r
#ifdef MINGW\r
- if (SOCKET_ERROR == ret)\r
- SetErrnoFromWinsockError (WSAGetLastError ());\r
-#endif\r
-\r
- return ret;\r
-}\r
-\r
+ if (SOCKET_ERROR == ret)
+ \rSetErrnoFromWinsockError (WSAGetLastError ());
+ \r
+#endif /* \r */
+ \rreturn ret;
+\r}
+
+\r\r
/**\r
* Set socket option\r
* @param fd socket\r
* @param option_value value to set\r
* @param option_len size of option_value\r
* @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
- */\r
-int\r
-GNUNET_NETWORK_socket_setsockopt (struct GNUNET_NETWORK_Handle *fd,\r
- int level, int option_name,\r
- const void *option_value,\r
- socklen_t option_len)\r
-{\r
- int ret;\r
-\r
- ret = setsockopt (fd->fd, level, option_name, option_value, option_len);\r
+ */ \r
+int \r
+GNUNET_NETWORK_socket_setsockopt (struct GNUNET_NETWORK_Handle *fd,
+ \rint level, int option_name,
+ \rconst void *option_value,
+ \rsocklen_t option_len) \r
+{
+ \rint ret;
+ \r\rret = setsockopt (fd->fd, level, option_name, option_value, option_len);
+ \r
#ifdef MINGW\r
- if (SOCKET_ERROR == ret)\r
- SetErrnoFromWinsockError (WSAGetLastError ());\r
-#endif\r
-\r
- return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
-}\r
-\r
-\r
-\r
+ if (SOCKET_ERROR == ret)
+ \rSetErrnoFromWinsockError (WSAGetLastError ());
+ \r
+#endif /* \r */
+ \rreturn ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
+\r}
+
+\r\r\r\r
/**\r
* Create a new socket. Configure it for non-blocking IO and\r
* mark it as non-inheritable to child processes (set the\r
* @param type socket type\r
* @param protocol network protocol\r
* @return new socket, NULL on error\r
- */\r
+ */ \r
struct GNUNET_NETWORK_Handle *\r
-GNUNET_NETWORK_socket_create (int domain, int type, int protocol)\r
-{\r
- struct GNUNET_NETWORK_Handle *ret;\r
-\r
- ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle));\r
- ret->fd = socket (domain, type, protocol);\r
- if (INVALID_SOCKET == ret->fd)\r
- {\r
+GNUNET_NETWORK_socket_create (int domain, int type, int protocol) \r
+{
+ \rstruct GNUNET_NETWORK_Handle *ret;
+ \r\rret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle));
+ \rret->fd = socket (domain, type, protocol);
+ \rif (INVALID_SOCKET == ret->fd)
+ \r
+ {
+ \r
#ifdef MINGW\r
- SetErrnoFromWinsockError (WSAGetLastError ());\r
-#endif\r
- GNUNET_free (ret);\r
- return NULL;\r
- }\r
+ SetErrnoFromWinsockError (WSAGetLastError ());
+ \r
+#endif /* \r */
+ GNUNET_free (ret);
+ \rreturn NULL;
+ \r}
+ \r
#ifndef MINGW\r
- if (ret->fd >= FD_SETSIZE)\r
- {\r
- GNUNET_break (0 == close (ret->fd));\r
- GNUNET_free (ret);\r
- errno = EMFILE;\r
- return NULL;\r
- }\r
-#endif\r
-\r
- if (GNUNET_SYSERR == socket_set_blocking (ret, GNUNET_NO))\r
- {\r
- /* we might want to treat this one as fatal... */\r
- GNUNET_break (0);\r
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ret));\r
- return NULL; \r
- }\r
+ if (ret->fd >= FD_SETSIZE)
+ \r
+ {
+ \rGNUNET_break (0 == close (ret->fd));
+ \rGNUNET_free (ret);
+ \rerrno = EMFILE;
+ \rreturn NULL;
+ \r}
+ \r
+#endif /* \r */
+ \rif (GNUNET_SYSERR == socket_set_blocking (ret, GNUNET_NO))
+ \r
+ {
+ \r
+ /* we might want to treat this one as fatal... */ \r
+ GNUNET_break (0);
+ \rGNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ret));
+ \rreturn NULL;
+ \r}
+ \r
#ifndef MINGW\r
- if (GNUNET_OK != socket_set_inheritable (ret))\r
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,\r
- "socket_set_inheritable");\r
-#endif\r
+ if (GNUNET_OK != socket_set_inheritable (ret))
+ \rGNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+ \r"socket_set_inheritable");
+ \r
+#endif /* \r */
#ifdef DARWIN\r
- socket_set_nosigpipe (ret); \r
-#endif\r
- if (type == SOCK_STREAM)\r
- socket_set_nodelay (ret);\r
-\r
- return ret;\r
-}\r
-\r
+ socket_set_nosigpipe (ret);
+ \r
+#endif /* \r */
+ if (type == SOCK_STREAM)
+ \rsocket_set_nodelay (ret);
+ \r\rreturn ret;
+\r}
+
+\r\r
/**\r
* Shut down socket operations\r
* @param desc socket\r
* @param how type of shutdown\r
* @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
- */\r
-int\r
-GNUNET_NETWORK_socket_shutdown (struct GNUNET_NETWORK_Handle *desc,\r
- int how)\r
-{\r
- int ret;\r
-\r
- ret = shutdown (desc->fd, how);\r
+ */ \r
+int \r
+GNUNET_NETWORK_socket_shutdown (struct GNUNET_NETWORK_Handle *desc,
+ \rint how) \r
+{
+ \rint ret;
+ \r\rret = shutdown (desc->fd, how);
+ \r
#ifdef MINGW\r
- if (ret != 0)\r
- SetErrnoFromWinsockError (WSAGetLastError ());\r
-#endif\r
-\r
- return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
-}\r
-\r
-\r
+ if (ret != 0)
+ \rSetErrnoFromWinsockError (WSAGetLastError ());
+ \r
+#endif /* \r */
+ \rreturn ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
+\r}
+
+\r\r\r
/**\r
* Reset FD set\r
* @param fds fd set\r
- */\r
-void\r
-GNUNET_NETWORK_fdset_zero (struct GNUNET_NETWORK_FDSet *fds)\r
-{\r
- FD_ZERO (&fds->sds);\r
- fds->nsds = 0;\r
+ */ \r
+void \r
+GNUNET_NETWORK_fdset_zero (struct GNUNET_NETWORK_FDSet *fds) \r
+{
+ \rFD_ZERO (&fds->sds);
+ \rfds->nsds = 0;
+ \r
#ifdef MINGW\r
- GNUNET_CONTAINER_slist_clear (fds->handles);\r
-#endif\r
-}\r
-\r
-\r
+ GNUNET_CONTAINER_slist_clear (fds->handles);
+ \r
+#endif /* \r */
+} \r\r\r
+
/**\r
* Add a socket to the FD set\r
* @param fds fd set\r
* @param desc socket to add\r
- */\r
-void\r
-GNUNET_NETWORK_fdset_set (struct GNUNET_NETWORK_FDSet *fds,\r
- const struct GNUNET_NETWORK_Handle *desc)\r
-{\r
- FD_SET (desc->fd, &fds->sds);\r
-\r
- if (desc->fd + 1 > fds->nsds)\r
- fds->nsds = desc->fd + 1;\r
-}\r
-\r
-\r
+ */ \r
+void \r
+GNUNET_NETWORK_fdset_set (struct GNUNET_NETWORK_FDSet *fds,
+ \rconst struct GNUNET_NETWORK_Handle *desc) \r
+{
+ \rFD_SET (desc->fd, &fds->sds);
+ \r\rif (desc->fd + 1 > fds->nsds)
+ \rfds->nsds = desc->fd + 1;
+\r}
+
+\r\r\r
/**\r
* Check whether a socket is part of the fd set\r
* @param fds fd set\r
* @param desc socket\r
* @return 0 if the FD is not set\r
- */\r
-int\r
-GNUNET_NETWORK_fdset_isset (const struct GNUNET_NETWORK_FDSet *fds,\r
- const struct GNUNET_NETWORK_Handle *desc)\r
-{\r
- return FD_ISSET (desc->fd, &fds->sds);\r
-}\r
-\r
-\r
+ */ \r
+int \r
+GNUNET_NETWORK_fdset_isset (const struct GNUNET_NETWORK_FDSet *fds,
+ \rconst struct GNUNET_NETWORK_Handle *desc) \r
+{
+ \rreturn FD_ISSET (desc->fd, &fds->sds);
+\r}
+
+\r\r\r
/**\r
* Add one fd set to another\r
* @param dst the fd set to add to\r
* @param src the fd set to add from\r
- */\r
-void\r
-GNUNET_NETWORK_fdset_add (struct GNUNET_NETWORK_FDSet *dst,\r
- const struct GNUNET_NETWORK_FDSet *src)\r
-{\r
- int nfds;\r
-\r
- for (nfds = src->nsds; nfds > 0; nfds--)\r
- if (FD_ISSET (nfds, &src->sds))\r
- {\r
- FD_SET (nfds, &dst->sds);\r
- if (nfds + 1 > dst->nsds)\r
- dst->nsds = nfds + 1;\r
- }\r
-}\r
-\r
-\r
+ */ \r
+void \r
+GNUNET_NETWORK_fdset_add (struct GNUNET_NETWORK_FDSet *dst,
+ \rconst struct GNUNET_NETWORK_FDSet *src) \r
+{
+ \rint nfds;
+ \r\rfor (nfds = src->nsds; nfds > 0; nfds--)
+ \rif (FD_ISSET (nfds, &src->sds))
+ \r
+ {
+ \rFD_SET (nfds, &dst->sds);
+ \rif (nfds + 1 > dst->nsds)
+ \rdst->nsds = nfds + 1;
+ \r}
+\r}
+
+\r\r\r
/**\r
* Copy one fd set to another\r
* @param to destination\r
* @param from source\r
- */\r
-void\r
-GNUNET_NETWORK_fdset_copy (struct GNUNET_NETWORK_FDSet *to,\r
- const struct GNUNET_NETWORK_FDSet *from)\r
-{\r
- FD_COPY (&from->sds, &to->sds);\r
- to->nsds = from->nsds;\r
+ */ \r
+void \r
+GNUNET_NETWORK_fdset_copy (struct GNUNET_NETWORK_FDSet *to,
+ \rconst struct GNUNET_NETWORK_FDSet *from) \r
+{
+ \rFD_COPY (&from->sds, &to->sds);
+ \rto->nsds = from->nsds;
+ \r
#ifdef MINGW\r
- struct GNUNET_CONTAINER_SList_Iterator *iter;\r
-\r
-\r
- GNUNET_CONTAINER_slist_clear (to->handles);\r
-\r
- for (iter = GNUNET_CONTAINER_slist_begin (from->handles);\r
- GNUNET_CONTAINER_slist_end (iter) != GNUNET_YES; GNUNET_CONTAINER_slist_next (iter))\r
- {\r
- void *handle;\r
- size_t len;\r
-\r
- handle = GNUNET_CONTAINER_slist_get (iter, &len);\r
- GNUNET_CONTAINER_slist_add (to->handles, GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT, handle, len);\r
- }\r
-#endif\r
-}\r
-\r
-\r
+ struct GNUNET_CONTAINER_SList_Iterator *iter;
+ \r\r\rGNUNET_CONTAINER_slist_clear (to->handles);
+ \r\rfor (iter = GNUNET_CONTAINER_slist_begin (from->handles);
+ \rGNUNET_CONTAINER_slist_end (iter) != GNUNET_YES;
+ GNUNET_CONTAINER_slist_next (iter))
+ \r
+ {
+ \rvoid *handle;
+ \rsize_t len;
+ \r\rhandle = GNUNET_CONTAINER_slist_get (iter, &len);
+ \rGNUNET_CONTAINER_slist_add (to->handles,
+ GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+ handle, len);
+ \r} \r
+#endif /* \r */
+} \r\r\r
+
/**\r
* Copy a native fd set\r
* @param to destination\r
* @param from native source set\r
* @param nfds the biggest socket number in from + 1\r
- */\r
-void\r
-GNUNET_NETWORK_fdset_copy_native (struct GNUNET_NETWORK_FDSet *to,\r
- const fd_set * from, int nfds)\r
-{\r
- FD_COPY (from, &to->sds);\r
- to->nsds = nfds;\r
-}\r
-\r
-\r
+ */ \r
+void \r
+GNUNET_NETWORK_fdset_copy_native (struct GNUNET_NETWORK_FDSet *to,
+ \rconst fd_set * from, int nfds) \r
+{
+ \rFD_COPY (from, &to->sds);
+ \rto->nsds = nfds;
+\r} \r\r\r
+
/**\r
* Add a file handle to the fd set\r
* @param fds fd set\r
* @param h the file handle to add\r
- */\r
-void\r
-GNUNET_NETWORK_fdset_handle_set (struct GNUNET_NETWORK_FDSet *fds,\r
- const struct GNUNET_DISK_FileHandle *h)\r
-{\r
+ */ \r
+void \r
+GNUNET_NETWORK_fdset_handle_set (struct GNUNET_NETWORK_FDSet *fds,
+ \rconst struct GNUNET_DISK_FileHandle *h) \r
+{
+ \r
#ifdef MINGW\r
- HANDLE hw;\r
-\r
- GNUNET_DISK_internal_file_handle_ (h, &hw, sizeof (HANDLE));\r
- GNUNET_CONTAINER_slist_add (fds->handles, GNUNET_NO, &hw, sizeof (HANDLE));\r
-#else\r
- int fd;\r
-\r
- GNUNET_DISK_internal_file_handle_ (h, &fd, sizeof (int));\r
- FD_SET (fd, &fds->sds);\r
- if (fd + 1 > fds->nsds)\r
- fds->nsds = fd + 1;\r
-#endif\r
-}\r
-\r
+ HANDLE hw;
+ \r\rGNUNET_DISK_internal_file_handle_ (h, &hw, sizeof (HANDLE));
+ \rGNUNET_CONTAINER_slist_add (fds->handles, GNUNET_NO, &hw, sizeof (HANDLE));
+ \r
+#else /* \r */
+ int fd;
+ \r\rGNUNET_DISK_internal_file_handle_ (h, &fd, sizeof (int));
+ \rFD_SET (fd, &fds->sds);
+ \rif (fd + 1 > fds->nsds)
+ \rfds->nsds = fd + 1;
+ \r
+#endif /* \r */
+}
+
+\r\r
/**\r
* Check if a file handle is part of an fd set\r
* @param fds fd set\r
* @param h file handle\r
* @return GNUNET_YES if the file handle is part of the set\r
- */\r
-int\r
-GNUNET_NETWORK_fdset_handle_isset (const struct GNUNET_NETWORK_FDSet *fds,\r
- const struct GNUNET_DISK_FileHandle *h)\r
-{\r
+ */ \r
+int \r
+GNUNET_NETWORK_fdset_handle_isset (const struct GNUNET_NETWORK_FDSet *fds,
+ \rconst struct GNUNET_DISK_FileHandle *h) \r
+{
+ \r
#ifdef MINGW\r
- return GNUNET_CONTAINER_slist_contains (fds->handles, h->h, sizeof (HANDLE));\r
-#else\r
- return FD_ISSET (h->fd, &fds->sds);\r
-#endif\r
-}\r
-\r
+ return GNUNET_CONTAINER_slist_contains (fds->handles, h->h,
+ sizeof (HANDLE));
+ \r
+#else /* \r */
+ return FD_ISSET (h->fd, &fds->sds);
+ \r
+#endif /* \r */
+}
+
+\r\r
/**\r
* Checks if two fd sets overlap\r
* @param fds1 first fd set\r
* @param fds2 second fd set\r
* @return GNUNET_YES if they do overlap, GNUNET_NO otherwise\r
- */\r
-int\r
-GNUNET_NETWORK_fdset_overlap (const struct GNUNET_NETWORK_FDSet *fds1,\r
- const struct GNUNET_NETWORK_FDSet *fds2)\r
-{\r
- int nfds;\r
-\r
- nfds = fds1->nsds;\r
- if (nfds < fds2->nsds)\r
- nfds = fds2->nsds;\r
-\r
- for (; nfds >= 0; nfds--)\r
- if (FD_ISSET (nfds, &fds1->sds) && FD_ISSET (nfds, &fds2->sds))\r
- return GNUNET_YES;\r
-\r
- return GNUNET_NO;\r
-}\r
-\r
+ */ \r
+int \r
+GNUNET_NETWORK_fdset_overlap (const struct GNUNET_NETWORK_FDSet *fds1,
+ \rconst struct GNUNET_NETWORK_FDSet *fds2) \r
+{
+ \rint nfds;
+ \r\rnfds = fds1->nsds;
+ \rif (nfds < fds2->nsds)
+ \rnfds = fds2->nsds;
+ \r\rfor (; nfds >= 0; nfds--)
+ \rif (FD_ISSET (nfds, &fds1->sds) && FD_ISSET (nfds, &fds2->sds))
+ \rreturn GNUNET_YES;
+ \r\rreturn GNUNET_NO;
+\r}
+
+\r\r
/**\r
* Creates an fd set\r
* @return a new fd set\r
- */\r
+ */ \r
struct GNUNET_NETWORK_FDSet *\r
-GNUNET_NETWORK_fdset_create ()\r
-{\r
- struct GNUNET_NETWORK_FDSet *fds;\r
-\r
- fds = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_FDSet));\r
+GNUNET_NETWORK_fdset_create () \r
+{
+ \rstruct GNUNET_NETWORK_FDSet *fds;
+ \r\rfds = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_FDSet));
+ \r
#ifdef MINGW\r
- fds->handles = GNUNET_CONTAINER_slist_create ();\r
-#endif\r
- GNUNET_NETWORK_fdset_zero (fds);\r
- return fds;\r
-}\r
-\r
-\r
+ fds->handles = GNUNET_CONTAINER_slist_create ();
+ \r
+#endif /* \r */
+ GNUNET_NETWORK_fdset_zero (fds);
+ \rreturn fds;
+\r}
+
+\r\r\r
/**\r
* Releases the associated memory of an fd set\r
* @param fds fd set\r
- */\r
-void\r
-GNUNET_NETWORK_fdset_destroy (struct GNUNET_NETWORK_FDSet *fds)\r
-{\r
+ */ \r
+void \r
+GNUNET_NETWORK_fdset_destroy (struct GNUNET_NETWORK_FDSet *fds) \r
+{
+ \r
#ifdef MINGW\r
- GNUNET_CONTAINER_slist_destroy (fds->handles);\r
-#endif\r
- GNUNET_free (fds);\r
-}\r
-\r
-\r
+ GNUNET_CONTAINER_slist_destroy (fds->handles);
+ \r
+#endif /* \r */
+ GNUNET_free (fds);
+\r} \r\r\r
+
/**\r
* Check if sockets meet certain conditions\r
* @param rfds set of sockets to be checked for readability\r
* @param efds set of sockets to be checked for exceptions\r
* @param timeout relative value when to return\r
* @return number of selected sockets, GNUNET_SYSERR on error\r
- */\r
-int\r
-GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,\r
- struct GNUNET_NETWORK_FDSet *wfds,\r
- struct GNUNET_NETWORK_FDSet *efds,\r
- const struct GNUNET_TIME_Relative timeout)\r
-{\r
- int nfds;\r
-\r
- nfds = 0;\r
- if (NULL != rfds)\r
- nfds = rfds->nsds;\r
- if (NULL != wfds)\r
- nfds = GNUNET_MAX (nfds, wfds->nsds);\r
- if (NULL != efds)\r
- nfds = GNUNET_MAX (nfds, efds->nsds);\r
-\r
+ */ \r
+int \r
+GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
+ \rstruct GNUNET_NETWORK_FDSet *wfds,
+ \rstruct GNUNET_NETWORK_FDSet *efds,
+ \rconst struct GNUNET_TIME_Relative timeout) \r
+{
+ \rint nfds;
+ \r\rnfds = 0;
+ \rif (NULL != rfds)
+ \rnfds = rfds->nsds;
+ \rif (NULL != wfds)
+ \rnfds = GNUNET_MAX (nfds, wfds->nsds);
+ \rif (NULL != efds)
+ \rnfds = GNUNET_MAX (nfds, efds->nsds);
+ \r\r
#ifndef MINGW\r
- struct timeval tv;\r
-\r
- tv.tv_sec = timeout.value / GNUNET_TIME_UNIT_SECONDS.value;\r
- tv.tv_usec = 1000 * (timeout.value - (tv.tv_sec * GNUNET_TIME_UNIT_SECONDS.value));\r
- if ( (nfds == 0) &&\r
- (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value) )\r
- {\r
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,\r
- _("Fatal internal logic error, process hangs in `%s' (abort with CTRL-C)!\n"),\r
- "select");\r
- GNUNET_break (0);\r
- }\r
- return select (nfds + 1, \r
- (rfds != NULL) ? &rfds->sds : NULL, \r
- (wfds != NULL) ? &wfds->sds : NULL,\r
- (efds != NULL) ? &efds->sds : NULL, \r
- (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value) \r
- ? NULL \r
- : &tv);\r
-#else\r
- DWORD limit;\r
- fd_set sock_read, sock_write, sock_except;\r
- fd_set aread, awrite, aexcept;\r
- int i;\r
- struct timeval tvslice;\r
- int retcode;\r
- DWORD ms_total;\r
-\r
+ struct timeval tv;
+ \r\rtv.tv_sec = timeout.value / GNUNET_TIME_UNIT_SECONDS.value;
+ \rtv.tv_usec =
+ 1000 * (timeout.value - (tv.tv_sec * GNUNET_TIME_UNIT_SECONDS.value));
+ \rif ((nfds == 0) && \r(timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value))
+ \r
+ {
+ \rGNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ \r_
+ ("Fatal internal logic error, process hangs in `%s' (abort with CTRL-C)!\n"),
+ \r"select");
+ \rGNUNET_break (0);
+ \r}
+ \rreturn select (nfds + 1, \r
+ (rfds != NULL) ? &rfds->sds : NULL, \r
+ (wfds != NULL) ? &wfds->sds : NULL, \r
+ (efds != NULL) ? &efds->sds : NULL, \r
+ (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value) \r
+ ? NULL \r : &tv);
+ \r
+#else /* \r */
+ DWORD limit;
+ \rfd_set sock_read, sock_write, sock_except;
+ \rfd_set aread, awrite, aexcept;
+ \rint i;
+ \rstruct timeval tvslice;
+ \rint retcode;
+ \rDWORD ms_total;
+ \r\r
#define SAFE_FD_ISSET(fd, set) (set != NULL && FD_ISSET(fd, set))\r
-\r
- /* calculate how long we need to wait in milliseconds */\r
- if (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value)\r
- ms_total = INFINITE;\r
- else\r
- ms_total = timeout.value / GNUNET_TIME_UNIT_MILLISECONDS.value;\r
-\r
- /* select() may be used as a portable way to sleep */\r
- if (!(rfds || wfds || efds))\r
- {\r
- Sleep (ms_total);\r
- return 0;\r
- }\r
-\r
- if (rfds)\r
- sock_read = rfds->sds;\r
- else\r
- FD_ZERO(&sock_read);\r
-\r
- if (wfds)\r
- sock_write = wfds->sds;\r
- else\r
- FD_ZERO(&sock_write);\r
-\r
- if (efds)\r
- sock_except = efds->sds;\r
- else\r
- FD_ZERO(&sock_except);\r
-\r
- /* multiplex between winsock select() and waiting on the handles */\r
-\r
- FD_ZERO (&aread);\r
- FD_ZERO (&awrite);\r
- FD_ZERO (&aexcept);\r
-\r
- limit = GetTickCount () + ms_total;\r
- do\r
- {\r
- retcode = 0;\r
-\r
- if (nfds > 0)\r
- {\r
- /* overwrite the zero'd sets here; the select call\r
- * will clear those that are not active */\r
-\r
- FD_COPY (&sock_read, &aread);\r
- FD_COPY (&sock_write, &awrite);\r
- FD_COPY (&sock_except, &aexcept);\r
-\r
- tvslice.tv_sec = 0;\r
- tvslice.tv_usec = 100000;\r
-\r
- if ((retcode =\r
- select (nfds + 1, &aread, &awrite, &aexcept,\r
- &tvslice)) == SOCKET_ERROR)\r
- {\r
- SetErrnoFromWinsockError (WSAGetLastError ());\r
- if (errno == ENOTSOCK)\r
- errno = EBADF;\r
-\r
+ \r
+ /* calculate how long we need to wait in milliseconds */ \r
+ if (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value)
+ \rms_total = INFINITE;
+ \r
+ else
+ \rms_total = timeout.value / GNUNET_TIME_UNIT_MILLISECONDS.value;
+ \r\r
+ /* select() may be used as a portable way to sleep */ \r
+ if (!(rfds || wfds || efds))
+ \r
+ {
+ \rSleep (ms_total);
+ \rreturn 0;
+ \r}
+ \r\rif (rfds)
+ \rsock_read = rfds->sds;
+ \r
+ else
+ \rFD_ZERO (&sock_read);
+ \r\rif (wfds)
+ \rsock_write = wfds->sds;
+ \r
+ else
+ \rFD_ZERO (&sock_write);
+ \r\rif (efds)
+ \rsock_except = efds->sds;
+ \r
+ else
+ \rFD_ZERO (&sock_except);
+ \r\r
+ /* multiplex between winsock select() and waiting on the handles */ \r
+ \rFD_ZERO (&aread);
+ \rFD_ZERO (&awrite);
+ \rFD_ZERO (&aexcept);
+ \r\rlimit = GetTickCount () + ms_total;
+ \r
+ do
+ \r
+ {
+ \rretcode = 0;
+ \r\rif (nfds > 0)
+ \r
+ {
+ \r
+ /* overwrite the zero'd sets here; the select call\r
+ * will clear those that are not active */ \r
+ \rFD_COPY (&sock_read, &aread);
+ \rFD_COPY (&sock_write, &awrite);
+ \rFD_COPY (&sock_except, &aexcept);
+ \r\rtvslice.tv_sec = 0;
+ \rtvslice.tv_usec = 100000;
+ \r\rif ((retcode =
+ \rselect (nfds + 1, &aread, &awrite, &aexcept,
+ \r&tvslice)) == SOCKET_ERROR)
+ \r
+ {
+ \rSetErrnoFromWinsockError (WSAGetLastError ());
+ \rif (errno == ENOTSOCK)
+ \rerrno = EBADF;
+ \r\r
#if DEBUG_NETWORK\r
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "select");\r
-#endif\r
-\r
- goto select_loop_end;\r
- }\r
- }\r
-\r
- /* Poll read pipes */\r
- if (rfds)\r
- {\r
- struct GNUNET_CONTAINER_SList_Iterator *i;\r
- int on_next;\r
-\r
- on_next = GNUNET_NO;\r
- for (i = GNUNET_CONTAINER_slist_begin (rfds->handles);\r
- GNUNET_CONTAINER_slist_end (i) != GNUNET_YES;\r
- on_next || GNUNET_CONTAINER_slist_next (i))\r
- {\r
- HANDLE h;\r
- DWORD dwBytes;\r
-\r
- h = *(HANDLE *) GNUNET_CONTAINER_slist_get (i, NULL);\r
- on_next = GNUNET_NO;\r
-\r
- if (!PeekNamedPipe (h, NULL, 0, NULL, &dwBytes, NULL))\r
- {\r
- GNUNET_CONTAINER_slist_erase (i);\r
- on_next = GNUNET_YES;\r
-\r
- retcode = -1;\r
- SetErrnoFromWinError (GetLastError ());\r
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "select");
+ \r
+#endif /* \r */
+ \rgoto select_loop_end;
+ \r}
+ \r}
+ \r\r
+ /* Poll read pipes */ \r
+ if (rfds)
+ \r
+ {
+ \rstruct GNUNET_CONTAINER_SList_Iterator *i;
+ \rint on_next;
+ \r\ron_next = GNUNET_NO;
+ \rfor (i = GNUNET_CONTAINER_slist_begin (rfds->handles);
+ \rGNUNET_CONTAINER_slist_end (i) != GNUNET_YES;
+ \ron_next || GNUNET_CONTAINER_slist_next (i))
+ \r
+ {
+ \rHANDLE h;
+ \rDWORD dwBytes;
+ \r\rh = *(HANDLE *) GNUNET_CONTAINER_slist_get (i, NULL);
+ \ron_next = GNUNET_NO;
+ \r\rif (!PeekNamedPipe (h, NULL, 0, NULL, &dwBytes, NULL))
+ \r
+ {
+ \rGNUNET_CONTAINER_slist_erase (i);
+ \ron_next = GNUNET_YES;
+ \r\rretcode = -1;
+ \rSetErrnoFromWinError (GetLastError ());
+ \r
#if DEBUG_NETWORK\r
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "PeekNamedPipe");\r
-#endif\r
- goto select_loop_end;\r
- }\r
- else if (dwBytes)\r
- {\r
- retcode++;\r
- }\r
- else\r
- {\r
- GNUNET_CONTAINER_slist_erase (i);\r
- on_next = GNUNET_YES;\r
- }\r
- }\r
- }\r
-\r
- /* Poll for faulty pipes */\r
- if (efds)\r
- {\r
- struct GNUNET_CONTAINER_SList_Iterator *i;\r
- int on_next;\r
-\r
- on_next = GNUNET_NO;\r
- for (i = GNUNET_CONTAINER_slist_begin (efds->handles);\r
- GNUNET_CONTAINER_slist_end (i) != GNUNET_YES;\r
- on_next || GNUNET_CONTAINER_slist_next (i))\r
- {\r
- HANDLE h;\r
- DWORD dwBytes;\r
-\r
- h = *(HANDLE *) GNUNET_CONTAINER_slist_get (i, NULL);\r
-\r
- if (PeekNamedPipe (h, NULL, 0, NULL, &dwBytes, NULL))\r
- {\r
- GNUNET_CONTAINER_slist_erase (i);\r
- on_next = GNUNET_YES;\r
-\r
- retcode++;\r
- }\r
- else\r
- on_next = GNUNET_NO;\r
- }\r
- }\r
-\r
- /* FIXME */\r
- if (wfds)\r
- GNUNET_assert (GNUNET_CONTAINER_slist_count (wfds->handles) == 0);\r
-\r
- /* Check for closed sockets */\r
- for (i = 0; i < nfds; i++)\r
- {\r
- if (SAFE_FD_ISSET (i, &sock_read))\r
- {\r
- struct sockaddr addr;\r
- int len;\r
-\r
- if (getpeername (i, &addr, &len) == SOCKET_ERROR)\r
- {\r
- int err, len;\r
-\r
- len = sizeof (err);\r
- if (getsockopt\r
- (i, SOL_SOCKET, SO_ERROR, (char *) &err, &len) == 0\r
- && err == WSAENOTCONN)\r
- {\r
- if (!SAFE_FD_ISSET (i, &aread))\r
- {\r
- FD_SET (i, &aread);\r
- retcode++;\r
- }\r
- }\r
- }\r
- }\r
- }\r
-\r
- select_loop_end:;\r
- }\r
- while (retcode == 0 && (ms_total == INFINITE || GetTickCount () < limit));\r
-\r
- if (retcode != -1)\r
- {\r
- if (rfds)\r
- {\r
- GNUNET_NETWORK_fdset_zero (rfds);\r
- GNUNET_NETWORK_fdset_copy_native (rfds, &aread, retcode);\r
- }\r
-\r
- if (wfds)\r
- {\r
- GNUNET_NETWORK_fdset_zero (wfds);\r
- GNUNET_NETWORK_fdset_copy_native (wfds, &awrite, retcode);\r
- }\r
-\r
- if (efds)\r
- {\r
- GNUNET_NETWORK_fdset_zero (efds);\r
- GNUNET_NETWORK_fdset_copy_native (efds, &aexcept, retcode);\r
- }\r
- }\r
-\r
- return retcode;\r
-#endif\r
-}\r
-\r
-\r
-/* end of network.c */\r
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+ "PeekNamedPipe");
+ \r
+#endif /* \r */
+ goto select_loop_end;
+ \r}
+ \r
+ else if (dwBytes)
+ \r
+ {
+ \rretcode++;
+ \r}
+ \r
+ else
+ \r
+ {
+ \rGNUNET_CONTAINER_slist_erase (i);
+ \ron_next = GNUNET_YES;
+ \r}
+ \r}
+ \r}
+ \r\r
+ /* Poll for faulty pipes */ \r
+ if (efds)
+ \r
+ {
+ \rstruct GNUNET_CONTAINER_SList_Iterator *i;
+ \rint on_next;
+ \r\ron_next = GNUNET_NO;
+ \rfor (i = GNUNET_CONTAINER_slist_begin (efds->handles);
+ \rGNUNET_CONTAINER_slist_end (i) != GNUNET_YES;
+ \ron_next || GNUNET_CONTAINER_slist_next (i))
+ \r
+ {
+ \rHANDLE h;
+ \rDWORD dwBytes;
+ \r\rh = *(HANDLE *) GNUNET_CONTAINER_slist_get (i, NULL);
+ \r\rif (PeekNamedPipe (h, NULL, 0, NULL, &dwBytes, NULL))
+ \r
+ {
+ \rGNUNET_CONTAINER_slist_erase (i);
+ \ron_next = GNUNET_YES;
+ \r\rretcode++;
+ \r}
+ \r
+ else
+ \ron_next = GNUNET_NO;
+ \r}
+ \r}
+ \r\r
+ /* FIXME */ \r
+ if (wfds)
+ \rGNUNET_assert (GNUNET_CONTAINER_slist_count (wfds->handles) == 0);
+ \r\r
+ /* Check for closed sockets */ \r
+ for (i = 0; i < nfds; i++)
+ \r
+ {
+ \rif (SAFE_FD_ISSET (i, &sock_read))
+ \r
+ {
+ \rstruct sockaddr addr;
+ \rint len;
+ \r\rif (getpeername (i, &addr, &len) == SOCKET_ERROR)
+ \r
+ {
+ \rint err, len;
+ \r\rlen = sizeof (err);
+ \rif (getsockopt \r
+ (i, SOL_SOCKET, SO_ERROR, (char *) &err, &len) == 0 \r
+ &&err == WSAENOTCONN)
+ \r
+ {
+ \rif (!SAFE_FD_ISSET (i, &aread))
+ \r
+ {
+ \rFD_SET (i, &aread);
+ \rretcode++;
+ \r}
+ \r}
+ \r}
+ \r}
+ \r}
+ \r\rselect_loop_end:;
+ \r}
+ \rwhile (retcode == 0 && (ms_total == INFINITE || GetTickCount () < limit));
+ \r\rif (retcode != -1)
+ \r
+ {
+ \rif (rfds)
+ \r
+ {
+ \rGNUNET_NETWORK_fdset_zero (rfds);
+ \rGNUNET_NETWORK_fdset_copy_native (rfds, &aread, retcode);
+ \r}
+ \r\rif (wfds)
+ \r
+ {
+ \rGNUNET_NETWORK_fdset_zero (wfds);
+ \rGNUNET_NETWORK_fdset_copy_native (wfds, &awrite, retcode);
+ \r}
+ \r\rif (efds)
+ \r
+ {
+ \rGNUNET_NETWORK_fdset_zero (efds);
+ \rGNUNET_NETWORK_fdset_copy_native (efds, &aexcept, retcode);
+ \r}
+ \r}
+ \r\rreturn retcode;
+ \r
+#endif /* \r */
+}
+
+\r\r\r
+/* end of network.c */ \r
return ret;
/* other attempts here */
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Could not determine installation path for GNUnet. Set `%s' environment variable.\n"),
- "GNUNET_PREFIX");
+ _
+ ("Could not determine installation path for GNUnet. Set `%s' environment variable.\n"),
+ "GNUNET_PREFIX");
return NULL;
}
if (ret != 0)
{
if (ret == -1)
- {
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
- }
+ {
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
+ }
else
- {
+ {
#if HAVE_WORKING_VFORK
- /* let's hope vfork actually works; for some extreme cases (including
- a testcase) we need 'execvp' to have run before we return, since
- we may send a signal to the process next and we don't want it
- to be caught by OUR signal handler (but either by the default
- handler or the actual handler as installed by the process itself). */
+ /* let's hope vfork actually works; for some extreme cases (including
+ a testcase) we need 'execvp' to have run before we return, since
+ we may send a signal to the process next and we don't want it
+ to be caught by OUR signal handler (but either by the default
+ handler or the actual handler as installed by the process itself). */
#else
- /* let's give the child process a chance to run execvp, 1s should
- be plenty in practice */
- sleep (1);
+ /* let's give the child process a chance to run execvp, 1s should
+ be plenty in practice */
+ sleep (1);
#endif
- }
+ }
return ret;
}
argc = 0;
cmdlen = 0;
va_start (ap, filename);
while (NULL != (arg = va_arg (ap, char *)))
- cmdlen = cmdlen + strlen (arg) + 3;
+ cmdlen = cmdlen + strlen (arg) + 3;
va_end (ap);
- cmd = idx = GNUNET_malloc (sizeof(char) * cmdlen);
+ cmd = idx = GNUNET_malloc (sizeof (char) * cmdlen);
va_start (ap, filename);
while (NULL != (arg = va_arg (ap, char *)))
- idx += sprintf (idx, "\"%s\" ", arg);
+ idx += sprintf (idx, "\"%s\" ", arg);
va_end (ap);
- memset (&start, 0, sizeof(start));
- start.cb = sizeof(start);
+ memset (&start, 0, sizeof (start));
+ start.cb = sizeof (start);
- if (!CreateProcess (filename, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL,
- NULL, &start, &proc))
- {
- SetErrnoFromWinError (GetLastError ());
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
- return -1;
- }
+ if (!CreateProcess
+ (filename, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &start,
+ &proc))
+ {
+ SetErrnoFromWinError (GetLastError ());
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
+ return -1;
+ }
CloseHandle (proc.hProcess);
CloseHandle (proc.hThread);
- GNUNET_free(cmd);
+ GNUNET_free (cmd);
return proc.dwProcessId;
#endif
if (ret != 0)
{
if (ret == -1)
- {
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
- }
+ {
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
+ }
else
- {
+ {
#if HAVE_WORKING_VFORK
- /* let's hope vfork actually works; for some extreme cases (including
- a testcase) we need 'execvp' to have run before we return, since
- we may send a signal to the process next and we don't want it
- to be caught by OUR signal handler (but either by the default
- handler or the actual handler as installed by the process itself). */
+ /* let's hope vfork actually works; for some extreme cases (including
+ a testcase) we need 'execvp' to have run before we return, since
+ we may send a signal to the process next and we don't want it
+ to be caught by OUR signal handler (but either by the default
+ handler or the actual handler as installed by the process itself). */
#else
- /* let's give the child process a chance to run execvp, 1s should
- be plenty in practice */
- sleep (1);
+ /* let's give the child process a chance to run execvp, 1s should
+ be plenty in practice */
+ sleep (1);
#endif
- }
+ }
return ret;
}
execvp (filename, argv);
cmdlen = 0;
arg = argv;
while (*arg)
- {
- cmdlen = cmdlen + strlen (*arg) + 3;
- arg++;
- }
+ {
+ cmdlen = cmdlen + strlen (*arg) + 3;
+ arg++;
+ }
- cmd = idx = GNUNET_malloc (sizeof(char) * cmdlen);
+ cmd = idx = GNUNET_malloc (sizeof (char) * cmdlen);
arg = argv;
while (*arg)
- {
- idx += sprintf (idx, "\"%s\" ", *arg);
- arg++;
- }
-
- memset (&start, 0, sizeof(start));
- start.cb = sizeof(start);
-
- if (!CreateProcess (filename, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL,
- NULL, &start, &proc))
- {
- SetErrnoFromWinError (GetLastError ());
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
- return -1;
- }
+ {
+ idx += sprintf (idx, "\"%s\" ", *arg);
+ arg++;
+ }
+
+ memset (&start, 0, sizeof (start));
+ start.cb = sizeof (start);
+
+ if (!CreateProcess
+ (filename, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &start,
+ &proc))
+ {
+ SetErrnoFromWinError (GetLastError ());
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
+ return -1;
+ }
CloseHandle (proc.hProcess);
CloseHandle (proc.hThread);
- GNUNET_free(cmd);
+ GNUNET_free (cmd);
return proc.dwProcessId;
#endif
*/
int
GNUNET_OS_process_status (pid_t proc, enum GNUNET_OS_ProcessStatusType *type,
- unsigned long *code)
+ unsigned long *code)
{
#ifndef MINGW
int status;
GNUNET_assert (0 != proc);
ret = waitpid (proc, &status, WNOHANG);
- if (0 == ret)
+ if (0 == ret)
{
*type = GNUNET_OS_PROCESS_RUNNING;
*code = 0;
return GNUNET_SYSERR;
}
if (WIFEXITED (status))
- {
- *type = GNUNET_OS_PROCESS_EXITED;
- *code = WEXITSTATUS (status);
- }
+ {
+ *type = GNUNET_OS_PROCESS_EXITED;
+ *code = WEXITSTATUS (status);
+ }
else if (WIFSIGNALED (status))
- {
- *type = GNUNET_OS_PROCESS_SIGNALED;
- *code = WTERMSIG (status);
- }
+ {
+ *type = GNUNET_OS_PROCESS_SIGNALED;
+ *code = WTERMSIG (status);
+ }
else if (WIFSTOPPED (status))
- {
- *type = GNUNET_OS_PROCESS_SIGNALED;
- *code = WSTOPSIG (status);
- }
+ {
+ *type = GNUNET_OS_PROCESS_SIGNALED;
+ *code = WSTOPSIG (status);
+ }
else if (WIFCONTINUED (status))
- {
- *type = GNUNET_OS_PROCESS_RUNNING;
- *code = 0;
- }
+ {
+ *type = GNUNET_OS_PROCESS_RUNNING;
+ *code = 0;
+ }
else
- {
- *type = GNUNET_OS_PROCESS_UNKNOWN;
- *code = 0;
- }
+ {
+ *type = GNUNET_OS_PROCESS_UNKNOWN;
+ *code = 0;
+ }
#else
HANDLE h;
DWORD c;
h = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, proc);
if (INVALID_HANDLE_VALUE == h)
- {
- SetErrnoFromWinError (GetLastError ());
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "OpenProcess");
- return GNUNET_SYSERR;
- }
+ {
+ SetErrnoFromWinError (GetLastError ());
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "OpenProcess");
+ return GNUNET_SYSERR;
+ }
c = GetExitCodeProcess (proc, &c);
if (STILL_ACTIVE == c)
- {
- *type = GNUNET_OS_PROCESS_RUNNING;
- *code = 0;
- CloseHandle (h);
- return GNUNET_NO;
- }
+ {
+ *type = GNUNET_OS_PROCESS_RUNNING;
+ *code = 0;
+ CloseHandle (h);
+ return GNUNET_NO;
+ }
*type = GNUNET_OS_PROCESS_EXITED;
*code = c;
CloseHandle (h);
h = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, proc);
if (INVALID_HANDLE_VALUE == h)
- {
- SetErrnoFromWinError (GetLastError ());
- return GNUNET_SYSERR;
- }
+ {
+ SetErrnoFromWinError (GetLastError ());
+ return GNUNET_SYSERR;
+ }
if (WAIT_OBJECT_0 != WaitForSingleObject (h, INFINITE))
- {
- SetErrnoFromWinError (GetLastError ());
- ret = GNUNET_SYSERR;
- }
+ {
+ SetErrnoFromWinError (GetLastError ());
+ ret = GNUNET_SYSERR;
+ }
else
ret = GNUNET_OK;
* @return the interned identity.
*/
GNUNET_PEER_Id
-GNUNET_PEER_intern (const struct GNUNET_PeerIdentity * pid)
+GNUNET_PEER_intern (const struct GNUNET_PeerIdentity *pid)
{
GNUNET_PEER_Id ret;
struct PeerEntry *e;
return 0;
if (NULL == map)
map = GNUNET_CONTAINER_multihashmap_create (32);
- e = GNUNET_CONTAINER_multihashmap_get (map,
- &pid->hashPubKey);
+ e = GNUNET_CONTAINER_multihashmap_get (map, &pid->hashPubKey);
if (e != NULL)
{
GNUNET_assert (e->rc > 0);
if (ret == size)
{
GNUNET_array_grow (table, size, size + 16);
- for (i=ret;i<size;i++)
- table[i].pid = i + 1;
+ for (i = ret; i < size; i++)
+ table[i].pid = i + 1;
}
if (ret == 0)
{
table[ret].rc = 1;
table[ret].pid = ret;
GNUNET_CONTAINER_multihashmap_put (map,
- &pid->hashPubKey,
- &table[ret],
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+ &pid->hashPubKey,
+ &table[ret],
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
return ret;
}
* @param count size of the ids array
*/
void
-GNUNET_PEER_decrement_rcs (const GNUNET_PEER_Id * ids,
- unsigned int count)
+GNUNET_PEER_decrement_rcs (const GNUNET_PEER_Id * ids, unsigned int count)
{
int i;
GNUNET_PEER_Id id;
GNUNET_assert (table[id].rc > 0);
table[id].rc--;
if (table[id].rc == 0)
- {
- GNUNET_CONTAINER_multihashmap_remove (map,
- &table[id].id.hashPubKey,
- &table[id]);
- table[id].pid = free_list_start;
- free_list_start = id;
- }
+ {
+ GNUNET_CONTAINER_multihashmap_remove (map,
+ &table[id].id.hashPubKey,
+ &table[id]);
+ table[id].pid = free_list_start;
+ free_list_start = id;
+ }
}
}
if (table[id].rc == 0)
{
GNUNET_CONTAINER_multihashmap_remove (map,
- &table[id].id.hashPubKey,
- &table[id]);
+ &table[id].id.hashPubKey,
+ &table[id]);
table[id].pid = free_list_start;
free_list_start = id;
}
* @param pid where to write the normal peer identity
*/
void
-GNUNET_PEER_resolve (GNUNET_PEER_Id id,
- struct GNUNET_PeerIdentity * pid)
+GNUNET_PEER_resolve (GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
{
if (id == 0)
{
start = GNUNET_TIME_absolute_get ();
perfHash ();
printf ("Hash perf took %llu ms\n",
- (unsigned long long) GNUNET_TIME_absolute_get_duration (start).value);
+ (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+ value);
return 0;
}
* @param a2 second command line option
*/
static int
-cmd_sorter (const void *a1, const void *a2)
+cmd_sorter (__const void *a1, __const void *a2)
{
- const struct GNUNET_GETOPT_CommandLineOption *c1 = a1;
- const struct GNUNET_GETOPT_CommandLineOption *c2 = a2;
+ __const struct GNUNET_GETOPT_CommandLineOption *c1 = a1;
+ __const struct GNUNET_GETOPT_CommandLineOption *c2 = a2;
if (toupper (c1->shortName) > toupper (c2->shortName))
return 1;
if (toupper (c1->shortName) < toupper (c2->shortName))
qsort (allopts, cnt, sizeof (struct GNUNET_GETOPT_CommandLineOption),
&cmd_sorter);
loglev = GNUNET_strdup ("WARNING");
- if ((-1 == (ret = GNUNET_GETOPT_run (binaryName,
+ if ((-1 == (ret = GNUNET_GETOPT_run (binaryName,
allopts,
(unsigned int) argc, argv))) ||
((GNUNET_OK !=
tag += off;
}
buf = GNUNET_malloc (tag);
- ((int32_t *) buf)[0] = htonl (ranking); /* ranking */
+ ((int32_t *) buf)[0] = htonl (ranking); /* ranking */
if (ns_name != NULL)
{
memcpy (&buf[sizeof (int32_t)], ns_name, off + 1);
GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL));
GNUNET_break
(tag == GNUNET_DISK_fn_write (fn, buf, tag, GNUNET_DISK_PERM_USER_READ
- | GNUNET_DISK_PERM_USER_WRITE | GNUNET_DISK_PERM_GROUP_READ));
+ | GNUNET_DISK_PERM_USER_WRITE |
+ GNUNET_DISK_PERM_GROUP_READ));
GNUNET_free (fn);
GNUNET_free (buf);
/* create entry for pseudonym name in names */
if (0 == STAT (fn, &sbuf))
GNUNET_DISK_file_size (fn, &len, GNUNET_YES);
fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_CREATE
- | GNUNET_DISK_OPEN_READWRITE, GNUNET_DISK_PERM_USER_READ
- | GNUNET_DISK_PERM_USER_WRITE);
+ | GNUNET_DISK_OPEN_READWRITE,
+ GNUNET_DISK_PERM_USER_READ |
+ GNUNET_DISK_PERM_USER_WRITE);
i = 0;
idx = -1;
while ((len >= sizeof (GNUNET_HashCode)) &&
return GNUNET_SYSERR;
}
fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_CREATE
- | GNUNET_DISK_OPEN_READWRITE, GNUNET_DISK_PERM_USER_READ
- | GNUNET_DISK_PERM_USER_WRITE);
+ | GNUNET_DISK_OPEN_READWRITE,
+ GNUNET_DISK_PERM_USER_READ |
+ GNUNET_DISK_PERM_USER_WRITE);
GNUNET_free (fn);
- GNUNET_DISK_file_seek (fh, idx * sizeof (GNUNET_HashCode), GNUNET_DISK_SEEK_SET);
- if (sizeof (GNUNET_HashCode) != GNUNET_DISK_file_read (fh, nsid, sizeof (GNUNET_HashCode)))
+ GNUNET_DISK_file_seek (fh, idx * sizeof (GNUNET_HashCode),
+ GNUNET_DISK_SEEK_SET);
+ if (sizeof (GNUNET_HashCode) !=
+ GNUNET_DISK_file_read (fh, nsid, sizeof (GNUNET_HashCode)))
{
GNUNET_DISK_file_close (fh);
return GNUNET_SYSERR;
* FIXME
*/
GNUNET_PSEUDONYM_Iterator iterator;
-
+
/**
* FIXME
*/
void *closure;
-
+
/**
* FIXME
*/
* @param data value of entry to insert
*/
static int
-merge_meta_helper (void *cls,
- EXTRACTOR_KeywordType type,
- const char *data)
+merge_meta_helper (void *cls, EXTRACTOR_KeywordType type, const char *data)
{
struct GNUNET_CONTAINER_MetaData *meta = cls;
GNUNET_CONTAINER_meta_data_insert (meta, type, data);
/**
* Desired address family.
- */
+ */
int domain;
/**
struct sockaddr_in v4;
struct sockaddr_in6 v6;
- memset (&v4, 0, sizeof(v4));
- v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+ memset (&v4, 0, sizeof (v4));
+ v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
v4.sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
- v4.sin_len = sizeof(v4);
+ v4.sin_len = sizeof (v4);
#endif
- memset (&v6, 0, sizeof(v6));
+ memset (&v6, 0, sizeof (v6));
v6.sin6_family = AF_INET6;
#if HAVE_SOCKADDR_IN_SIN_LEN
- v6.sin6_len = sizeof(v6);
+ v6.sin6_len = sizeof (v6);
#endif
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (cfg,
- "resolver",
- "HOSTNAME",
- &hostname))
+ "resolver",
+ "HOSTNAME", &hostname))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Must specify `%s' for `%s' in configuration!\n"),
- "HOSTNAME",
- "resolver");
+ _("Must specify `%s' for `%s' in configuration!\n"),
+ "HOSTNAME", "resolver");
GNUNET_assert (0);
}
- if ( (1 != inet_pton (AF_INET,
- hostname,
- &v4)) ||
- (1 != inet_pton (AF_INET6,
- hostname,
- &v6)) )
+ if ((1 != inet_pton (AF_INET,
+ hostname,
+ &v4)) || (1 != inet_pton (AF_INET6, hostname, &v6)))
{
GNUNET_free (hostname);
return;
while (loopback[i] != NULL)
if (0 == strcasecmp (loopback[i++], hostname))
{
- GNUNET_free (hostname);
- return;
+ GNUNET_free (hostname);
+ return;
}
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Must specify `%s' or numeric IP address for `%s' of `%s' in configuration!\n"),
- "localhost",
- "HOSTNAME",
- "resolver");
- GNUNET_free (hostname);
- GNUNET_assert (0);
+ _
+ ("Must specify `%s' or numeric IP address for `%s' of `%s' in configuration!\n"),
+ "localhost", "HOSTNAME", "resolver");
+ GNUNET_free (hostname);
+ GNUNET_assert (0);
}
#if DEBUG_RESOLVER
{
char *ips = no_resolve (sa, salen);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Resolver returns `%s'.\n",
- ips);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Resolver returns `%s'.\n", ips);
GNUNET_free (ips);
}
#endif
* @param tc unused scheduler context
*/
static void
-numeric_resolution (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+numeric_resolution (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_RESOLVER_RequestHandle *rh = cls;
struct sockaddr_in v4;
struct sockaddr_in6 v6;
- memset (&v4, 0, sizeof(v4));
+ memset (&v4, 0, sizeof (v4));
v4.sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
- v4.sin_len = sizeof(v4);
+ v4.sin_len = sizeof (v4);
#endif
- memset (&v6, 0, sizeof(v6));
+ memset (&v6, 0, sizeof (v6));
v6.sin6_family = AF_INET6;
#if HAVE_SOCKADDR_IN_SIN_LEN
- v6.sin6_len = sizeof(v6);
+ v6.sin6_len = sizeof (v6);
#endif
- if ( ( (rh->domain == AF_UNSPEC) || (rh->domain == AF_INET) ) &&
- (1 == inet_pton (AF_INET,
- rh->hostname,
- &v4.sin_addr)) )
+ if (((rh->domain == AF_UNSPEC) || (rh->domain == AF_INET)) &&
+ (1 == inet_pton (AF_INET, rh->hostname, &v4.sin_addr)))
{
- rh->addr_callback (rh->cls,
- (const struct sockaddr*) &v4,
- sizeof(v4));
- if ( (rh->domain == AF_UNSPEC) &&
- (1 == inet_pton (AF_INET6,
- rh->hostname,
- &v6.sin6_addr)) )
- {
- /* this can happen on some systems IF "hostname" is "localhost" */
- rh->addr_callback (rh->cls,
- (const struct sockaddr*) &v6,
- sizeof(v6));
- }
- rh->addr_callback (rh->cls, NULL, 0);
+ rh->addr_callback (rh->cls, (const struct sockaddr *) &v4, sizeof (v4));
+ if ((rh->domain == AF_UNSPEC) &&
+ (1 == inet_pton (AF_INET6, rh->hostname, &v6.sin6_addr)))
+ {
+ /* this can happen on some systems IF "hostname" is "localhost" */
+ rh->addr_callback (rh->cls,
+ (const struct sockaddr *) &v6, sizeof (v6));
+ }
+ rh->addr_callback (rh->cls, NULL, 0);
GNUNET_free (rh);
return;
}
- if ( ( (rh->domain == AF_UNSPEC) || (rh->domain == AF_INET6) ) &&
- (1 == inet_pton (AF_INET6,
- rh->hostname,
- &v6.sin6_addr)) )
+ if (((rh->domain == AF_UNSPEC) || (rh->domain == AF_INET6)) &&
+ (1 == inet_pton (AF_INET6, rh->hostname, &v6.sin6_addr)))
{
- rh->addr_callback (rh->cls,
- (const struct sockaddr*) &v6,
- sizeof(v6));
+ rh->addr_callback (rh->cls, (const struct sockaddr *) &v6, sizeof (v6));
rh->addr_callback (rh->cls, NULL, 0);
GNUNET_free (rh);
return;
* @param tc unused scheduler context
*/
static void
-loopback_resolution (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+loopback_resolution (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_RESOLVER_RequestHandle *rh = cls;
struct sockaddr_in v4;
struct sockaddr_in6 v6;
- memset (&v4, 0, sizeof(v4));
- v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+ memset (&v4, 0, sizeof (v4));
+ v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
v4.sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
- v4.sin_len = sizeof(v4);
+ v4.sin_len = sizeof (v4);
#endif
- memset (&v6, 0, sizeof(v6));
+ memset (&v6, 0, sizeof (v6));
v6.sin6_family = AF_INET6;
#if HAVE_SOCKADDR_IN_SIN_LEN
- v6.sin6_len = sizeof(v6);
+ v6.sin6_len = sizeof (v6);
#endif
v6.sin6_addr = in6addr_loopback;
switch (rh->domain)
{
case AF_INET:
- rh->addr_callback (rh->cls,
- (const struct sockaddr*) &v4,
- sizeof(v4));
+ rh->addr_callback (rh->cls, (const struct sockaddr *) &v4, sizeof (v4));
break;
case AF_INET6:
- rh->addr_callback (rh->cls,
- (const struct sockaddr*) &v6,
- sizeof(v6));
+ rh->addr_callback (rh->cls, (const struct sockaddr *) &v6, sizeof (v6));
break;
case AF_UNSPEC:
- rh->addr_callback (rh->cls,
- (const struct sockaddr*) &v6,
- sizeof(v6));
- rh->addr_callback (rh->cls,
- (const struct sockaddr*) &v4,
- sizeof(v4));
+ rh->addr_callback (rh->cls, (const struct sockaddr *) &v6, sizeof (v6));
+ rh->addr_callback (rh->cls, (const struct sockaddr *) &v4, sizeof (v4));
break;
default:
GNUNET_break (0);
const char *hostname,
int domain,
struct GNUNET_TIME_Relative timeout,
- GNUNET_RESOLVER_AddressCallback callback,
- void *callback_cls)
+ GNUNET_RESOLVER_AddressCallback callback,
+ void *callback_cls)
{
struct GNUNET_CLIENT_Connection *client;
struct GNUNET_RESOLVER_GetMessage *msg;
GNUNET_break (0);
return NULL;
}
- rh = GNUNET_malloc (sizeof(struct GNUNET_RESOLVER_RequestHandle) + slen);
+ rh = GNUNET_malloc (sizeof (struct GNUNET_RESOLVER_RequestHandle) + slen);
rh->sched = sched;
rh->domain = domain;
rh->addr_callback = callback;
rh->cls = callback_cls;
memcpy (&rh[1], hostname, slen);
- rh->hostname = (const char*) &rh[1];
+ rh->hostname = (const char *) &rh[1];
rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
/* first, check if this is a numeric address */
- if ( ( (1 == inet_pton (AF_INET,
- hostname,
- &v4)) &&
- ( (domain == AF_INET) || (domain == AF_UNSPEC)) ) ||
- ( (1 == inet_pton (AF_INET6,
- hostname,
- &v6)) &&
- ( (domain == AF_INET6) || (domain == AF_UNSPEC)) ) )
+ if (((1 == inet_pton (AF_INET,
+ hostname,
+ &v4)) &&
+ ((domain == AF_INET) || (domain == AF_UNSPEC))) ||
+ ((1 == inet_pton (AF_INET6,
+ hostname,
+ &v6)) &&
+ ((domain == AF_INET6) || (domain == AF_UNSPEC))))
{
rh->task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_UNIT_ZERO,
- &numeric_resolution,
- rh);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_UNIT_ZERO,
+ &numeric_resolution, rh);
return rh;
}
/* then, check if this is a loopback address */
while (loopback[i] != NULL)
if (0 == strcasecmp (loopback[i++], hostname))
{
- rh->task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_UNIT_ZERO,
- &loopback_resolution,
- rh);
- return rh;
+ rh->task = GNUNET_SCHEDULER_add_delayed (sched,
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_UNIT_ZERO,
+ &loopback_resolution, rh);
+ return rh;
}
client = GNUNET_CLIENT_connect (sched, "resolver", cfg);
if (client == NULL)
{
GNUNET_free (rh);
- return NULL;
+ return NULL;
}
rh->client = client;
- msg = (struct GNUNET_RESOLVER_GetMessage*) buf;
+ msg = (struct GNUNET_RESOLVER_GetMessage *) buf;
msg->header.size =
htons (sizeof (struct GNUNET_RESOLVER_GetMessage) + slen);
msg->header.type = htons (GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST);
#endif
if (GNUNET_OK !=
GNUNET_CLIENT_transmit_and_get_response (client,
- &msg->header,
- timeout,
- GNUNET_YES,
- &handle_address_response,
- rh))
+ &msg->header,
+ timeout,
+ GNUNET_YES,
+ &handle_address_response, rh))
{
GNUNET_free (rh);
GNUNET_CLIENT_disconnect (client);
* @param msg message with the hostname, NULL on error
*/
static void
-handle_hostname_response (void *cls,
- const struct GNUNET_MessageHeader *msg)
+handle_hostname_response (void *cls, const struct GNUNET_MessageHeader *msg)
{
struct GNUNET_RESOLVER_RequestHandle *rh = cls;
uint16_t size;
* @param tc unused scheduler context
*/
static void
-numeric_reverse (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+numeric_reverse (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_RESOLVER_RequestHandle *rh = cls;
char *result;
- result = no_resolve ((const struct sockaddr*) &rh[1],
- rh->salen);
+ result = no_resolve ((const struct sockaddr *) &rh[1], rh->salen);
#if DEBUG_RESOLVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- _("Resolver returns `%s'.\n"), result);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Resolver returns `%s'.\n"), result);
#endif
if (result != NULL)
{
if (GNUNET_NO == do_resolve)
{
rh->task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_UNIT_ZERO,
- &numeric_reverse,
- rh);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_UNIT_ZERO,
+ &numeric_reverse, rh);
return rh;
}
if (salen + sizeof (struct GNUNET_RESOLVER_GetMessage) >
}
rh->client = client;
- msg = (struct GNUNET_RESOLVER_GetMessage*) buf;
+ msg = (struct GNUNET_RESOLVER_GetMessage *) buf;
msg->header.size =
htons (sizeof (struct GNUNET_RESOLVER_GetMessage) + salen);
msg->header.type = htons (GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST);
#endif
if (GNUNET_OK !=
GNUNET_CLIENT_transmit_and_get_response (client,
- &msg->header,
- timeout,
- GNUNET_YES,
- &handle_hostname_response,
- rh))
+ &msg->header,
+ timeout,
+ GNUNET_YES,
+ &handle_hostname_response, rh))
{
GNUNET_CLIENT_disconnect (client);
GNUNET_free (rh);
*/
struct GNUNET_RESOLVER_RequestHandle *
GNUNET_RESOLVER_hostname_resolve (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- int domain,
+ const struct GNUNET_CONFIGURATION_Handle
+ *cfg, int domain,
struct GNUNET_TIME_Relative timeout,
GNUNET_RESOLVER_AddressCallback callback,
void *cls)
_("Resolving our hostname `%s'\n"), hostname);
#endif
return GNUNET_RESOLVER_ip_get (sched,
- cfg, hostname, domain, timeout, callback, cls);
+ cfg, hostname, domain, timeout, callback,
+ cls);
}
if (h->client != NULL)
GNUNET_CLIENT_disconnect (h->client);
if (h->task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (h->sched,
- h->task);
+ GNUNET_SCHEDULER_cancel (h->sched, h->task);
GNUNET_free (h);
}
*/
static void
update_sets (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_NETWORK_FDSet * rs,
- struct GNUNET_NETWORK_FDSet * ws,
- struct GNUNET_TIME_Relative *timeout)
+ struct GNUNET_NETWORK_FDSet *rs,
+ struct GNUNET_NETWORK_FDSet *ws,
+ struct GNUNET_TIME_Relative *timeout)
{
struct Task *pos;
to = GNUNET_TIME_absolute_get_remaining (pos->timeout);
if (timeout->value > to.value)
- *timeout = to;
+ *timeout = to;
}
if (pos->read_set != NULL)
- GNUNET_NETWORK_fdset_add (rs, pos->read_set);
+ GNUNET_NETWORK_fdset_add (rs, pos->read_set);
if (pos->write_set != NULL)
- GNUNET_NETWORK_fdset_add (ws, pos->write_set);
+ GNUNET_NETWORK_fdset_add (ws, pos->write_set);
pos = pos->next;
}
}
* @return GNUNET_YES if there was some overlap
*/
static int
-set_overlaps (const struct GNUNET_NETWORK_FDSet * ready,
- struct GNUNET_NETWORK_FDSet * want)
+set_overlaps (const struct GNUNET_NETWORK_FDSet *ready,
+ struct GNUNET_NETWORK_FDSet *want)
{
if (NULL == want)
return GNUNET_NO;
struct Task *task,
struct GNUNET_TIME_Absolute now,
const struct GNUNET_NETWORK_FDSet *rs,
- const struct GNUNET_NETWORK_FDSet * ws)
+ const struct GNUNET_NETWORK_FDSet *ws)
{
if ((GNUNET_NO == task->run_on_shutdown) && (GNUNET_YES == sched->shutdown))
return GNUNET_NO;
* @param task task ready for execution
*/
static void
-queue_ready_task (struct GNUNET_SCHEDULER_Handle *handle,
- struct Task *task)
+queue_ready_task (struct GNUNET_SCHEDULER_Handle *handle, struct Task *task)
{
task->next = handle->ready[check_priority (task->priority)];
handle->ready[check_priority (task->priority)] = task;
*/
static void
check_ready (struct GNUNET_SCHEDULER_Handle *handle,
- const struct GNUNET_NETWORK_FDSet * rs,
- const struct GNUNET_NETWORK_FDSet * ws)
+ const struct GNUNET_NETWORK_FDSet *rs,
+ const struct GNUNET_NETWORK_FDSet *ws)
{
struct Task *pos;
struct Task *prev;
{
#if DEBUG_TASKS
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Checking readyness of task: %llu / %p\n",
- pos->id,
- pos->callback_cls);
+ "Checking readyness of task: %llu / %p\n",
+ pos->id, pos->callback_cls);
#endif
next = pos->next;
if (GNUNET_YES == is_ready (handle, pos, now, rs, ws))
*
* @param t task to destroy
*/
-static void destroy_task (struct Task *t)
+static void
+destroy_task (struct Task *t)
{
if (NULL != t->read_set)
GNUNET_NETWORK_fdset_destroy (t->read_set);
pos->callback (pos->callback_cls, &tc);
#if DEBUG_TASKS
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Running task: %llu / %p\n",
- pos->id,
- pos->callback_cls);
+ "Running task: %llu / %p\n", pos->id, pos->callback_cls);
#endif
destroy_task (pos);
sched->tasks_run++;
{
static char c;
- GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_WRITE),
- &c,
- sizeof(c));
+ GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
+ (sigpipe, GNUNET_DISK_PIPE_END_WRITE), &c,
+ sizeof (c));
}
{
GNUNET_NETWORK_fdset_zero (rs);
GNUNET_NETWORK_fdset_zero (ws);
- timeout = GNUNET_TIME_relative_get_forever();
+ timeout = GNUNET_TIME_relative_get_forever ();
update_sets (&sched, rs, ws, &timeout);
#ifndef MINGW
GNUNET_NETWORK_fdset_handle_set (rs, pr);
if (sched.ready_count > 0)
{
/* no blocking, more work already ready! */
- timeout = GNUNET_TIME_relative_get_zero();
+ timeout = GNUNET_TIME_relative_get_zero ();
}
ret = GNUNET_NETWORK_socket_select (rs, ws, NULL, timeout);
#ifndef MINGW
if (GNUNET_NETWORK_fdset_handle_isset (rs, pr))
- break;
+ break;
#endif
if (last_tr == sched.tasks_run)
- {
- busy_wait_warning++;
- }
+ {
+ busy_wait_warning++;
+ }
else
- {
- last_tr = sched.tasks_run;
- busy_wait_warning = 0;
- }
- if ( (ret == 0) &&
- (timeout.value == 0) &&
- (busy_wait_warning > 16) )
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Looks like we're busy waiting...\n"));
- sleep (1); /* mitigate */
- }
+ {
+ last_tr = sched.tasks_run;
+ busy_wait_warning = 0;
+ }
+ if ((ret == 0) && (timeout.value == 0) && (busy_wait_warning > 16))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Looks like we're busy waiting...\n"));
+ sleep (1); /* mitigate */
+ }
if (ret == GNUNET_SYSERR)
{
if (errno == EINTR)
ret = t->callback_cls;
#if DEBUG_TASKS
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Canceling task: %llu / %p\n",
- task,
- t->callback_cls);
+ "Canceling task: %llu / %p\n", task, t->callback_cls);
#endif
destroy_task (t);
return ret;
task->run_on_shutdown = run_on_shutdown;
#if DEBUG_TASKS
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Adding continuation task: %llu / %p\n",
- task->id,
- task->callback_cls);
+ "Adding continuation task: %llu / %p\n",
+ task->id, task->callback_cls);
#endif
queue_ready_task (sched, task);
}
*/
GNUNET_SCHEDULER_TaskIdentifier
GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle * sched,
- int run_on_shutdown,
- enum GNUNET_SCHEDULER_Priority prio,
- GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
- struct GNUNET_TIME_Relative delay,
- struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_Task main, void *cls)
+ int run_on_shutdown,
+ enum GNUNET_SCHEDULER_Priority prio,
+ GNUNET_SCHEDULER_TaskIdentifier
+ prerequisite_task,
+ struct GNUNET_TIME_Relative delay,
+ struct GNUNET_NETWORK_Handle * rfd,
+ GNUNET_SCHEDULER_Task main, void *cls)
{
struct GNUNET_NETWORK_FDSet *rs;
GNUNET_SCHEDULER_TaskIdentifier ret;
rs = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_set (rs, rfd);
ret = GNUNET_SCHEDULER_add_select (sched, run_on_shutdown, prio,
- prerequisite_task, delay,
- rs, NULL, main, cls);
+ prerequisite_task, delay,
+ rs, NULL, main, cls);
GNUNET_NETWORK_fdset_destroy (rs);
return ret;
}
*/
GNUNET_SCHEDULER_TaskIdentifier
GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle * sched,
- int run_on_shutdown,
- enum GNUNET_SCHEDULER_Priority prio,
- GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
- struct GNUNET_TIME_Relative delay,
- struct GNUNET_NETWORK_Handle *wfd, GNUNET_SCHEDULER_Task main, void *cls)
+ int run_on_shutdown,
+ enum GNUNET_SCHEDULER_Priority prio,
+ GNUNET_SCHEDULER_TaskIdentifier
+ prerequisite_task,
+ struct GNUNET_TIME_Relative delay,
+ struct GNUNET_NETWORK_Handle * wfd,
+ GNUNET_SCHEDULER_Task main, void *cls)
{
struct GNUNET_NETWORK_FDSet *ws;
GNUNET_SCHEDULER_TaskIdentifier ret;
ws = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_set (ws, wfd);
ret = GNUNET_SCHEDULER_add_select (sched, run_on_shutdown, prio,
- prerequisite_task, delay,
- NULL, ws, main, cls);
+ prerequisite_task, delay,
+ NULL, ws, main, cls);
GNUNET_NETWORK_fdset_destroy (ws);
return ret;
}
prerequisite_task,
struct GNUNET_TIME_Relative delay,
const struct GNUNET_NETWORK_FDSet * rs,
- const struct GNUNET_NETWORK_FDSet * ws,
+ const struct GNUNET_NETWORK_FDSet * ws,
GNUNET_SCHEDULER_Task main, void *cls)
{
struct Task *task;
sched->pending = task;
#if DEBUG_TASKS
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Adding task: %llu / %p\n",
- task->id,
- task->callback_cls);
+ "Adding task: %llu / %p\n", task->id, task->callback_cls);
#endif
return task->id;
}
*/
GNUNET_SCHEDULER_TaskIdentifier
GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle * sched,
- int run_on_shutdown,
- enum GNUNET_SCHEDULER_Priority prio,
- GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
- struct GNUNET_TIME_Relative delay,
- const struct GNUNET_DISK_FileHandle *rfd,
- GNUNET_SCHEDULER_Task main, void *cls)
+ int run_on_shutdown,
+ enum GNUNET_SCHEDULER_Priority prio,
+ GNUNET_SCHEDULER_TaskIdentifier
+ prerequisite_task,
+ struct GNUNET_TIME_Relative delay,
+ const struct GNUNET_DISK_FileHandle * rfd,
+ GNUNET_SCHEDULER_Task main, void *cls)
{
struct GNUNET_NETWORK_FDSet *rs;
GNUNET_SCHEDULER_TaskIdentifier ret;
rs = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_handle_set (rs, rfd);
ret = GNUNET_SCHEDULER_add_select (sched, run_on_shutdown, prio,
- prerequisite_task, delay,
- rs, NULL, main, cls);
+ prerequisite_task, delay,
+ rs, NULL, main, cls);
GNUNET_NETWORK_fdset_destroy (rs);
return ret;
}
*/
GNUNET_SCHEDULER_TaskIdentifier
GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle * sched,
- int run_on_shutdown,
- enum GNUNET_SCHEDULER_Priority prio,
- GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
- struct GNUNET_TIME_Relative delay,
- const struct GNUNET_DISK_FileHandle *wfd,
- GNUNET_SCHEDULER_Task main, void *cls)
+ int run_on_shutdown,
+ enum GNUNET_SCHEDULER_Priority prio,
+ GNUNET_SCHEDULER_TaskIdentifier
+ prerequisite_task,
+ struct GNUNET_TIME_Relative delay,
+ const struct GNUNET_DISK_FileHandle * wfd,
+ GNUNET_SCHEDULER_Task main, void *cls)
{
struct GNUNET_NETWORK_FDSet *ws;
GNUNET_SCHEDULER_TaskIdentifier ret;
ws = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_handle_set (ws, wfd);
ret = GNUNET_SCHEDULER_add_select (sched, run_on_shutdown, prio,
- prerequisite_task, delay,
- NULL, ws, main, cls);
+ prerequisite_task, delay,
+ NULL, ws, main, cls);
GNUNET_NETWORK_fdset_destroy (ws);
return ret;
}
struct NotifyList *npos;
#if DEBUG_SERVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Server shutting down.\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Server shutting down.\n");
#endif
GNUNET_assert (server->listen_socket == NULL);
if (GNUNET_OK != GNUNET_DISK_pipe_close (server->shutpipe))
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
- "pipe-close");
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "pipe-close");
while (server->clients != NULL)
{
pos = server->clients;
{
/* shutdown was initiated */
GNUNET_assert (server->listen_socket != NULL);
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (server->listen_socket));
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (server->listen_socket));
server->listen_socket = NULL;
if (server->do_shutdown)
destroy_server (server);
return;
}
- shutpipe = GNUNET_DISK_pipe_handle (server->shutpipe,
- GNUNET_DISK_PIPE_END_READ);
- GNUNET_assert (GNUNET_NETWORK_fdset_isset (tc->read_ready, server->listen_socket));
- GNUNET_assert (!GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, shutpipe));
- sock = GNUNET_CONNECTION_create_from_accept (tc->sched,
- server->access,
- server->access_cls,
- server->listen_socket,
- server->maxbuf);
+ shutpipe = GNUNET_DISK_pipe_handle (server->shutpipe,
+ GNUNET_DISK_PIPE_END_READ);
+ GNUNET_assert (GNUNET_NETWORK_fdset_isset
+ (tc->read_ready, server->listen_socket));
+ GNUNET_assert (!GNUNET_NETWORK_fdset_handle_isset
+ (tc->read_ready, shutpipe));
+ sock =
+ GNUNET_CONNECTION_create_from_accept (tc->sched, server->access,
+ server->access_cls,
+ server->listen_socket,
+ server->maxbuf);
if (sock != NULL)
{
#if DEBUG_SERVER
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Server accepted incoming connection.\n");
+ "Server accepted incoming connection.\n");
#endif
client = GNUNET_SERVER_connect_socket (server, sock);
/* decrement reference count, we don't keep "client" alive */
GNUNET_SCHEDULER_PRIORITY_HIGH,
GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_UNIT_FOREVER_REL,
- r, NULL,
- &process_listen_socket, server);
+ r, NULL, &process_listen_socket, server);
GNUNET_NETWORK_fdset_destroy (r);
}
GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
return NULL;
}
- if (GNUNET_NETWORK_socket_setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
+ if (GNUNET_NETWORK_socket_setsockopt
+ (sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"setsockopt");
/* bind the socket */
return NULL;
}
#if DEBUG_SERVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Server starts to listen on port %u.\n",
- port);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Server starts to listen on port %u.\n", port);
#endif
return sock;
}
{
r = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_set (r, ret->listen_socket);
- GNUNET_NETWORK_fdset_handle_set (r, GNUNET_DISK_pipe_handle (ret->shutpipe,
- GNUNET_DISK_PIPE_END_READ));
- GNUNET_SCHEDULER_add_select (sched,
- GNUNET_YES,
+ GNUNET_NETWORK_fdset_handle_set (r,
+ GNUNET_DISK_pipe_handle (ret->shutpipe,
+ GNUNET_DISK_PIPE_END_READ));
+ GNUNET_SCHEDULER_add_select (sched, GNUNET_YES,
GNUNET_SCHEDULER_PRIORITY_HIGH,
GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_UNIT_FOREVER_REL,
- r,
- NULL, &process_listen_socket, ret);
+ GNUNET_TIME_UNIT_FOREVER_REL, r, NULL,
+ &process_listen_socket, ret);
GNUNET_NETWORK_fdset_destroy (r);
}
return ret;
if (s->listen_socket == NULL)
destroy_server (s);
else
- GNUNET_break (1 == GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle (s->shutpipe,
- GNUNET_DISK_PIPE_END_WRITE),
- &c,
- sizeof(c)));
+ GNUNET_break (1 ==
+ GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
+ (s->shutpipe,
+ GNUNET_DISK_PIPE_END_WRITE), &c,
+ sizeof (c)));
}
size = ntohs (message->size);
#if DEBUG_SERVER
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Server schedules transmission of %u-byte message of type %u to client.\n",
- size,
- type);
+ "Server schedules transmission of %u-byte message of type %u to client.\n",
+ size, type);
#endif
pos = server->handlers;
found = GNUNET_NO;
server = client->server;
#if DEBUG_SERVER
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Private buffer contains %u bytes; client is %s and we are %s\n",
- client->receive_pos,
- client->suspended ? "suspended" : "up",
- client->shutdown_now ? "in shutdown" : "running");
+ "Private buffer contains %u bytes; client is %s and we are %s\n",
+ client->receive_pos,
+ client->suspended ? "suspended" : "up",
+ client->shutdown_now ? "in shutdown" : "running");
#endif
while ((client->receive_pos >= sizeof (struct GNUNET_MessageHeader)) &&
(0 == client->suspended) && (GNUNET_YES != client->shutdown_now))
hdr = (const struct GNUNET_MessageHeader *) &client->incoming_buffer;
msize = ntohs (hdr->size);
if (msize > client->receive_pos)
- {
+ {
#if DEBUG_SERVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Total message size is %u, we only have %u bytes; need more data\n",
- msize,
- client->receive_pos);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Total message size is %u, we only have %u bytes; need more data\n",
+ msize, client->receive_pos);
#endif
- break;
- }
+ break;
+ }
#if DEBUG_SERVER
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Passing %u bytes to callback for processing\n",
- msize);
+ "Passing %u bytes to callback for processing\n", msize);
#endif
if ((msize < sizeof (struct GNUNET_MessageHeader)) ||
(GNUNET_OK != GNUNET_SERVER_inject (server, client, hdr)))
process_incoming (void *cls,
const void *buf,
size_t available,
- const struct sockaddr *addr,
- socklen_t addrlen,
- int errCode)
+ const struct sockaddr *addr, socklen_t addrlen, int errCode)
{
struct GNUNET_SERVER_Client *client = cls;
struct GNUNET_SERVER_Handle *server = client->server;
}
#if DEBUG_SERVER
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Server receives %u bytes from `%s'.\n",
- available,
- GNUNET_a2s(addr, addrlen));
+ "Server receives %u bytes from `%s'.\n",
+ available, GNUNET_a2s (addr, addrlen));
#endif
GNUNET_SERVER_client_keep (client);
client->last_activity = GNUNET_TIME_absolute_get ();
maxcpy = sizeof (client->incoming_buffer) - client->receive_pos;
#if DEBUG_SERVER
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Can copy %u bytes to private buffer\n",
- maxcpy);
+ "Can copy %u bytes to private buffer\n", maxcpy);
#endif
memcpy (&client->incoming_buffer[client->receive_pos], cbuf, maxcpy);
client->receive_pos += maxcpy;
if (available > 0)
{
#if DEBUG_SERVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Client has suspended processing; copying %u bytes to side buffer to be used later.\n",
- available);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Client has suspended processing; copying %u bytes to side buffer to be used later.\n",
+ available);
#endif
- GNUNET_assert (client->side_buf_size == 0);
- GNUNET_assert (client->side_buf == NULL);
+ GNUNET_assert (client->side_buf_size == 0);
+ GNUNET_assert (client->side_buf == NULL);
client->side_buf_size = available;
client->side_buf = GNUNET_malloc (available);
memcpy (client->side_buf, cbuf, available);
}
#if DEBUG_SERVER
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Now processing messages in private buffer\n");
+ "Now processing messages in private buffer\n");
#endif
process_client_buffer (client);
}
{
/* Finally, keep receiving! */
client->receive (client->client_closure,
- GNUNET_SERVER_MAX_MESSAGE_SIZE,
- server->idle_timeout,
- &process_incoming, client);
+ GNUNET_SERVER_MAX_MESSAGE_SIZE,
+ server->idle_timeout, &process_incoming, client);
}
if (GNUNET_YES == client->shutdown_now)
shutdown_incoming_processing (client);
process_client_buffer (client);
if (0 == client->suspended)
client->receive (client->client_closure,
- GNUNET_SERVER_MAX_MESSAGE_SIZE,
- client->server->idle_timeout,
- &process_incoming, client);
+ GNUNET_SERVER_MAX_MESSAGE_SIZE,
+ client->server->idle_timeout, &process_incoming, client);
}
client->next = server->clients;
server->clients = client;
client->receive (client->client_closure,
- GNUNET_SERVER_MAX_MESSAGE_SIZE,
- server->idle_timeout,
- &process_incoming, client);
+ GNUNET_SERVER_MAX_MESSAGE_SIZE,
+ server->idle_timeout, &process_incoming, client);
}
void *notify_cls)
{
return GNUNET_CONNECTION_notify_transmit_ready (cls, size, timeout, notify,
- notify_cls);
+ notify_cls);
}
if (client->receive != &sock_receive)
return GNUNET_SYSERR; /* not a network client */
return GNUNET_CONNECTION_get_address (client->client_closure,
- addr, addrlen);
+ addr, addrlen);
}
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("Access from `%s' denied to service `%s'\n"),
- GNUNET_a2s(addr, addrlen), sctx->serviceName);
+ GNUNET_a2s (addr, addrlen), sctx->serviceName);
}
return ret;
}
{
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (sctx->cfg,
- sctx->serviceName,
- "TIMEOUT", &idleout))
+ sctx->serviceName,
+ "TIMEOUT", &idleout))
return GNUNET_SYSERR;
sctx->timeout = idleout;
{
if (GNUNET_SYSERR ==
(disablev6 = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg,
- sctx->serviceName,
+ sctx->
+ serviceName,
"DISABLEV6")))
return GNUNET_SYSERR;
}
GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
return GNUNET_SYSERR;
}
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"),
- sctx->serviceName,
- STRERROR (errno));
- disablev6 = GNUNET_YES;
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ _
+ ("Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"),
+ sctx->serviceName, STRERROR (errno));
+ disablev6 = GNUNET_YES;
}
else
- {
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
- }
+ {
+ GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
+ }
}
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to find %saddress for `%s'.\n"),
- disablev6 ? "IPv4 " : "", hostname);
+ disablev6 ? "IPv4 " : "", hostname);
freeaddrinfo (res);
GNUNET_free (hostname);
return GNUNET_SYSERR;
if (sctx->server == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Failed to start `%s' at `%s'\n"),
- sctx->serviceName,
- GNUNET_a2s (sctx->addr,
- sctx->addrlen));
+ _("Failed to start `%s' at `%s'\n"),
+ sctx->serviceName, GNUNET_a2s (sctx->addr, sctx->addrlen));
sctx->ret = GNUNET_SYSERR;
return;
}
write_pid_file (sctx, getpid ());
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Service `%s' runs at %s\n"),
- sctx->serviceName,
- GNUNET_a2s (sctx->addr,
- sctx->addrlen));
+ _("Service `%s' runs at %s\n"),
+ sctx->serviceName, GNUNET_a2s (sctx->addr, sctx->addrlen));
sctx->task (sctx->task_cls, tc->sched, sctx->server, sctx->cfg);
}
static int
detach_terminal (struct GNUNET_SERVICE_Context *sctx)
{
-#ifndef MINGW
+#ifndef MINGW
pid_t pid;
int nullfd;
int filedes[2];
sctx.cfg = cfg = GNUNET_CONFIGURATION_create ();
/* setup subsystems */
if ((GNUNET_SYSERR ==
- GNUNET_GETOPT_run (serviceName,
+ GNUNET_GETOPT_run (serviceName,
service_options,
argc,
argv)) ||
}
#if 0
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Service `%s' runs with configuration from `%s'\n",
- serviceName,
- cfg_fn);
+ "Service `%s' runs with configuration from `%s'\n",
+ serviceName, cfg_fn);
#endif
/* actually run service */
GNUNET_SCHEDULER_run (&service_task, &sctx);
tmp = GNUNET_malloc (tmpSize);
itmp = tmp;
finSize = tmpSize;
- if (iconv (cd,
+ if (iconv (cd,
#if FREEBSD
- (const char **) &input,
+ (const char **) &input,
#else
- (char **) &input,
+ (char **) &input,
#endif
- &len, &itmp, &finSize) == (size_t) - 1)
+ &len, &itmp, &finSize) == (size_t) - 1)
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "iconv");
iconv_close (cd);
main (int argc, char *argv[])
{
- char *readResultString;
- int64_t testNumber = (int64_t)TESTNUMBER64;
- int64_t testNum;
- char *msg;
- char file[102400];
- char meta[1024*1024*10];
- int i,j;
- for(i=0;i<102400;i++){
- file[i]='a';
+ char *readResultString;
+ int64_t testNumber = (int64_t) TESTNUMBER64;
+ int64_t testNum;
+ char *msg;
+ static char file[102400];
+ static char meta[1024 * 1024 * 10];
+ int i, j;
+ for (i = 0; i < 102400; i++)
+ {
+ file[i] = 'a';
}
- for(j=0;j<1024*1024*10;j++){
- meta[j]='b';
+ for (j = 0; j < 1024 * 1024 * 10; j++)
+ {
+ meta[j] = 'b';
}
- char* fileName = GNUNET_DISK_mktemp ("gnunet_bio");
- char* fileName2 = GNUNET_DISK_mktemp ("gnunet_zwei_bio");
- char* fileName3 = GNUNET_DISK_mktemp ("gnunet_drei_bio");
- char* fileName4 = GNUNET_DISK_mktemp ("gnunet_vier_bio");
+ char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+ char *fileName2 = GNUNET_DISK_mktemp ("gnunet_zwei_bio");
+ char *fileName3 = GNUNET_DISK_mktemp ("gnunet_drei_bio");
+ char *fileName4 = GNUNET_DISK_mktemp ("gnunet_vier_bio");
- struct GNUNET_BIO_ReadHandle *fileR,*fileR2,*fileR3,*fileR4;
- struct GNUNET_BIO_WriteHandle *fileW,*fileW2,*fileW3,*fileW4;
- struct GNUNET_CONTAINER_MetaData *metaDataW;
- struct GNUNET_CONTAINER_MetaData *metaDataR;
- struct GNUNET_BIO_ReadHandle *fileRNO;
- struct GNUNET_BIO_WriteHandle *fileWNO;
- struct GNUNET_CONTAINER_MetaData *metaData;
- struct GNUNET_CONTAINER_MetaData *metaDataNO;
+ struct GNUNET_BIO_ReadHandle *fileR, *fileR2, *fileR3, *fileR4;
+ struct GNUNET_BIO_WriteHandle *fileW, *fileW2, *fileW3, *fileW4;
+ struct GNUNET_CONTAINER_MetaData *metaDataW;
+ struct GNUNET_CONTAINER_MetaData *metaDataR;
+ struct GNUNET_BIO_ReadHandle *fileRNO;
+ struct GNUNET_BIO_WriteHandle *fileWNO;
+ struct GNUNET_CONTAINER_MetaData *metaData;
+ struct GNUNET_CONTAINER_MetaData *metaDataNO;
- metaData = GNUNET_CONTAINER_meta_data_create();
- metaDataNO = GNUNET_CONTAINER_meta_data_create();
- metaDataR = GNUNET_CONTAINER_meta_data_create();
- metaDataW = GNUNET_CONTAINER_meta_data_create();
- GNUNET_CONTAINER_meta_data_add_publication_date(metaDataW);
- GNUNET_CONTAINER_meta_data_add_publication_date(metaData);
- GNUNET_assert(GNUNET_OK == GNUNET_CONTAINER_meta_data_insert(metaData,EXTRACTOR_COMMENT,meta));
+ metaData = GNUNET_CONTAINER_meta_data_create ();
+ metaDataNO = GNUNET_CONTAINER_meta_data_create ();
+ metaDataR = GNUNET_CONTAINER_meta_data_create ();
+ metaDataW = GNUNET_CONTAINER_meta_data_create ();
+ GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
+ GNUNET_CONTAINER_meta_data_add_publication_date (metaData);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CONTAINER_meta_data_insert (metaData,
+ EXTRACTOR_COMMENT, meta));
///////////write
- fileW = GNUNET_BIO_write_open(fileName);
- GNUNET_assert(NULL != fileW);
- GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_string(fileW, TESTSTRING));
- GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_meta_data(fileW,metaDataW));
- GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_int64(fileW,testNumber));
- GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
- fileW2 = GNUNET_BIO_write_open(fileName2);
- GNUNET_assert(NULL != fileW2);
- GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_string(fileW2,NULL));
- fileWNO = GNUNET_BIO_write_open(file);
- fileW3 = GNUNET_BIO_write_open(fileName3);
- GNUNET_assert(NULL != fileW3);
- GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_meta_data(fileW3,metaData));
- fileW4 = GNUNET_BIO_write_open(fileName4);
- GNUNET_assert(NULL != fileW4);
- GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_string(fileW4,""));
- GNUNET_assert(NULL != fileWNO);
- GNUNET_assert(GNUNET_SYSERR == GNUNET_BIO_write_string(fileWNO, TESTSTRING));
- GNUNET_assert(GNUNET_SYSERR == GNUNET_BIO_write_meta_data(fileWNO,metaDataW));
- GNUNET_assert(GNUNET_SYSERR == GNUNET_BIO_write_close(fileWNO));
+ fileW = GNUNET_BIO_write_open (fileName);
+ GNUNET_assert (NULL != fileW);
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int64 (fileW, testNumber));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+ fileW2 = GNUNET_BIO_write_open (fileName2);
+ GNUNET_assert (NULL != fileW2);
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW2, NULL));
+ fileWNO = GNUNET_BIO_write_open (file);
+ GNUNET_assert (NULL != fileWNO);
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_write_string (fileWNO, TESTSTRING));
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_write_meta_data (fileWNO, metaDataW));
+ GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileWNO));
+ fileW3 = GNUNET_BIO_write_open (fileName3);
+ GNUNET_assert (NULL != fileW3);
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW3, metaData));
+ fileW4 = GNUNET_BIO_write_open (fileName4);
+ GNUNET_assert (NULL != fileW4);
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW4, ""));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW4));
////////////read
- fileRNO = GNUNET_BIO_read_open(file);
- GNUNET_assert(NULL != fileRNO);
- GNUNET_assert(GNUNET_SYSERR == GNUNET_BIO_read_string(fileRNO, "Read string error", &readResultString, 200));
- GNUNET_assert(GNUNET_SYSERR == GNUNET_BIO_read_int64(fileRNO, &testNum));
- GNUNET_assert(GNUNET_SYSERR == GNUNET_BIO_read_meta_data(fileRNO,"Read meta error", &metaDataNO));
- fileR = GNUNET_BIO_read_open(fileName);
- GNUNET_assert(NULL != fileR);
- GNUNET_assert(GNUNET_OK == GNUNET_BIO_read_string(fileR, "Read string error", &readResultString, 200));
- GNUNET_assert(GNUNET_OK == GNUNET_BIO_read_meta_data(fileR, "Read meta error", &metaDataR));
- GNUNET_assert(GNUNET_YES == GNUNET_CONTAINER_meta_data_test_equal(metaDataR,metaDataW));
- GNUNET_assert(GNUNET_OK == GNUNET_BIO_read_int64(fileR, &testNum));
- fileR2 = GNUNET_BIO_read_open(fileName2);
- GNUNET_assert(NULL != fileR2);
- GNUNET_assert(GNUNET_SYSERR == GNUNET_BIO_read_string(fileR2, "Read string error", &readResultString, 200));
- fileR3 = GNUNET_BIO_read_open(fileName3);
- GNUNET_assert(NULL != fileR3);
- GNUNET_assert(GNUNET_SYSERR == GNUNET_BIO_read_meta_data(fileR3, "Read meta error", &metaDataR));
- fileR4 = GNUNET_BIO_read_open(fileName4);
- GNUNET_assert(NULL != fileR4);
- GNUNET_assert(GNUNET_OK == GNUNET_BIO_read_string(fileR4, "Read string error", &readResultString, 200));
- GNUNET_BIO_read_close(fileR,&msg);
- GNUNET_BIO_read_close(fileR2,&msg);
- GNUNET_BIO_read_close(fileR3,&msg);
- GNUNET_BIO_read_close(fileR4,&msg);
- GNUNET_CONTAINER_meta_data_destroy(metaDataW);
- GNUNET_CONTAINER_meta_data_destroy(metaDataNO);
- GNUNET_CONTAINER_meta_data_destroy(metaDataR);
- GNUNET_CONTAINER_meta_data_destroy(metaData);
- GNUNET_free(fileName);
- GNUNET_free(fileName2);
- GNUNET_free(fileName3);
- GNUNET_free(fileName4);
+ fileRNO = GNUNET_BIO_read_open (file);
+ GNUNET_assert (NULL != fileRNO);
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_read_string (fileRNO, "Read string error",
+ &readResultString, 200));
+ GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileRNO, &testNum));
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_read_meta_data (fileRNO, "Read meta error",
+ &metaDataNO));
+ fileR = GNUNET_BIO_read_open (fileName);
+ GNUNET_assert (NULL != fileR);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_BIO_read_string (fileR, "Read string error",
+ &readResultString, 200));
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+ &metaDataR));
+ GNUNET_assert (GNUNET_YES ==
+ GNUNET_CONTAINER_meta_data_test_equal (metaDataR,
+ metaDataW));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum));
+ fileR2 = GNUNET_BIO_read_open (fileName2);
+ GNUNET_assert (NULL != fileR2);
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_read_string (fileR2, "Read string error",
+ &readResultString, 200));
+ fileR3 = GNUNET_BIO_read_open (fileName3);
+ GNUNET_assert (NULL != fileR3);
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_read_meta_data (fileR3, "Read meta error",
+ &metaDataR));
+ fileR4 = GNUNET_BIO_read_open (fileName4);
+ GNUNET_assert (NULL != fileR4);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_BIO_read_string (fileR4, "Read string error",
+ &readResultString, 200));
+ GNUNET_BIO_read_close (fileR, &msg);
+ GNUNET_BIO_read_close (fileR2, &msg);
+ GNUNET_BIO_read_close (fileR3, &msg);
+ GNUNET_BIO_read_close (fileR4, &msg);
+ GNUNET_CONTAINER_meta_data_destroy (metaDataW);
+ GNUNET_CONTAINER_meta_data_destroy (metaDataNO);
+ GNUNET_CONTAINER_meta_data_destroy (metaDataR);
+ GNUNET_CONTAINER_meta_data_destroy (metaData);
+ GNUNET_free (fileName);
+ GNUNET_free (fileName2);
+ GNUNET_free (fileName3);
+ GNUNET_free (fileName4);
- return 0;
+ return 0;
} /* end of main */
GNUNET_SERVER_receive_done (ctx->client, GNUNET_OK);
GNUNET_free (cpy);
GNUNET_free (ctx);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Message bounced back to client\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Message bounced back to client\n");
return sizeof (struct GNUNET_MessageHeader);
}
struct GNUNET_MessageHeader *cpy;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Receiving message from client, bouncing back\n");
+ "Receiving message from client, bouncing back\n");
GNUNET_assert (sizeof (struct GNUNET_MessageHeader) ==
ntohs (message->size));
cc = GNUNET_malloc (sizeof (struct CopyContext));
GNUNET_assert (got != NULL); /* timeout */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Receiving bounce, checking content\n");
+ "Receiving bounce, checking content\n");
msg.type = htons (MY_TYPE);
msg.size = htons (sizeof (struct GNUNET_MessageHeader));
- GNUNET_assert (0 == memcmp (got, &msg, sizeof (struct GNUNET_MessageHeader)));
+ GNUNET_assert (0 ==
+ memcmp (got, &msg, sizeof (struct GNUNET_MessageHeader)));
GNUNET_CLIENT_disconnect (client);
client = NULL;
GNUNET_SERVER_destroy (server);
GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
msg->type = htons (MY_TYPE);
msg->size = htons (sizeof (struct GNUNET_MessageHeader));
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Creating message for transmission\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating message for transmission\n");
return sizeof (struct GNUNET_MessageHeader);
}
GNUNET_assert (NULL !=
GNUNET_CLIENT_notify_transmit_ready (client,
sizeof (struct
- GNUNET_MessageHeader),
+ GNUNET_MessageHeader),
GNUNET_TIME_UNIT_SECONDS,
- GNUNET_NO,
+ GNUNET_NO,
&make_msg, NULL));
GNUNET_CLIENT_receive (client, &recv_bounce, cls,
GNUNET_TIME_relative_multiply
{
int ret = 0;
- GNUNET_log_setup ("test_client",
+ GNUNET_log_setup ("test_client",
#if VERBOSE
- "DEBUG",
+ "DEBUG",
#else
- "WARNING",
+ "WARNING",
#endif
- NULL);
+ NULL);
ret += check ();
return ret;
#ifndef MINGW
if (0 != strcmp (c, "/hello/world"))
#else
- #define HI "\\hello\\world"
+#define HI "\\hello\\world"
if (strstr (c, HI) != c + strlen (c) - strlen (HI))
#endif
{
sa.sin_family = AF_INET;
desc = GNUNET_NETWORK_socket_create (AF_INET, SOCK_STREAM, 0);
GNUNET_assert (desc != NULL);
- if (GNUNET_NETWORK_socket_setsockopt (desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
+ if (GNUNET_NETWORK_socket_setsockopt
+ (desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"setsockopt");
- GNUNET_assert (GNUNET_NETWORK_socket_bind (desc,
- (const struct sockaddr*) &sa,
- sizeof (sa)) == GNUNET_OK);
+ GNUNET_assert (GNUNET_NETWORK_socket_bind
+ (desc, (const struct sockaddr *) &sa,
+ sizeof (sa)) == GNUNET_OK);
GNUNET_NETWORK_socket_listen (desc, 5);
return desc;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receive needs more data\n");
#endif
GNUNET_CONNECTION_receive (asock,
- 1024,
- GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check,
- cls);
+ 1024,
+ GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 5),
+ &receive_check, cls);
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test accepts connection\n");
#endif
asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
- NULL, NULL, ls, 1024);
+ NULL, NULL, ls, 1024);
GNUNET_assert (asock != NULL);
GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
#if VERBOSE
"Test asks to receive on accepted socket\n");
#endif
GNUNET_CONNECTION_receive (asock,
- 1024,
- GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check, cls);
+ 1024,
+ GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check,
+ cls);
}
static size_t
lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls, 0);
GNUNET_assert (lsock != NULL);
csock = GNUNET_CONNECTION_create_from_connect (tc->sched,
- cfg,
- "localhost", PORT, 1024);
+ cfg,
+ "localhost", PORT, 1024);
GNUNET_assert (csock != NULL);
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test asks for write notification\n");
#endif
GNUNET_assert (NULL !=
GNUNET_CONNECTION_notify_transmit_ready (csock,
- 12,
- GNUNET_TIME_UNIT_SECONDS,
- &make_hello,
- NULL));
+ 12,
+ GNUNET_TIME_UNIT_SECONDS,
+ &make_hello, NULL));
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test prepares to accept\n");
#endif
GNUNET_SCHEDULER_add_read_net (tc->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_HIGH,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_UNIT_FOREVER_REL,
- ls, &run_accept, cls);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_HIGH,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ ls, &run_accept, cls);
}
sa.sin_port = htons (PORT);
desc = GNUNET_NETWORK_socket_create (AF_INET, SOCK_STREAM, 0);
GNUNET_assert (desc != 0);
- if (GNUNET_NETWORK_socket_setsockopt (desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
+ if (GNUNET_NETWORK_socket_setsockopt
+ (desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"setsockopt");
- GNUNET_assert (GNUNET_NETWORK_socket_bind (desc,
- (const struct sockaddr*) &sa,
- sizeof (sa)) == GNUNET_OK);
+ GNUNET_assert (GNUNET_NETWORK_socket_bind
+ (desc, (const struct sockaddr *) &sa,
+ sizeof (sa)) == GNUNET_OK);
GNUNET_NETWORK_socket_listen (desc, 5);
return desc;
}
if (sofar < 12)
{
GNUNET_CONNECTION_receive (asock,
- 1024,
- GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check,
- cls);
+ 1024,
+ GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 5),
+ &receive_check, cls);
}
else
{
struct sockaddr_in expect;
asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
- NULL, NULL, ls, 1024);
+ NULL, NULL, ls, 1024);
GNUNET_assert (asock != NULL);
GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
GNUNET_assert (GNUNET_OK ==
GNUNET_free (addr);
GNUNET_CONNECTION_destroy (lsock);
GNUNET_CONNECTION_receive (asock,
- 1024,
- GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check, cls);
+ 1024,
+ GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check,
+ cls);
}
static size_t
v4.sin_port = htons (PORT);
v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
csock = GNUNET_CONNECTION_create_from_sockaddr (tc->sched,
- AF_INET,
- (const struct sockaddr
- *) &v4, sizeof (v4),
- 1024);
+ AF_INET,
+ (const struct sockaddr
+ *) &v4, sizeof (v4), 1024);
GNUNET_assert (csock != NULL);
GNUNET_assert (NULL !=
GNUNET_CONNECTION_notify_transmit_ready (csock,
- 12,
- GNUNET_TIME_UNIT_SECONDS,
- &make_hello, NULL));
+ 12,
+ GNUNET_TIME_UNIT_SECONDS,
+ &make_hello, NULL));
GNUNET_CONNECTION_destroy (csock);
GNUNET_SCHEDULER_add_read_net (tc->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_HIGH,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_UNIT_FOREVER_REL,
- ls, &run_accept, cls);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_HIGH,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ ls, &run_accept, cls);
}
{
int ret = 0;
- GNUNET_log_setup ("test_connection_addressing",
+ GNUNET_log_setup ("test_connection_addressing",
#if VERBOSE
- "DEBUG",
+ "DEBUG",
#else
- "WARNING",
+ "WARNING",
#endif
- NULL);
+ NULL);
ret += check ();
return ret;
}
sa.sin_port = htons (PORT);
desc = GNUNET_NETWORK_socket_create (AF_INET, SOCK_STREAM, 0);
GNUNET_assert (desc != NULL);
- if (GNUNET_NETWORK_socket_setsockopt (desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
+ if (GNUNET_NETWORK_socket_setsockopt
+ (desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"setsockopt");
- GNUNET_assert (GNUNET_NETWORK_socket_bind (desc,
- (const struct sockaddr*) &sa,
- sizeof (sa)) == GNUNET_OK);
+ GNUNET_assert (GNUNET_NETWORK_socket_bind
+ (desc, (const struct sockaddr *) &sa,
+ sizeof (sa)) == GNUNET_OK);
GNUNET_NETWORK_socket_listen (desc, 5);
return desc;
}
{
asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
- NULL, NULL, ls, 1024);
+ NULL, NULL, ls, 1024);
GNUNET_assert (asock != NULL);
GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
GNUNET_CONNECTION_destroy (lsock);
GNUNET_CONNECTION_receive (asock,
- 1024,
- GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_SECONDS, 5), &dead_receive,
- cls);
+ 1024,
+ GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 5), &dead_receive,
+ cls);
}
lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls, 0);
GNUNET_assert (lsock != NULL);
csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
- "localhost", PORT, 1024);
+ "localhost", PORT, 1024);
GNUNET_assert (csock != NULL);
GNUNET_SCHEDULER_add_read_net (tc->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_HIGH,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_UNIT_FOREVER_REL,
- ls, &run_accept_cancel, cls);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_HIGH,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ ls, &run_accept_cancel, cls);
GNUNET_SCHEDULER_add_delayed (tc->sched,
GNUNET_NO,
GNUNET_SCHEDULER_PRIORITY_KEEP,
sa.sin_port = htons (PORT);
desc = GNUNET_NETWORK_socket_create (AF_INET, SOCK_STREAM, 0);
GNUNET_assert (desc != NULL);
- if (GNUNET_NETWORK_socket_setsockopt (desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
+ if (GNUNET_NETWORK_socket_setsockopt
+ (desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"setsockopt");
- GNUNET_assert (GNUNET_NETWORK_socket_bind (desc,
- (const struct sockaddr*) &sa,
- sizeof (sa)) == GNUNET_OK);
+ GNUNET_assert (GNUNET_NETWORK_socket_bind
+ (desc, (const struct sockaddr *) &sa,
+ sizeof (sa)) == GNUNET_OK);
GNUNET_NETWORK_socket_listen (desc, 5);
return desc;
}
GNUNET_assert (NULL !=
GNUNET_CONNECTION_notify_transmit_ready (csock,
- 1024,
- GNUNET_TIME_UNIT_SECONDS,
- &send_kilo, cls));
+ 1024,
+ GNUNET_TIME_UNIT_SECONDS,
+ &send_kilo, cls));
return 1024;
}
lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls, 0);
GNUNET_assert (lsock != NULL);
csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
- "localhost", PORT, 1024);
+ "localhost", PORT, 1024);
GNUNET_assert (csock != NULL);
GNUNET_assert (NULL !=
GNUNET_CONNECTION_notify_transmit_ready (csock,
- 1024,
- GNUNET_TIME_UNIT_SECONDS,
- &send_kilo, cls));
+ 1024,
+ GNUNET_TIME_UNIT_SECONDS,
+ &send_kilo, cls));
}
task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
- "localhost", PORT, 1024);
+ "localhost", PORT, 1024);
GNUNET_assert (csock != NULL);
GNUNET_assert (NULL !=
GNUNET_CONNECTION_notify_transmit_ready (csock,
- 1024,
- GNUNET_TIME_UNIT_SECONDS,
- &handle_timeout, cls));
+ 1024,
+ GNUNET_TIME_UNIT_SECONDS,
+ &handle_timeout,
+ cls));
}
struct GNUNET_CONNECTION_Handle *csock;
csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
- "localhost", PORT, 1024);
+ "localhost", PORT, 1024);
GNUNET_assert (csock != NULL);
th = GNUNET_CONNECTION_notify_transmit_ready (csock,
- 12,
- GNUNET_TIME_UNIT_MINUTES,
- ¬_run, cls);
+ 12,
+ GNUNET_TIME_UNIT_MINUTES,
+ ¬_run, cls);
GNUNET_CONNECTION_notify_transmit_ready_cancel (th);
GNUNET_CONNECTION_destroy (csock);
*ok = 0;
}
static int
-add_iterator (void *cls,
- GNUNET_HashCode * next)
+add_iterator (void *cls, GNUNET_HashCode * next)
{
int *ret = cls;
GNUNET_HashCode pos;
unsigned int i;
unsigned int j;
size_t s;
- const void *p;
+ const void *p;
GNUNET_log_setup ("test-container-slist", "WARNING", NULL);
CHECK (GNUNET_CONTAINER_slist_count (l) == 0);
for (i = 0; i < 100; i++)
- GNUNET_CONTAINER_slist_add (l, GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT, &i, sizeof (i));
+ GNUNET_CONTAINER_slist_add (l,
+ GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+ &i, sizeof (i));
CHECK (GNUNET_CONTAINER_slist_count (l) == 100);
for (it = GNUNET_CONTAINER_slist_begin (l), i = 99;
CHECK (s == sizeof (i));
j *= 2;
- GNUNET_CONTAINER_slist_insert (it, GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT, &j,
- sizeof (j));
+ GNUNET_CONTAINER_slist_insert (it,
+ GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+ &j, sizeof (j));
}
GNUNET_free (it);
CHECK (GNUNET_CONTAINER_slist_count (l) == 200);
CHECK (GNUNET_CONTAINER_slist_count (l) == 0);
for (i = 0; i < 100; i++)
- GNUNET_CONTAINER_slist_add (l, GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT, &i, sizeof (i));
+ GNUNET_CONTAINER_slist_add (l,
+ GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+ &i, sizeof (i));
GNUNET_CONTAINER_slist_destroy (l);
}
size = GNUNET_CRYPTO_aes_decrypt (result, size,
&key,
- (const struct
+ (const struct
GNUNET_CRYPTO_AesInitializationVector *)
INITVALUE, res);
if (strlen (TESTSTRING) + 1 != size)
GNUNET_CRYPTO_aes_decrypt (result,
GNUNET_CRYPTO_AES_KEY_LENGTH,
&key,
- (const struct
+ (const struct
GNUNET_CRYPTO_AesInitializationVector *)
"testtesttesttest", res))
{
continue;
}
if (GNUNET_SYSERR !=
- GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_TCP_PING,
- &purp, &sig, &pkey))
+ GNUNET_CRYPTO_rsa_verify
+ (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_TCP_PING, &purp, &sig, &pkey))
{
printf ("GNUNET_CRYPTO_rsa_verify failed to fail!\n");
ok = GNUNET_SYSERR;
if (strncmp (TESTSTRING, result, strlen (TESTSTRING)) != 0)
{
printf ("%s != %.*s - testEncryptDecrypt failed!\n",
- TESTSTRING,
- (int) MAX_TESTVAL,
- result);
+ TESTSTRING, (int) MAX_TESTVAL, result);
ok++;
continue;
}
continue;
}
if (GNUNET_SYSERR !=
- GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_TCP_PING,
- &purp, &sig, &pkey))
+ GNUNET_CRYPTO_rsa_verify
+ (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_TCP_PING, &purp, &sig, &pkey))
{
printf ("GNUNET_CRYPTO_rsa_verify failed to fail!\n");
ok = GNUNET_SYSERR;
}
}
printf ("%d RSA sign operations %llu ms\n", ITER,
- (unsigned long long) GNUNET_TIME_absolute_get_duration (start).value);
+ (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+ value);
GNUNET_CRYPTO_rsa_key_free (hostkey);
return ok;
}
char tmp[100 + 1];
int ret;
- if (strlen(TESTSTRING) !=
- GNUNET_DISK_fn_write (".testfile", TESTSTRING,
- strlen (TESTSTRING),
- GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE))
+ if (strlen (TESTSTRING) !=
+ GNUNET_DISK_fn_write (".testfile", TESTSTRING,
+ strlen (TESTSTRING),
+ GNUNET_DISK_PERM_USER_READ |
+ GNUNET_DISK_PERM_USER_WRITE))
return 1;
if (GNUNET_OK != GNUNET_DISK_file_test (".testfile"))
return 1;
long avail;
fh = GNUNET_DISK_file_open (".testfile", GNUNET_DISK_OPEN_READWRITE
- | GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_PERM_USER_READ
- | GNUNET_DISK_PERM_USER_WRITE);
+ | GNUNET_DISK_OPEN_CREATE,
+ GNUNET_DISK_PERM_USER_READ |
+ GNUNET_DISK_PERM_USER_WRITE);
GNUNET_assert (GNUNET_NO == GNUNET_DISK_handle_invalid (fh));
GNUNET_break (5 == GNUNET_DISK_file_write (fh, "Hello", 5));
GNUNET_DISK_file_close (fh);
avail = GNUNET_DISK_get_blocks_available (".testfile");
GNUNET_log_skip (0, GNUNET_NO);
fh = GNUNET_DISK_file_open (".testfile", GNUNET_DISK_OPEN_READWRITE
- | GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_PERM_USER_WRITE
- | GNUNET_DISK_PERM_USER_READ);
+ | GNUNET_DISK_OPEN_CREATE,
+ GNUNET_DISK_PERM_USER_WRITE |
+ GNUNET_DISK_PERM_USER_READ);
GNUNET_assert (GNUNET_NO == GNUNET_DISK_handle_invalid (fh));
while ((avail == GNUNET_DISK_get_blocks_available (".testfile")) &&
(avail != -1))
static int
testDirScan ()
{
- if (GNUNET_OK != GNUNET_DISK_directory_create ("test" DIR_SEPARATOR_STR "entry"))
+ if (GNUNET_OK !=
+ GNUNET_DISK_directory_create ("test" DIR_SEPARATOR_STR "entry"))
return 1;
- if (GNUNET_OK != GNUNET_DISK_directory_create ("test" DIR_SEPARATOR_STR "entry_more"))
+ if (GNUNET_OK !=
+ GNUNET_DISK_directory_create ("test" DIR_SEPARATOR_STR "entry_more"))
return 1;
- GNUNET_DISK_directory_scan ("test", &scan_callback, "test" DIR_SEPARATOR_STR "entry");
+ GNUNET_DISK_directory_scan ("test", &scan_callback,
+ "test" DIR_SEPARATOR_STR "entry");
if (GNUNET_OK != GNUNET_DISK_directory_remove ("test"))
return 1;
if (ok < 2)
GNUNET_GETOPT_OPTION_END
};
- if (-1 != GNUNET_GETOPT_run ("test_getopt",
- versionoptionlist, 2, myargv))
+ if (-1 != GNUNET_GETOPT_run ("test_getopt", versionoptionlist, 2, myargv))
{
GNUNET_break (0);
return 1;
GNUNET_GETOPT_OPTION_END
};
- if (-1 != GNUNET_GETOPT_run ("test_getopt",
- aboutoptionlist, 2, myargv))
+ if (-1 != GNUNET_GETOPT_run ("test_getopt", aboutoptionlist, 2, myargv))
{
GNUNET_break (0);
return 1;
}
memset (buf, 42, sizeof (buf));
fh = GNUNET_DISK_file_open (".loadfile", GNUNET_DISK_OPEN_WRITE
- | GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_PERM_USER_READ
- | GNUNET_DISK_PERM_USER_WRITE);
- GNUNET_assert (GNUNET_NO == GNUNET_DISK_handle_invalid(fh));
+ | GNUNET_DISK_OPEN_CREATE,
+ GNUNET_DISK_PERM_USER_READ |
+ GNUNET_DISK_PERM_USER_WRITE);
+ GNUNET_assert (GNUNET_NO == GNUNET_DISK_handle_invalid (fh));
while (GNUNET_TIME_absolute_get_duration (start).value < 60 * 1000)
{
- GNUNET_DISK_file_seek (fh, GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
- 1024 * 1024 * 1024), GNUNET_DISK_SEEK_SET);
- GNUNET_assert (sizeof (buf) == GNUNET_DISK_file_write (fh, buf, sizeof (buf)));
+ GNUNET_DISK_file_seek (fh,
+ GNUNET_CRYPTO_random_u64
+ (GNUNET_CRYPTO_QUALITY_WEAK, 1024 * 1024 * 1024),
+ GNUNET_DISK_SEEK_SET);
+ GNUNET_assert (sizeof (buf) ==
+ GNUNET_DISK_file_write (fh, buf, sizeof (buf)));
GNUNET_DISK_file_sync (fh);
if (ret < GNUNET_OS_load_disk_get (cfg))
break;
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Got IP address `%s' for our host.\n"),
- GNUNET_a2s (sa, salen));
+ _("Got IP address `%s' for our host.\n"),
+ GNUNET_a2s (sa, salen));
}
run (void *cls,
struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
- const char *cfgfile,
- const struct GNUNET_CONFIGURATION_Handle *cfg)
+ const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct sockaddr_in sa;
struct GNUNET_TIME_Relative timeout =
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
ok = 1;
}
- GNUNET_OS_process_wait(pid);
+ GNUNET_OS_process_wait (pid);
if (ok != 0)
fprintf (stderr, "Missed some resolutions: %u\n", ok);
return ok;
fds[0] = GNUNET_DISK_pipe_handle (p, GNUNET_DISK_PIPE_END_READ);
fds[1] = GNUNET_DISK_pipe_handle (p, GNUNET_DISK_PIPE_END_WRITE);
GNUNET_SCHEDULER_add_read_file (tc->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_UNIT_FOREVER_REL,
- fds[0], &taskRd, cls);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ fds[0], &taskRd, cls);
GNUNET_SCHEDULER_add_write_file (tc->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_UNIT_FOREVER_REL,
- fds[1], &taskWrt, cls);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ fds[1], &taskWrt, cls);
}
t2 = GNUNET_SCHEDULER_add_after (tc->sched,
GNUNET_NO,
GNUNET_SCHEDULER_PRIORITY_IDLE,
- GNUNET_SCHEDULER_NO_TASK,
- &task2, cls);
+ GNUNET_SCHEDULER_NO_TASK, &task2, cls);
/* t3 will go before t4: higher priority */
t4 = GNUNET_SCHEDULER_add_after (tc->sched,
GNUNET_NO,
GNUNET_SCHEDULER_PRIORITY_IDLE,
t2, &task4, cls);
GNUNET_SCHEDULER_add_delayed (tc->sched,
- GNUNET_NO,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- t2,
- GNUNET_TIME_relative_get_zero (),
- &task3, cls);
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ t2,
+ GNUNET_TIME_relative_get_zero (),
+ &task3, cls);
/* t4 will go first: lower prio, but prereq! */
GNUNET_SCHEDULER_add_after (tc->sched,
GNUNET_NO,
*ok = 2; /* report success */
msg.type = htons (MY_TYPE2);
msg.size = htons (sizeof (struct GNUNET_MessageHeader));
- receiver (receiver_cls, &msg, sizeof (struct GNUNET_MessageHeader), NULL, 0, 0);
+ receiver (receiver_cls, &msg, sizeof (struct GNUNET_MessageHeader),
+ NULL, 0, 0);
break;
case 3:
/* called after first receive instantly
256,
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS, 250),
- GNUNET_NO,
- ¬ify_ready, NULL);
+ GNUNET_NO, ¬ify_ready, NULL);
}
256,
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS, 250),
- GNUNET_NO,
- ¬ify_ready, NULL);
+ GNUNET_NO, ¬ify_ready, NULL);
}
GNUNET_CLIENT_notify_transmit_ready (client,
sizeof (struct GNUNET_MessageHeader),
GNUNET_TIME_UNIT_SECONDS,
- GNUNET_NO,
- &build_msg, client);
+ GNUNET_NO, &build_msg, client);
}
static void
GNUNET_SERVER_add_handlers (server, myhandlers);
GNUNET_CLIENT_service_test (sched,
"test_service",
- cfg, GNUNET_TIME_UNIT_SECONDS, &ready, (void*) cfg);
+ cfg, GNUNET_TIME_UNIT_SECONDS, &ready,
+ (void *) cfg);
}
static void
-term (void *cls,
- const struct GNUNET_CONFIGURATION_Handle *cfg)
+term (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
int *ok = cls;
*ok = 0;
GNUNET_CLIENT_notify_transmit_ready (client,
sizeof (struct GNUNET_MessageHeader),
GNUNET_TIME_UNIT_SECONDS,
- GNUNET_NO,
- &build_msg, client);
+ GNUNET_NO, &build_msg, client);
}
static void
GNUNET_SERVER_add_handlers (server, myhandlers);
GNUNET_CLIENT_service_test (sched,
"test_service6",
- cfg, GNUNET_TIME_UNIT_SECONDS, &ready6, (void*) cfg);
+ cfg, GNUNET_TIME_UNIT_SECONDS, &ready6,
+ (void *) cfg);
}
/**
start_stop_main (void *cls,
struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
- const char *cfgfile,
- const struct GNUNET_CONFIGURATION_Handle *cfg)
+ const char *cfgfile,
+ const struct GNUNET_CONFIGURATION_Handle *cfg)
{
int *ret = cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
struct timeval tv;
GETTIMEOFDAY (&tv, NULL);
- ret.value = (uint64_t) (((uint64_t) tv.tv_sec * 1000LL) + ((uint64_t) tv.tv_usec / 1000LL));
+ ret.value =
+ (uint64_t) (((uint64_t) tv.tv_sec * 1000LL) +
+ ((uint64_t) tv.tv_usec / 1000LL));
return ret;
}
GNUNET_TIME_relative_to_absolute (struct GNUNET_TIME_Relative rel)
{
struct GNUNET_TIME_Absolute ret;
- if (rel.value == (uint64_t) -1LL)
+ if (rel.value == (uint64_t) - 1LL)
return GNUNET_TIME_absolute_get_forever ();
struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
if (rel.value + now.value < rel.value)
* @param t2 other timestamp
* @return timestamp that is smaller
*/
-struct GNUNET_TIME_Relative GNUNET_TIME_relative_min (struct
- GNUNET_TIME_Relative
- t1,
- struct
- GNUNET_TIME_Relative t2)
+struct GNUNET_TIME_Relative
+GNUNET_TIME_relative_min (struct
+ GNUNET_TIME_Relative
+ t1, struct GNUNET_TIME_Relative t2)
{
return (t1.value < t2.value) ? t1 : t2;
}
* @param t2 other timestamp
* @return timestamp that is smaller
*/
-struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_min (struct
- GNUNET_TIME_Absolute
- t1,
- struct
- GNUNET_TIME_Absolute t2)
+struct GNUNET_TIME_Absolute
+GNUNET_TIME_absolute_min (struct
+ GNUNET_TIME_Absolute
+ t1, struct GNUNET_TIME_Absolute t2)
{
return (t1.value < t2.value) ? t1 : t2;
}
{
GNUNET_break (0);
return GNUNET_TIME_relative_get_forever ();
- }
+ }
return ret;
}
* @return remaining duration for the operation,
* assuming it continues at the same speed
*/
-struct GNUNET_TIME_Relative GNUNET_TIME_calculate_eta (struct GNUNET_TIME_Absolute start,
- uint64_t finished,
- uint64_t total)
+struct GNUNET_TIME_Relative
+GNUNET_TIME_calculate_eta (struct GNUNET_TIME_Absolute start,
+ uint64_t finished, uint64_t total)
{
struct GNUNET_TIME_Relative dur;
double exp;
if (finished == 0)
return GNUNET_TIME_UNIT_FOREVER_REL;
dur = GNUNET_TIME_absolute_get_duration (start);
- exp = ((double)dur.value) * ((double) total) / ((double)finished);
+ exp = ((double) dur.value) * ((double) total) / ((double) finished);
ret.value = ((uint64_t) exp) - dur.value;
return ret;
}
plibc_panic (int err, char *msg)
{
GNUNET_log (((err ==
- INT_MAX) ? GNUNET_ERROR_TYPE_DEBUG : GNUNET_ERROR_TYPE_ERROR),
- "%s", msg);
+ INT_MAX) ? GNUNET_ERROR_TYPE_DEBUG : GNUNET_ERROR_TYPE_ERROR),
+ "%s", msg);
}
/**
projects / oweals / gnunet.git / commitdiff