#include <winsock2.h>
#include <ws2tcpip.h>
#else
+#include <signal.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/tcp.h>
#endif
+#ifndef EWOULDBLOCK
+#define EWOULDBLOCK EAGAIN
+#endif
+
#define MAXLOG 1024
iohandler_log_callback *iolog_backend = NULL;
dstaddrlen = sizeof(*ip4);
} else
return NULL;
+ //prevent SIGPIPE
+ #ifndef WIN32
+ #if defined(SO_NOSIGPIPE)
+ {
+ int set = 1;
+ setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&set, sizeof(int));
+ }
+ #else
+ signal(SIGPIPE, SIG_IGN);
+ #endif
+ #endif
//make sockfd unblocking
-#if defined(F_GETFL)
+ #if defined(F_GETFL)
{
int flags;
flags = fcntl(sockfd, F_GETFL);
flags = fcntl(sockfd, F_GETFD);
fcntl(sockfd, F_SETFD, flags|FD_CLOEXEC);
}
-#else
+ #else
/* I hope you're using the Win32 backend or something else that
* automatically marks the file descriptor non-blocking...
*/
-#endif
+ #endif
descriptor = iohandler_add(sockfd, IOTYPE_CLIENT, NULL, callback);
if(!descriptor) {
close(sockfd);
bind(sockfd, (struct sockaddr*)ip4, sizeof(*ip4));
} else
return NULL;
+ //prevent SIGPIPE
+ #ifndef WIN32
+ #if defined(SO_NOSIGPIPE)
+ {
+ int set = 1;
+ setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&set, sizeof(int));
+ }
+ #else
+ signal(SIGPIPE, SIG_IGN);
+ #endif
+ #endif
//make sockfd unblocking
-#if defined(F_GETFL)
+ #if defined(F_GETFL)
{
int flags;
flags = fcntl(sockfd, F_GETFL);
flags = fcntl(sockfd, F_GETFD);
fcntl(sockfd, F_SETFD, flags|FD_CLOEXEC);
}
-#else
+ #else
/* I hope you're using the Win32 backend or something else that
* automatically marks the file descriptor non-blocking...
*/
-#endif
+ #endif
descriptor = iohandler_add(sockfd, IOTYPE_SERVER, NULL, callback);
if(!descriptor) {
close(sockfd);
iohandler_send(iofd, sendBuf, pos+1);
}
-void iohandler_try_write(struct IODescriptor *iofd) {
- if(!iofd->writebuf.bufpos) return;
+static int iohandler_try_write(struct IODescriptor *iofd) {
+ if(!iofd->writebuf.bufpos) return 0;
iohandler_log(IOLOG_DEBUG, "write writebuf (%d bytes) to socket (fd: %d)", iofd->writebuf.bufpos, iofd->fd);
int res;
if(iofd->ssl_active)
else
res = send(iofd->fd, iofd->writebuf.buffer, iofd->writebuf.bufpos, 0);
if(res < 0) {
- if (errno != EAGAIN) {
+ if (errno != EAGAIN && errno != EWOULDBLOCK)
iohandler_log(IOLOG_ERROR, "could not write to socket (fd: %d): %d - %s", iofd->fd, errno, strerror(errno));
- }
+ else
+ res = 0;
} else {
iofd->writebuf.bufpos -= res;
if(iofd->state != IO_CLOSED)
engine->update(iofd);
}
+ return res;
}
void iohandler_close(struct IODescriptor *iofd) {
bytes = recv(iofd->fd, iofd->readbuf.buffer + iofd->readbuf.bufpos, iofd->readbuf.buflen - iofd->readbuf.bufpos, 0);
}
if(bytes <= 0) {
- if (errno != EAGAIN) {
+ if (errno != EAGAIN || errno != EWOULDBLOCK) {
iofd->state = IO_CLOSED;
engine->update(iofd);
callback_event.type = IOEVENT_CLOSED;
callback_event.type = IOEVENT_READABLE;
}
if(writeable) {
- iohandler_try_write(iofd);
+ int bytes;
+ bytes = iohandler_try_write(iofd);
+ if(bytes < 0) {
+ iofd->state = IO_CLOSED;
+ engine->update(iofd);
+ callback_event.type = IOEVENT_CLOSED;
+ callback_event.data.errid = errno;
+ }
}
break;
}
}
void iohandler_poll() {
+ struct timeval timeout;
+ timeout.tv_sec = IO_MAX_TIMEOUT;
+ timeout.tv_usec = 0;
+ iohandler_poll_timeout(timeout);
+}
+
+void iohandler_poll_timeout(struct timeval timeout) {
if(engine) {
IOSYNCHRONIZE(io_poll_sync); //quite senceless multithread support... better support will follow
- struct timeval timeout;
- timeout.tv_sec = IO_MAX_TIMEOUT;
- timeout.tv_usec = 0;
engine->loop(&timeout);
IODESYNCHRONIZE(io_poll_sync);
}