/**
* accept a new connection
* @param sock the socket to connect on
*/
sock_t *sock_accept(sock_t * sock)
{
sock_t *client;
SOCKET tmp_sock;
struct sockaddr tmp_addr;
socklen_t sin_size = sizeof sock->addr;
#ifdef DEBUG
assert(NULL != sock);
#endif
if (!sock_has_data(sock)) {
/* don't bother... */
return NULL;
}
if ((tmp_sock =
accept(sock->sock, (struct sockaddr *)&tmp_addr, &sin_size)) == -1) {
/* couldn't accept. */
return NULL;
}
client = sock_new(sock->proto, sock->type, sock->host, sock->port);
sock_destroy(client);
client->sock = tmp_sock;
memcpy(&client->addr, &tmp_addr, sizeof client->addr);
snprintf(client->ip, sizeof client->ip,
"%s", inet_ntoa(client->addr.sin_addr));
client->port = ntohs(client->addr.sin_port);
return client;
}
/**
* duplicate a socket
* @param sock the socket to duplicate
*/
sock_t *sock_dup(sock_t * sock)
{
sock_t *copy;
#ifdef DEBUG
assert(NULL != sock);
assert(0 != sock->port);
assert(NULL != sock->host);
assert(!sock->type || sock->type == 1);
#endif
copy = sock_new(sock->proto, sock->type, sock->host, sock->port);
return copy;
}
static int port__ctl_add(port_state_t* port_state,
SOCKET sock,
struct epoll_event* ev) {
sock_state_t* sock_state = sock_new(port_state, sock);
if (sock_state == NULL)
return -1;
if (sock_set_event(port_state, sock_state, ev) < 0) {
sock_delete(port_state, sock_state);
return -1;
}
port__update_events_if_polling(port_state);
return 0;
}
void
listen_in(void *arg)
{
struct listen *f = arg;
struct sockaddr caddr;
socklen_t caddrlen;
int sock, opt;
caddrlen = sizeof(caddrlen);
while ((sock = accept(f->fd, &caddr, &caddrlen)) < 0) {
if (errno == EINTR)
continue;
if (errno == ENFILE || errno == EMFILE)
file_slowaccept = 1;
else if (errno != ECONNABORTED && errno != EWOULDBLOCK)
perror("accept");
return;
}
if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0) {
perror("fcntl(sock, O_NONBLOCK)");
close(sock);
return;
}
if (f->path == NULL) {
opt = 1;
if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
&opt, sizeof(int)) < 0) {
perror("setsockopt");
close(sock);
return;
}
}
if (sock_new(sock) == NULL) {
close(sock);
return;
}
}
/*! \brief Create a new HTTP server
*
* \param config the configuratin from config file
* \param monitor the monitor to be used
* \param callback the function to be called when a request arrives
* \param user_data the parameter to the callback
*
* \return A instance of the server
*/
HttpServer* hs_new(iks* config, hs_request_callback callback,
void* user_data) {
HttpServer* server;
Socket* sock;
const char* str;
int port, ret;
/* get the port to listen */
if((str = iks_find_attrib(config, "port")) != NULL) {
port = atoi(str);
} else {
port = HTTP_PORT;
}
/* create the socket */
sock = sock_new();
ret = sock_listen(sock, port);
if(ret == 0) {
log(ERROR, "Failed to listen http server port %d", port);
return NULL;
}
/* alloc memomry for the server struct */
server = malloc(sizeof(HttpServer));
/* init values */
server->sock = sock;
server->http_connections = list_new();
server->callback = callback;
server->user_data = user_data;
/* monitor the server socket for conenctions */
sock_set_accept_callback(sock, hs_accept, server);
return server;
}
sock *sock_new_udp()
{
return sock_new(PF_INET, SOCK_DGRAM);
}
