// initialize cares
if((res = ares_init(&dnsengine_cares_channel)) != ARES_SUCCESS) {
iolog_trigger(IOLOG_ERROR, "Failed to initialize c-ares in %s:%d", __FILE__, __LINE__);
- return 0;
- }
- return 1;
+ return 0;
+ }
+ return 1;
}
static void dnsengine_cares_update_sockets() {
}
static void dnsengine_cares_loop() {
- /* empty */
+ /* empty */
}
struct IODNSEngine dnsengine_cares = {
- .name = "c-ares",
- .init = dnsengine_cares_init,
+ .name = "c-ares",
+ .init = dnsengine_cares_init,
.stop = dnsengine_cares_stop,
- .add = dnsengine_cares_add,
- .remove = dnsengine_cares_remove,
- .loop = dnsengine_cares_loop,
+ .add = dnsengine_cares_add,
+ .remove = dnsengine_cares_remove,
+ .loop = dnsengine_cares_loop,
.socket_callback = dnsengine_cares_socket_callback,
};
#else
struct IODNSEngine dnsengine_cares = {
- .name = "c-ares",
- .init = NULL,
+ .name = "c-ares",
+ .init = NULL,
.stop = NULL,
- .add = NULL,
- .remove = NULL,
- .loop = NULL,
+ .add = NULL,
+ .remove = NULL,
+ .loop = NULL,
.socket_callback = NULL,
};
#else
iodns_loop_blocking = 1;
#endif
- return 1;
+ return 1;
}
static void dnsengine_default_stop() {
}
static void dnsengine_default_add(struct _IODNSQuery *iodns) {
- #ifdef IODNS_USE_THREADS
+ #ifdef IODNS_USE_THREADS
if(iodns_thread_running) {
IOSYNCHRONIZE(iodns_sync2);
pthread_cond_signal(&iodns_cond);
}
static void dnsengine_default_remove(struct _IODNSQuery *iodns) {
- /* unused */
+ /* unused */
}
static void dnsengine_default_loop() {
- if(iodns_loop_blocking)
+ if(iodns_loop_blocking)
iodns_process_queries();
}
static void iodns_process_queries() {
enum IODNSEventType querystate;
- struct addrinfo hints, *res, *allres;
- struct _IODNSQuery *iodns, *next_iodns;
- struct IODNSResult *dnsresult;
+ struct addrinfo hints, *res, *allres;
+ struct _IODNSQuery *iodns, *next_iodns;
+ struct IODNSResult *dnsresult;
int ret;
iodns_process_queries_start:
IOSYNCHRONIZE(iodns_sync);
- for(iodns = iodnsquery_first; iodns; iodns = next_iodns) {
- next_iodns = iodns->next;
+ for(iodns = iodnsquery_first; iodns; iodns = next_iodns) {
+ next_iodns = iodns->next;
if(!(iodns->flags & IODNSFLAG_RUNNING))
continue;
IODESYNCHRONIZE(iodns_sync);
- querystate = IODNSEVENT_FAILED;
-
- if((iodns->type & IODNS_FORWARD)) {
- memset (&hints, 0, sizeof (hints));
- hints.ai_family = PF_UNSPEC;
- hints.ai_socktype = SOCK_STREAM;
- hints.ai_flags |= AI_CANONNAME;
- if (!(ret = getaddrinfo(iodns->request.host, NULL, &hints, &allres))) {
+ querystate = IODNSEVENT_FAILED;
+
+ if((iodns->type & IODNS_FORWARD)) {
+ memset (&hints, 0, sizeof (hints));
+ hints.ai_family = PF_UNSPEC;
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_flags |= AI_CANONNAME;
+ if (!(ret = getaddrinfo(iodns->request.host, NULL, &hints, &allres))) {
res = allres;
- while (res) {
- switch (res->ai_family) {
- case AF_INET:
- if((iodns->type & IODNS_RECORD_A)) {
- dnsresult = malloc(sizeof(*dnsresult));
- dnsresult->type = IODNS_RECORD_A;
- dnsresult->result.addr.addresslen = res->ai_addrlen;
- dnsresult->result.addr.address = calloc(dnsresult->result.addr.addresslen, 1);
+ while (res) {
+ switch (res->ai_family) {
+ case AF_INET:
+ if((iodns->type & IODNS_RECORD_A)) {
+ dnsresult = malloc(sizeof(*dnsresult));
+ dnsresult->type = IODNS_RECORD_A;
+ dnsresult->result.addr.addresslen = res->ai_addrlen;
+ dnsresult->result.addr.address = calloc(dnsresult->result.addr.addresslen, 1);
dnsresult->result.addr.address->sa_family = AF_INET;
- memcpy(dnsresult->result.addr.address, res->ai_addr, dnsresult->result.addr.addresslen);
- dnsresult->next = iodns->result;
- iodns->result = dnsresult;
-
- char str[INET_ADDRSTRLEN];
+ memcpy(dnsresult->result.addr.address, res->ai_addr, dnsresult->result.addr.addresslen);
+ dnsresult->next = iodns->result;
+ iodns->result = dnsresult;
+
+ char str[INET_ADDRSTRLEN];
inet_ntop( AF_INET, &((struct sockaddr_in *)dnsresult->result.addr.address)->sin_addr, str, INET_ADDRSTRLEN );
- iolog_trigger(IOLOG_DEBUG, "Resolved %s to (A): %s", iodns->request.host, str);
-
- querystate = IODNSEVENT_SUCCESS;
- }
- break;
- case AF_INET6:
- if((iodns->type & IODNS_RECORD_AAAA)) {
- dnsresult = malloc(sizeof(*dnsresult));
- dnsresult->type = IODNS_RECORD_AAAA;
- dnsresult->result.addr.addresslen = res->ai_addrlen;
- dnsresult->result.addr.address = calloc(dnsresult->result.addr.addresslen, 1);
+ iolog_trigger(IOLOG_DEBUG, "Resolved %s to (A): %s", iodns->request.host, str);
+
+ querystate = IODNSEVENT_SUCCESS;
+ }
+ break;
+ case AF_INET6:
+ if((iodns->type & IODNS_RECORD_AAAA)) {
+ dnsresult = malloc(sizeof(*dnsresult));
+ dnsresult->type = IODNS_RECORD_AAAA;
+ dnsresult->result.addr.addresslen = res->ai_addrlen;
+ dnsresult->result.addr.address = calloc(dnsresult->result.addr.addresslen, 1);
dnsresult->result.addr.address->sa_family = AF_INET6;
- memcpy(dnsresult->result.addr.address, res->ai_addr, dnsresult->result.addr.addresslen);
- dnsresult->next = iodns->result;
- iodns->result = dnsresult;
-
- char str[INET6_ADDRSTRLEN];
+ memcpy(dnsresult->result.addr.address, res->ai_addr, dnsresult->result.addr.addresslen);
+ dnsresult->next = iodns->result;
+ iodns->result = dnsresult;
+
+ char str[INET6_ADDRSTRLEN];
inet_ntop( AF_INET6, &((struct sockaddr_in6 *)dnsresult->result.addr.address)->sin6_addr, str, INET6_ADDRSTRLEN );
- iolog_trigger(IOLOG_DEBUG, "Resolved %s to (AAAA): %s", iodns->request.host, str);
-
- querystate = IODNSEVENT_SUCCESS;
- }
- break;
- }
- res = res->ai_next;
- }
- freeaddrinfo(allres);
- } else {
+ iolog_trigger(IOLOG_DEBUG, "Resolved %s to (AAAA): %s", iodns->request.host, str);
+
+ querystate = IODNSEVENT_SUCCESS;
+ }
+ break;
+ }
+ res = res->ai_next;
+ }
+ freeaddrinfo(allres);
+ } else {
iolog_trigger(IOLOG_WARNING, "getaddrinfo returned error code: %d", ret);
}
- } else if((iodns->type & IODNS_REVERSE)) {
+ } else if((iodns->type & IODNS_REVERSE)) {
char hostname[NI_MAXHOST];
if(!(ret = getnameinfo(iodns->request.addr.address, iodns->request.addr.addresslen, hostname, sizeof(hostname), NULL, 0, 0))) {
dnsresult = malloc(sizeof(*dnsresult));
IODESYNCHRONIZE(iodns_sync);
iodns_event_callback(iodns, querystate);
goto iodns_process_queries_start;
- }
+ }
}
struct IODNSEngine dnsengine_default = {
- .name = "default",
- .init = dnsengine_default_init,
+ .name = "default",
+ .init = dnsengine_default_init,
.stop = dnsengine_default_stop,
- .add = dnsengine_default_add,
- .remove = dnsengine_default_remove,
- .loop = dnsengine_default_loop,
+ .add = dnsengine_default_add,
+ .remove = dnsengine_default_remove,
+ .loop = dnsengine_default_loop,
.socket_callback = NULL,
};
#define PTHREAD_MUTEX_RECURSIVE_VAL PTHREAD_MUTEX_RECURSIVE
#endif
#define IOTHREAD_MUTEX_INIT(var) { \
- pthread_mutexattr_t mutex_attr; \
- pthread_mutexattr_init(&mutex_attr);\
- pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE_VAL);\
- pthread_mutex_init(&var, &mutex_attr); \
+ pthread_mutexattr_t mutex_attr; \
+ pthread_mutexattr_init(&mutex_attr);\
+ pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE_VAL);\
+ pthread_mutex_init(&var, &mutex_attr); \
}
#define IOSYNCHRONIZE(var) pthread_mutex_lock(&var)
#define IODESYNCHRONIZE(var) pthread_mutex_unlock(&var)
unsigned int flags : 8;
unsigned int type : 8;
- union {
+ union {
struct IODNSAddress addr;
char *host;
} request;
};
struct IODNSEngine {
- const char *name;
- int (*init)();
+ const char *name;
+ int (*init)();
void (*stop)();
- void (*add)(struct _IODNSQuery *query);
- void (*remove)(struct _IODNSQuery *query);
- void (*loop)();
+ void (*add)(struct _IODNSQuery *query);
+ void (*remove)(struct _IODNSQuery *query);
+ void (*loop)();
void (*socket_callback)(struct _IOSocket *iosock, int readable, int writeable);
};
typedef IODNS_CALLBACK(iodns_callback);
enum IODNSEventType {
- IODNSEVENT_SUCCESS,
- IODNSEVENT_FAILED
+ IODNSEVENT_SUCCESS,
+ IODNSEVENT_FAILED
};
#define IODNS_RECORD_A 0x01
struct IODNSQuery {
void *query;
- iodns_callback *callback;
- void *data;
+ iodns_callback *callback;
+ void *data;
};
struct IODNSResult {
- unsigned int type : 8;
- union {
+ unsigned int type : 8;
+ union {
struct IODNSAddress addr;
char *host;
} result;
- struct IODNSResult *next;
+ struct IODNSResult *next;
};
struct IODNSEvent {
- enum IODNSEventType type;
- struct IODNSQuery *query;
+ enum IODNSEventType type;
+ struct IODNSQuery *query;
struct IODNSResult *result;
};
return;
}
struct IOGCObject *obj = malloc(sizeof(*obj));
- if(!obj) {
- iolog_trigger(IOLOG_ERROR, "could not allocate memory for IOGCObject in %s:%d", __FILE__, __LINE__);
+ if(!obj) {
+ iolog_trigger(IOLOG_ERROR, "could not allocate memory for IOGCObject in %s:%d", __FILE__, __LINE__);
if(free_callback)
free_callback(object);
else
free(object);
- return;
- }
+ return;
+ }
obj->object = object;
obj->free_callback = free_callback;
gettimeofday(&obj->timeout, NULL);
#define MAXLOG 1024
void iolog_trigger(enum IOLogType type, char *text, ...) {
- va_list arg_list;
- char logBuf[MAXLOG+1];
- int pos;
- logBuf[0] = '\0';
- va_start(arg_list, text);
- pos = vsnprintf(logBuf, MAXLOG - 1, text, arg_list);
- va_end(arg_list);
- if (pos < 0 || pos > (MAXLOG - 1)) pos = MAXLOG - 1;
- logBuf[pos] = '\n';
- logBuf[pos+1] = '\0';
-
- struct iolog_callback_entry *callback;
+ va_list arg_list;
+ char logBuf[MAXLOG+1];
+ int pos;
+ logBuf[0] = '\0';
+ va_start(arg_list, text);
+ pos = vsnprintf(logBuf, MAXLOG - 1, text, arg_list);
+ va_end(arg_list);
+ if (pos < 0 || pos > (MAXLOG - 1)) pos = MAXLOG - 1;
+ logBuf[pos] = '\n';
+ logBuf[pos+1] = '\0';
+
+ struct iolog_callback_entry *callback;
for(callback = iolog_callbacks; callback; callback = callback->next)
callback->callback(type, logBuf);
}
#endif
enum IOLogType {
- IOLOG_DEBUG,
- IOLOG_WARNING,
- IOLOG_ERROR,
- IOLOG_FATAL
+ IOLOG_DEBUG,
+ IOLOG_WARNING,
+ IOLOG_ERROR,
+ IOLOG_FATAL
};
#define IOLOG_CALLBACK(NAME) void NAME(enum IOLogType type, char *message)
#include <openssl/err.h>
struct IOSSLDescriptor {
- SSL *sslHandle;
- SSL_CTX *sslContext;
+ SSL *sslHandle;
+ SSL_CTX *sslContext;
};
#else
struct IOSSLDescriptor {
- //just unused
+ //just unused
};
#endif
void _init_sockets() {
#ifdef WIN32
WSADATA wsaData;
- int iResult;
+ int iResult;
//Initialize Winsock
- iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
- if(iResult != 0){
- iolog_trigger(IOLOG_ERROR, "WSAStartup returned error code: %d", iResult);
- }
+ iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
+ if(iResult != 0){
+ iolog_trigger(IOLOG_ERROR, "WSAStartup returned error code: %d", iResult);
+ }
#endif
iosockets_init_engine();\r
#include "IODNSAddress.struct.h"
struct IOSocketBuffer {
- char *buffer;
- size_t bufpos, buflen;
+ char *buffer;
+ size_t bufpos, buflen;
};
#ifndef _IOHandler_internals
struct IODNSEvent;
struct IOEngine {
- const char *name;
- int (*init)(void);
- void (*add)(struct _IOSocket *iosock);
- void (*remove)(struct _IOSocket *iosock);
- void (*update)(struct _IOSocket *iosock);
- void (*loop)(struct timeval *timeout);
- void (*cleanup)(void);
+ const char *name;
+ int (*init)(void);
+ void (*add)(struct _IOSocket *iosock);
+ void (*remove)(struct _IOSocket *iosock);
+ void (*update)(struct _IOSocket *iosock);
+ void (*loop)(struct timeval *timeout);
+ void (*cleanup)(void);
};
/* IO Engines */
};
struct _IOSocket {
- int fd;
+ int fd;
unsigned int socket_flags : 32;
unsigned int port : 16;
struct IOSocketBuffer readbuf;
- struct IOSocketBuffer writebuf;
+ struct IOSocketBuffer writebuf;
struct IOSSLDescriptor *sslnode;
typedef IOSOCKET_CALLBACK(iosocket_callback);
enum IOSocketStatus {
- IOSOCKET_CLOSED, /* descriptor is dead (socket waiting for removal or timer) */
- IOSOCKET_LISTENING, /* descriptor is waiting for connections (server socket) */
- IOSOCKET_CONNECTING, /* descriptor is waiting for connection approval (connecting client socket) */
- IOSOCKET_CONNECTED, /* descriptor is connected (connected client socket) */
+ IOSOCKET_CLOSED, /* descriptor is dead (socket waiting for removal or timer) */
+ IOSOCKET_LISTENING, /* descriptor is waiting for connections (server socket) */
+ IOSOCKET_CONNECTING, /* descriptor is waiting for connection approval (connecting client socket) */
+ IOSOCKET_CONNECTED, /* descriptor is connected (connected client socket) */
IOSOCKET_SSLHANDSHAKE /* descriptor is waiting for ssl (handshake) */
};
enum IOSocketEventType {
- IOSOCKETEVENT_IGNORE,
- IOSOCKETEVENT_RECV, /* client socket received something (read_lines == 1 => recv_str valid; read_lines == 0 => recv_buf valid) */
- IOSOCKETEVENT_CONNECTED, /* client socket connected successful */
- IOSOCKETEVENT_NOTCONNECTED, /* client socket could not connect (errid valid) */
- IOSOCKETEVENT_CLOSED, /* client socket lost connection (errid valid) */
- IOSOCKETEVENT_ACCEPT, /* server socket accepted new connection (accept_socket valid) */
+ IOSOCKETEVENT_IGNORE,
+ IOSOCKETEVENT_RECV, /* client socket received something (read_lines == 1 => recv_str valid; read_lines == 0 => recv_buf valid) */
+ IOSOCKETEVENT_CONNECTED, /* client socket connected successful */
+ IOSOCKETEVENT_NOTCONNECTED, /* client socket could not connect (errid valid) */
+ IOSOCKETEVENT_CLOSED, /* client socket lost connection (errid valid) */
+ IOSOCKETEVENT_ACCEPT, /* server socket accepted new connection (accept_socket valid) */
IOSOCKETEVENT_DNSFAILED /* failed to lookup DNS information (recv_str contains error message) */
};
};
struct IOSocketEvent {
- enum IOSocketEventType type;
- struct IOSocket *socket;
- union {
- char *recv_str;
+ enum IOSocketEventType type;
+ struct IOSocket *socket;
+ union {
+ char *recv_str;
struct IOSocketBuffer *recv_buf;
- int errid;
- struct IOSocket *accept_socket;
- } data;
+ int errid;
+ struct IOSocket *accept_socket;
+ } data;
};
struct IOSocket *iosocket_connect(const char *hostname, unsigned int port, int ssl, const char *bindhost, iosocket_callback *callback);
struct IOTimerDescriptor *iotimer_create(struct timeval *timeout) {
struct IOTimerDescriptor *descriptor = calloc(1, sizeof(*descriptor));
- if(!descriptor) {
- iolog_trigger(IOLOG_ERROR, "could not allocate memory for IOTimerDescriptor in %s:%d", __FILE__, __LINE__);
- return NULL;
- }
+ if(!descriptor) {
+ iolog_trigger(IOLOG_ERROR, "could not allocate memory for IOTimerDescriptor in %s:%d", __FILE__, __LINE__);
+ return NULL;
+ }
struct _IOTimerDescriptor *timer = _create_timer(timeout);
if(!timer) {
free(descriptor);
struct _IOTimerDescriptor *_create_timer(struct timeval *timeout) {
struct _IOTimerDescriptor *timer = calloc(1, sizeof(*timer));
- if(!timer) {
- iolog_trigger(IOLOG_ERROR, "could not allocate memory for _IOTimerDescriptor in %s:%d", __FILE__, __LINE__);
- return NULL;
- }
+ if(!timer) {
+ iolog_trigger(IOLOG_ERROR, "could not allocate memory for _IOTimerDescriptor in %s:%d", __FILE__, __LINE__);
+ return NULL;
+ }
if(timeout) {
timer->timeout = *timeout;
_rearrange_timer(timer);
extern struct _IOTimerDescriptor *iotimer_sorted_descriptors;
struct _IOTimerDescriptor {
- unsigned int flags : 8;
- void *parent;
-
- struct timeval timeout;
- struct timeval autoreload;
-
- struct _IOTimerDescriptor *prev, *next;
+ unsigned int flags : 8;
+ void *parent;
+
+ struct timeval timeout;
+ struct timeval autoreload;
+
+ struct _IOTimerDescriptor *prev, *next;
};
void _init_timers();
typedef IOTIMER_CALLBACK(iotimer_callback);
struct IOTimerDescriptor {
- void *iotimer; /* struct _IOTimerDescriptor */
-
- iotimer_callback *callback;
- void *data;
+ void *iotimer; /* struct _IOTimerDescriptor */
+
+ iotimer_callback *callback;
+ void *data;
};
struct IOTimerDescriptor *iotimer_create(struct timeval *timeout);
projects / NextIRCd.git / commitdiff