X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Futil%2Fnetwork.c;h=5fe25da3bc747f472dd0771c5933fa13750ff02f;hb=72c8645af31896829b674b575c5375706f362a30;hp=012b1af0bdfbb0066c9612fe85226b0a31bd4aa2;hpb=3baea2d237e0b223fac6cbfa4fd3f830ecc16caa;p=oweals%2Fgnunet.git diff --git a/src/util/network.c b/src/util/network.c index 012b1af0b..5fe25da3b 100644 --- a/src/util/network.c +++ b/src/util/network.c @@ -66,6 +66,34 @@ struct GNUNET_NETWORK_Handle }; +/** + * Test if the given protocol family is supported by this system. + * + * @param pf protocol family to test (PF_INET, PF_INET6, PF_UNIX) + * @return GNUNET_OK if the PF is supported + */ +int +GNUNET_NETWORK_test_pf (int pf) +{ + int s; + + s = socket (pf, SOCK_STREAM, 0); + if (-1 == s) + { + if (EAFNOSUPPORT == errno) + return GNUNET_NO; + fprintf (stderr, "Failed to create test socket: %s\n", STRERROR (errno)); + return GNUNET_SYSERR; + } +#if WINDOWS + closesocket (s); +#else + close (s); +#endif + return GNUNET_OK; +} + + /** * Given a unixpath that is too long (larger than UNIX_PATH_MAX), * shorten it to an acceptable length while keeping it unique @@ -116,12 +144,13 @@ GNUNET_NETWORK_shorten_unixpath (char *unixpath) /** * Set if a socket should use blocking or non-blocking IO. + * * @param fd socket * @param doBlock blocking mode * @return GNUNET_OK on success, GNUNET_SYSERR on error */ -static int -socket_set_blocking (struct GNUNET_NETWORK_Handle *fd, int doBlock) +int +GNUNET_NETWORK_socket_set_blocking (struct GNUNET_NETWORK_Handle *fd, int doBlock) { #if MINGW @@ -163,7 +192,6 @@ socket_set_blocking (struct GNUNET_NETWORK_Handle *fd, int doBlock) } -#ifndef MINGW /** * Make a socket non-inheritable to child processes * @@ -174,8 +202,8 @@ socket_set_blocking (struct GNUNET_NETWORK_Handle *fd, int doBlock) static int socket_set_inheritable (const struct GNUNET_NETWORK_Handle *h) { +#ifndef MINGW int i; - i = fcntl (h->fd, F_GETFD); if (i < 0) return GNUNET_SYSERR; @@ -184,9 +212,18 @@ socket_set_inheritable (const struct GNUNET_NETWORK_Handle *h) i |= FD_CLOEXEC; if (fcntl (h->fd, F_SETFD, i) < 0) return GNUNET_SYSERR; +#else + BOOL b; + SetLastError (0); + b = SetHandleInformation ((HANDLE) h->fd, HANDLE_FLAG_INHERIT, 0); + if (!b) + { + SetErrnoFromWinsockError (WSAGetLastError ()); + return GNUNET_SYSERR; + } +#endif return GNUNET_OK; } -#endif #ifdef DARWIN @@ -266,11 +303,12 @@ initialize_network_handle (struct GNUNET_NETWORK_Handle *h, errno = EMFILE; return GNUNET_SYSERR; } +#endif if (GNUNET_OK != socket_set_inheritable (h)) LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "socket_set_inheritable"); -#endif - if (GNUNET_SYSERR == socket_set_blocking (h, GNUNET_NO)) + + if (GNUNET_SYSERR == GNUNET_NETWORK_socket_set_blocking (h, GNUNET_NO)) { GNUNET_break (0); GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (h)); @@ -326,35 +364,44 @@ GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc, /** * Bind to a connected socket - * @param desc socket + * + * @param desc socket to bind * @param address address to be bound * @param address_len length of address + * @param flags flags affecting bind behaviour * @return GNUNET_OK on success, GNUNET_SYSERR otherwise */ int GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc, const struct sockaddr *address, - socklen_t address_len) + socklen_t address_len, + int flags) { int ret; #ifdef IPV6_V6ONLY #ifdef IPPROTO_IPV6 - const int on = 1; + { + const int on = 1; - if (desc->af == AF_INET6) - if (0 != setsockopt (desc->fd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof (on))) - LOG_STRERROR (GNUNET_ERROR_TYPE_DEBUG, "setsockopt"); + if (desc->af == AF_INET6) + if (setsockopt (desc->fd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof (on))) + LOG_STRERROR (GNUNET_ERROR_TYPE_DEBUG, "setsockopt"); + } #endif #endif #ifndef WINDOWS - /* This is required, and required here, but only on UNIX */ - if (0 != setsockopt (desc->fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on))) - LOG_STRERROR (GNUNET_ERROR_TYPE_DEBUG, "setsockopt"); + { + const int on = 1; + + /* This is required, and required here, but only on UNIX */ + if (0 != setsockopt (desc->fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on))) + LOG_STRERROR (GNUNET_ERROR_TYPE_DEBUG, "setsockopt"); + } #endif #ifndef LINUX #ifndef MINGW - if (address->sa_family == AF_UNIX) + if (address->sa_family == AF_UNIX && (flags & GNUNET_BIND_EXCLUSIVE) == 0) { const struct sockaddr_un *un = (const struct sockaddr_un *) address; @@ -859,6 +906,7 @@ void GNUNET_NETWORK_fdset_add (struct GNUNET_NETWORK_FDSet *dst, const struct GNUNET_NETWORK_FDSet *src) { +#ifndef MINGW int nfds; for (nfds = src->nsds; nfds > 0; nfds--) @@ -869,7 +917,18 @@ GNUNET_NETWORK_fdset_add (struct GNUNET_NETWORK_FDSet *dst, if (nfds + 1 > dst->nsds) dst->nsds = nfds + 1; } -#ifdef MINGW +#else + /* This is MinGW32-specific implementation that relies on the code that + * winsock2.h defines for FD_SET. Namely, it relies on FD_SET checking + * that fd being added is not already in the set. + * Also relies on us knowing what's inside fd_set (fd_count and fd_array). + */ + int i; + for (i = 0; i < src->sds.fd_count; i++) + FD_SET (src->sds.fd_array[i], &dst->sds); + if (src->nsds > dst->nsds) + dst->nsds = src->nsds; + GNUNET_CONTAINER_slist_append (dst->handles, src->handles); #endif } @@ -1146,7 +1205,7 @@ static DWORD WINAPI _selector (LPVOID p) { struct _select_params *sp = p; - int i; + while (1) { WaitForSingleObject (sp->standby, INFINITE); @@ -1212,6 +1271,8 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds, struct GNUNET_CONTAINER_SList *handles_write; struct GNUNET_CONTAINER_SList *handles_except; + int selectret = 0; + fd_set aread; fd_set awrite; fd_set aexcept; @@ -1273,11 +1334,11 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds, #endif ) { + GNUNET_break (0); LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Fatal internal logic error, process hangs in `%s' (abort with CTRL-C)!\n"), "select"); - GNUNET_break (0); } #ifndef MINGW tv.tv_sec = timeout.rel_value / GNUNET_TIME_UNIT_SECONDS.rel_value; @@ -1328,6 +1389,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds, p = 1; res = ioctlsocket (select_wakeup_socket, FIONBIO, &p); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Select thread initialization: ioctlsocket() returns %d\n", res); alen = sizeof (s_in); s_in.sin_family = AF_INET; @@ -1337,12 +1399,16 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds, s_in.sin_addr.S_un.S_un_b.s_b3 = 0; s_in.sin_addr.S_un.S_un_b.s_b4 = 1; res = bind (select_listening_socket, (const struct sockaddr *) &s_in, sizeof (s_in)); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Select thread initialization: bind() returns %d\n", res); res = getsockname (select_listening_socket, (struct sockaddr *) &s_in, &alen); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Select thread initialization: getsockname() returns %d\n", res); res = listen (select_listening_socket, SOMAXCONN); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Select thread initialization: listen() returns %d\n", res); res = connect (select_wakeup_socket, (const struct sockaddr *) &s_in, sizeof (s_in)); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Select thread initialization: connect() returns %d\n", res); select_send_socket = accept (select_listening_socket, (struct sockaddr *) &s_in, &alen); @@ -1355,6 +1421,191 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds, select_thread = CreateThread (NULL, 0, _selector, &sp, 0, NULL); } + + handles_read = GNUNET_CONTAINER_slist_create (); + handles_write = GNUNET_CONTAINER_slist_create (); + handles_except = GNUNET_CONTAINER_slist_create (); + FD_ZERO (&aread); + FD_ZERO (&awrite); + FD_ZERO (&aexcept); +#if DEBUG_NETWORK + FD_ZERO (&bread); + FD_ZERO (&bwrite); + FD_ZERO (&bexcept); +#endif + if (rfds) + { + FD_COPY (&rfds->sds, &aread); +#if DEBUG_NETWORK + FD_COPY (&rfds->sds, &bread); +#endif + } + if (wfds) + { + FD_COPY (&wfds->sds, &awrite); +#if DEBUG_NETWORK + FD_COPY (&wfds->sds, &bwrite); +#endif + } + if (efds) + { + FD_COPY (&efds->sds, &aexcept); +#if DEBUG_NETWORK + FD_COPY (&efds->sds, &bexcept); +#endif + } + + /* Start by doing a fast check on sockets and pipes (without waiting). It is cheap, and is sufficient most of the time. + By profiling we detected that to be true in 90% of the cases. + */ + + /* Do the select now */ + select_timeout.tv_sec = 0; + select_timeout.tv_usec = 0; + + /* Copy all the writes to the except, so we can detect connect() errors */ + for (i = 0; i < awrite.fd_count; i++) + FD_SET (awrite.fd_array[i], &aexcept); + if (aread.fd_count > 0 || awrite.fd_count > 0 || aexcept.fd_count > 0) + selectret = select (1, (rfds != NULL) ? &aread : NULL, + (wfds != NULL) ? &awrite : NULL, &aexcept, &select_timeout); + else + selectret = 0; + if (selectret == -1) + { + /* Throw an error early on, while we still have the context. */ + LOG (GNUNET_ERROR_TYPE_ERROR, "W32 select(%d, %d, %d) failed: %lu\n", + rfds ? aread.fd_count : 0, wfds ? awrite.fd_count : 0, aexcept.fd_count, GetLastError ()); + GNUNET_abort (); + } + + /* Check aexcept, add its contents to awrite + This is technically wrong (aexcept might have its own descriptors), we should + have checked that descriptors were in awrite originally before re-adding them from + aexcept. Luckily, GNUnet never uses aexcept for anything, so this does not become a problem (yet). */ + for (i = 0; i < aexcept.fd_count; i++) + FD_SET (aexcept.fd_array[i], &awrite); + + /* If our select returned something or is a 0-timed request, then also check the pipes and get out of here! */ + /* Sadly, it means code duplication :( */ + if ((selectret > 0) || (ms_total == 0)) + { + /* Read Pipes */ + if (rfds && read_handles) + { + struct GNUNET_CONTAINER_SList_Iterator i; + int c; + + for (c = 0, i = GNUNET_CONTAINER_slist_begin (rfds->handles); + GNUNET_CONTAINER_slist_end (&i) != GNUNET_YES; + GNUNET_CONTAINER_slist_next (&i), c++) + { + struct GNUNET_DISK_FileHandle *fh; + + fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (&i,NULL); + if (fh->type == GNUNET_DISK_HANLDE_TYPE_PIPE) + { + DWORD error; + BOOL bret; + + SetLastError (0); + DWORD waitstatus = 0; + bret = PeekNamedPipe (fh->h, NULL, 0, NULL, &waitstatus, NULL); + error = GetLastError (); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Peek at read pipe %d (0x%x) returned %d (%d bytes available) GLE %u\n", + c, fh->h, bret, waitstatus, error); + if (bret == 0) + { + /* TODO: either add more errors to this condition, or eliminate it + * entirely (failed to peek -> pipe is in serious trouble, should + * be selected as readable). + */ + if (error != ERROR_BROKEN_PIPE && error != ERROR_INVALID_HANDLE) + continue; + } + else if (waitstatus <= 0) + continue; + GNUNET_CONTAINER_slist_add (handles_read, GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT, + fh, sizeof (struct GNUNET_DISK_FileHandle)); + retcode++; + LOG (GNUNET_ERROR_TYPE_DEBUG, "Added read Pipe 0x%x (0x%x)\n", + fh, fh->h); + } + else + { + GNUNET_CONTAINER_slist_add (handles_read, GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT, + fh, sizeof (struct GNUNET_DISK_FileHandle)); + retcode++; + } + } + } + if (wfds && write_handles) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Adding the write ready event to the array as %d\n", nhandles); + GNUNET_CONTAINER_slist_append (handles_write, wfds->handles); + retcode += write_handles; + } + if (efds && ex_handles) + { + struct GNUNET_CONTAINER_SList_Iterator i; + + for (i = GNUNET_CONTAINER_slist_begin (efds->handles); + GNUNET_CONTAINER_slist_end (&i) != GNUNET_YES; + GNUNET_CONTAINER_slist_next (&i)) + { + struct GNUNET_DISK_FileHandle *fh; + DWORD dwBytes; + + fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (&i, NULL); + if (fh->type == GNUNET_DISK_HANLDE_TYPE_PIPE) + { + if (PeekNamedPipe (fh->h, NULL, 0, NULL, &dwBytes, NULL)) + continue; + GNUNET_CONTAINER_slist_add (handles_except, GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT, + fh, sizeof (struct GNUNET_DISK_FileHandle)); + retcode++; + } + } + } + + /* Add our select() result.*/ + if (selectret >= 0) + retcode += selectret; + + if (rfds) + { + GNUNET_NETWORK_fdset_zero (rfds); + if (selectret != -1) + GNUNET_NETWORK_fdset_copy_native (rfds, &aread, selectret); + GNUNET_CONTAINER_slist_append (rfds->handles, handles_read); + } + if (wfds) + { + GNUNET_NETWORK_fdset_zero (wfds); + if (selectret != -1) + GNUNET_NETWORK_fdset_copy_native (wfds, &awrite, selectret); + GNUNET_CONTAINER_slist_append (wfds->handles, handles_write); + } + if (efds) + { + GNUNET_NETWORK_fdset_zero (efds); + if (selectret != -1) + GNUNET_NETWORK_fdset_copy_native (efds, &aexcept, selectret); + GNUNET_CONTAINER_slist_append (efds->handles, handles_except); + } + GNUNET_CONTAINER_slist_destroy (handles_read); + GNUNET_CONTAINER_slist_destroy (handles_write); + GNUNET_CONTAINER_slist_destroy (handles_except); + + if (selectret == -1) + return -1; + return retcode; + } + + /* If we got this far, use slower implementation that is able to do a waiting select + on both sockets and pipes simultaneously */ + /* Events for pipes */ if (!hEventReadReady) hEventReadReady = CreateEvent (NULL, TRUE, TRUE, NULL); @@ -1363,9 +1614,8 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds, readPipes = 0; writePipePos = -1; - handles_read = GNUNET_CONTAINER_slist_create (); - handles_write = GNUNET_CONTAINER_slist_create (); - handles_except = GNUNET_CONTAINER_slist_create (); + retcode = 0; + FD_ZERO (&aread); FD_ZERO (&awrite); FD_ZERO (&aexcept); @@ -1409,7 +1659,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds, fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (&i, NULL); - if (fh->type == GNUNET_PIPE) + if (fh->type == GNUNET_DISK_HANLDE_TYPE_PIPE) { /* Read zero bytes to check the status of the pipe */ LOG (GNUNET_ERROR_TYPE_DEBUG, "Reading 0 bytes from the pipe 0x%x\n", @@ -1470,7 +1720,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds, fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (&i, NULL); - if (fh->type == GNUNET_PIPE) + if (fh->type == GNUNET_DISK_HANLDE_TYPE_PIPE) { if (!PeekNamedPipe (fh->h, NULL, 0, NULL, &dwBytes, NULL)) { @@ -1511,10 +1761,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds, * but we don't use OOB data. */ for (i = 0; i < awrite.fd_count; i++) - { - if (awrite.fd_array[i] != 0 && awrite.fd_array[i] != -1) - FD_SET (awrite.fd_array[i], &aexcept); - } + FD_SET (awrite.fd_array[i], &aexcept); ResetEvent (select_finished_event); SetEvent (select_standby_event); } @@ -1558,10 +1805,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds, } /* Check aexcept, add its contents to awrite */ for (i = 0; i < aexcept.fd_count; i++) - { - if (aexcept.fd_array[i] != 0 && aexcept.fd_array[i] != -1) - FD_SET (aexcept.fd_array[i], &awrite); - } + FD_SET (aexcept.fd_array[i], &awrite); } returnedpos = returncode - WAIT_OBJECT_0; @@ -1632,7 +1876,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds, fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (&t, NULL); - if (fh->type == GNUNET_PIPE) + if (fh->type == GNUNET_DISK_HANLDE_TYPE_PIPE) { CancelIo (fh->h); }