Initial import

.gitignore

@@ -0,0 +1,2 @@
+*.o
+*.a

Makefile

@@ -0,0 +1,25 @@
+CC = $(CROSS)$(TARGET)gcc
+LINK = $(CROSS)$(TARGET)ld -o
+LIBRARY_LINK_OPTS =  -L. -r
+CFLAGS = -ggdb -Wall -Wextra -Wshadow -Wformat-security -O2
+RM = /bin/rm -f
+Q=@
+
+OBJS = queue.o list.o io.o log.o http_response.o asyncdns.o server.o
+PROG = libfuncs.a
+
+all: $(PROG)
+
+$(PROG): $(OBJS) 
+	$(Q)echo "  LINK	$(PROG)"
+	$(Q)$(LINK) $@ $(LIBRARY_LINK_OPTS) $(OBJS)
+
+%.o: %.c libfuncs.h
+	$(Q)echo "  CC	libfuncs	$<"
+	$(Q)$(CC) $(CFLAGS) -c $<
+
+clean:
+	$(Q)echo "  RM	$(PROG) $(OBJS)"
+	$(Q)$(RM) $(PROG) *.o core *.core *~
+
+distclean: clean

asyncdns.c

@@ -0,0 +1,141 @@
+/*
+ * Async DNS resolver
+ * Copyright (C) 2009-2010 Unix Solutions Ltd.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <errno.h>
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#include "log.h"
+
+/* FreeBSD have problems with pathread_cancel so do not use async resolver */
+#ifdef __FreeBSD__
+
+int async_resolve_host(char *host, int port, struct sockaddr_in *sockaddr, int msec_timeout, int *active) {
+	msec_timeout = msec_timeout;
+	active = active;
+	struct hostent *hostinfo = gethostbyname(host);
+	if (hostinfo == NULL) {
+		int local_h_errno = h_errno;
+		LOGf("gethostbyname(%s) returned %s", host, hstrerror(local_h_errno));
+		return 1; // error
+	}
+	sockaddr->sin_family = AF_INET;
+	sockaddr->sin_port = htons(port);
+	sockaddr->sin_addr = *(struct in_addr *)hostinfo->h_addr;
+	// LOGf("Not using async resolver! Resolved %s to %s\n", host, inet_ntoa(sockaddr->sin_addr));
+	return 0;
+}
+
+#else
+
+struct url_resolver {
+	char *host;
+	int port;
+	struct sockaddr_in *sockaddr;
+	int *status;
+};
+
+static void resolver_cleanup(void *p) {
+	if (p)
+		freeaddrinfo(p);
+}
+
+static void *resolver_thread(void *indata) {
+	struct url_resolver *uri = indata;
+	*(uri->status) = 0;
+	char *host = uri->host;
+	int port = uri->port;
+	struct sockaddr_in *sockaddr = uri->sockaddr;
+
+	int h_err;
+	struct addrinfo hints, *addrinfo = NULL;
+	memset(&hints, 0, sizeof hints);
+
+	int state;
+	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &state);
+	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &state);
+	pthread_cleanup_push(resolver_cleanup, NULL);
+
+	hints.ai_family = AF_INET;
+	hints.ai_socktype = SOCK_STREAM;
+	h_err = getaddrinfo(host, NULL, &hints, &addrinfo);
+
+	pthread_cleanup_pop(0);
+
+	if (h_err == 0) {
+		int num_addrs = 0;
+		struct addrinfo *p;
+		for (p=addrinfo; p!=NULL; p=p->ai_next) {
+			struct sockaddr_in *ipv4 = (struct sockaddr_in *)p->ai_addr;
+			sockaddr->sin_family = AF_INET;
+			sockaddr->sin_port = htons(port);
+			sockaddr->sin_addr = ipv4->sin_addr;
+			char IP[INET_ADDRSTRLEN];
+			inet_ntop(p->ai_family, &(sockaddr->sin_addr), IP, sizeof IP);
+			num_addrs++;
+			// LOGf("Resolved[%d] %s to %s", num_addrs, host, IP);
+		}
+		freeaddrinfo(addrinfo);
+		*(uri->status) = 1;
+	} else {
+		*(uri->status) = 2;
+	}
+
+	return NULL;
+}
+
+// Returns
+//   0 on success
+//   1 on error
+//   2 on timeout
+int async_resolve_host(char *host, int port, struct sockaddr_in *sockaddr, int msec_timeout, int *active) {
+	pthread_t dns_thread;
+	struct url_resolver uri;
+	int status = 0;
+	uri.host = host;
+	uri.port = port;
+	uri.sockaddr = sockaddr;
+	uri.status = &status;
+
+	int lactive = 1;
+	if (!active)
+		active = &lactive;
+
+	if (pthread_create(&dns_thread, NULL, resolver_thread, &uri)) {
+		log_perror("Failed to create resolver thread", errno);
+		return 1;
+	}
+	pthread_detach(dns_thread);
+
+	#define DNS_SLEEP 20000
+	long int waitcount = msec_timeout * 1000;
+	while (!status) {
+		if (!active) {
+			// LOG("Client !active, cancel resolver");
+			pthread_cancel(dns_thread);
+			return 2;
+		}
+		usleep(DNS_SLEEP);
+		waitcount = waitcount - DNS_SLEEP;
+		if (waitcount <= 0) {
+			// LOGf("Timed out resolving: %s", host);
+			pthread_cancel(dns_thread);
+			return 2; // Timed out
+		}
+	}
+
+	if (status == 1)
+		return 0; // Ok, resolved
+
+	return 1; // Error resolving
+}
+#endif

asyncdns.h

@@ -0,0 +1,19 @@
+/*
+ * Async DNS resolver
+ * Copyright (C) 2009-2010 Unix Solutions Ltd.
+ */
+
+#ifndef ASYNCDNS_H
+# define ASYNCDNS_H
+
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+
+// Returns
+//   0 on success
+//   1 on error
+//   2 on timeout
+int async_resolve_host(char *host, int port, struct sockaddr_in *sockaddr, int msec_timeout, int *active);
+
+#endif

http_response.c

@@ -0,0 +1,106 @@
+/*
+ * HTTP responses
+ * Copyright (C) 2006-2009 Unix Solutions Ltd.
+ */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <netdb.h>
+#include <time.h>
+
+#include "io.h"
+
+static char *server_signature = NULL;
+static char *server_version   = NULL;
+
+void set_http_response_server_ident(char *server, char *version) {
+	server_signature = server;
+	server_version   = version;
+}
+
+void send_http_response(int clientsock, const char *response) {
+	char buf[128];
+	time_t now = time(NULL);
+	fdputsf(clientsock, "HTTP/1.0 %s\n", response);
+	if (server_signature && server_version)
+		fdputsf(clientsock, "Server: %s %s\n", server_signature, server_version);
+	strftime(buf,sizeof(buf),"Date: %a, %d %b %Y %H:%M:%S %Z\n",gmtime(&now));
+	fdputs(clientsock,buf);
+	fdputs(clientsock, "Cache-Control: no-cache\n");
+	fdputs(clientsock, "Connection: close\n");
+	fdputs(clientsock, "Pragma: no-cache\n");
+}
+
+void send_header_textplain(int clientsock) {
+	fdputs(clientsock,"Content-Type: text/plain\n");
+}
+
+void send_http_error(int clientsock, const char *code, const char *message) {
+	send_http_response(clientsock, code);
+	send_header_textplain(clientsock);
+	if (message) {
+		fdputsf(clientsock,"X-Error: %s\n", message);
+	}
+	fdputs(clientsock,"\n");
+	fdputsf(clientsock,"%s\n", message ? message : code);
+}
+
+void send_200_ok(int clientsock) {
+	send_http_response(clientsock,"200 OK");
+}
+
+void send_http_ok(int clientsock, char *message) {
+	send_200_ok(clientsock);
+	send_header_textplain(clientsock);
+	fdputs(clientsock, "\n");
+	fdputs(clientsock, message);
+	fdputs(clientsock, "\n");
+}
+
+
+void send_http_ok_msg(int clientsock, const char *fmt, ...) {
+	char msg[512];
+	va_list args;
+	va_start(args, fmt);
+	vsnprintf(msg, 512, fmt, args);
+	va_end(args);
+	send_http_ok(clientsock, msg);
+}
+
+void send_302_redirect(int clientsock, char * url) {
+	send_http_response(clientsock,"302 Found");
+	fdputsf(clientsock,"Location: %s\n", url);
+	fdputs(clientsock,"\n");
+}
+
+void send_400_bad_request(int clientsock, const char * msg) {
+	send_http_error(clientsock,"400 Bad Request", msg);
+}
+
+void send_403_forbidden_msg(int clientsock, const char *msg) {
+	send_http_error(clientsock, "403 Forbidden", msg);
+}
+
+void send_403_forbidden(int clientsock) {
+	send_403_forbidden_msg(clientsock, "access-denied");
+}
+
+void send_404_not_found(int clientsock) {
+	send_http_error(clientsock, "404 Not Found", NULL);
+}
+
+void send_409_conflict(int clientsock, const char * msg) {
+	send_http_error(clientsock, "409 Conflict", msg);
+}
+
+void send_500_internal_server_error(int clientsock, const char * msg) {
+	send_http_error(clientsock, "500 Internal Server Error", msg);
+}
+
+void send_501_not_implemented(int clientsock) {
+	send_http_error(clientsock, "501 Method Not Implemented", NULL);
+}
+
+void send_504_gateway_timeout(int clientsock) {
+	send_http_error(clientsock, "504 Gateway Timeout", "no-signal");
+}

http_response.h

@@ -0,0 +1,37 @@
+/*
+ * HTTP responses header file
+ * Copyright (C) 2006-2009 Unix Solutions Ltd.
+ */
+
+#ifndef HTTP_RESPONSE_H
+# define HTTP_RESPONSE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void set_http_response_server_ident(char *server, char *version);
+
+void send_http_response(int clientsock, const char * response);
+void send_header_textplain(int clientsock);
+
+void send_http_error(int clientsock, const char *code, const char *message);
+void send_http_ok(int clientsock, const char *message);
+void send_http_ok_msg(int clientsock, const char *fmt, ...);
+
+void send_200_ok(int clientsock);
+void send_302_redirect(int clientsock, const char * url);
+void send_400_bad_request(int clientsock, const char *msg);
+void send_403_forbidden_msg(int clientsock, const char *msg);
+void send_403_forbidden(int clientsock);
+void send_404_not_found(int clientsock);
+void send_409_conflict(int clientsock, const char * msg);
+void send_500_internal_server_error(int clientsock, const char * msg);
+void send_501_not_implemented(int clientsock);
+void send_504_gateway_timeout(int clientsock);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

io.c

@@ -0,0 +1,262 @@
+/*
+ * UX IO functions
+ * Copyright (C) 2006-2009 Unix Solutions Ltd.
+ */
+
+/* Needed for POLLRDHUP */
+#define _GNU_SOURCE 1;
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <string.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <sys/utsname.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <poll.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <time.h>
+
+#include "libfuncs.h"
+#include "log.h"
+
+char * chomp(char *x) {
+	int i=strlen(x)-1;
+	while ((i>=0)&&((x[i]=='\n')||(x[i]=='\r')||(x[i]==' ')||(x[i]=='\t'))){
+		x[i--]=0;
+	}
+	return x;
+}
+
+ssize_t safe_read(int fd, void *buf, size_t len) {
+	ssize_t readen;
+	do {
+		readen = read(fd, buf, len);
+		if ((readen < 0) && (errno == EAGAIN || errno == EINTR))
+			continue;
+		return readen;
+	} while (1);
+}
+
+ssize_t safe_write(int fd, const void *buf, size_t len) {
+	ssize_t written;
+	do {
+		written = write(fd, buf, len);
+		if ((written < 0) && (errno == EAGAIN || errno == EINTR))
+			continue;
+		return written;
+	} while (1);
+}
+
+void shutdown_fd(int *in_fd) {
+	if (*in_fd > -1) {
+		shutdown(*in_fd, SHUT_RDWR);
+		close(*in_fd);
+		*in_fd = -1;
+	}
+}
+
+ssize_t fdgetline(int fd, char *buf, size_t buf_size) {
+	size_t i=0;
+	int intrs = 0;
+	int num_timeouts = 0;
+	struct pollfd fdset[1];
+	fdset[0].fd = fd;
+	fdset[0].events = POLLIN;
+	if (buf_size <= 0 || fd == -1)
+		return 0;
+	while (1) {
+		int fdready = poll(fdset, 1, FDGETLINE_TIMEOUT);
+		if (fdready == -1) {
+			if (errno == EINTR) {
+				if (++intrs < FDGETLINE_RETRIES)
+					continue;
+				else
+					return i;
+			}
+			if (num_timeouts++ <= FDGETLINE_RETRIES) {
+				continue;
+			} else {
+				log_perror("fdgetline() timeout", errno);
+			}
+		}
+		if (fdready == 0 || fdready == -1) { /* Timeout || error */
+			if (num_timeouts++ <= FDGETLINE_RETRIES)
+				continue;
+			return 0;
+		}
+		if (safe_read(fd,buf+i,1)!=1) /* Try to read 1 char */
+			break;
+		i++;
+		if (buf[i-1]=='\n')
+			break;
+		if (i==buf_size) /* End of buffer reached, get out a here */
+			return 0;
+	}
+	buf[i]='\0';
+	return i;
+}
+
+ssize_t fdread_ex(int fd, char *buf, size_t buf_size, int timeout, int retries, int waitfull) {
+	ssize_t rbytes = 0;
+	int intrs = 0;
+	int num_timeouts = 0;
+	struct pollfd fdset[1];
+	fdset[0].fd = fd;
+	fdset[0].events = POLLIN;
+	if (buf_size <= 0 || fd == -1)
+		return 0;
+	while (1) {
+		int fdready = poll(fdset, 1, timeout);
+		if (fdready == -1 || fdready == 0) { /* Timeout || error */
+			if (errno == EINTR) {
+				if (++intrs < retries)
+					continue;
+				else
+					return rbytes;
+			}
+			if (num_timeouts++ <= retries) {
+				continue;
+			} else {
+				if (timeout) {
+					log_perror("fdread() timeout", errno);
+				}
+				return rbytes > 0 ? rbytes : -1;
+			}
+		}
+		ssize_t j = safe_read(fd, buf + rbytes, buf_size - rbytes);
+		if (j < 0) // Error reading
+			return j;
+		if (j == 0) { // No data, retry?
+			if (num_timeouts++ > retries) {
+				return rbytes;
+			}
+			continue;
+		}
+		rbytes += j;
+		if (!waitfull)
+			return rbytes;
+		if (rbytes == (ssize_t)buf_size)
+			return rbytes;
+	}
+	return 0;
+}
+
+ssize_t fdread(int fd, char *buf, size_t buf_size) {
+	return fdread_ex(fd, buf, buf_size, FDREAD_TIMEOUT, FDREAD_RETRIES, 1);
+}
+
+ssize_t fdread_nowaitfull(int fd, char *buf, size_t buf_size) {
+	return fdread_ex(fd, buf, buf_size, FDREAD_TIMEOUT, FDREAD_RETRIES, 0);
+}
+
+ssize_t fdwrite(int fd, char *buf, size_t buf_size) {
+	ssize_t wbytes=0;
+	int intrs = 0;
+	int num_timeouts = 0;
+	struct pollfd fdset[1];
+	fdset[0].fd = fd;
+	fdset[0].events = POLLOUT | POLLERR | POLLHUP | POLLNVAL | POLLRDHUP;
+
+	if (buf_size <= 0 || fd == -1)
+		return 0;
+	while (1) {
+		int fdready = poll(fdset, 1, FDWRITE_TIMEOUT);
+		if (fdready == -1 || fdready == 0) { /* Timeout || error */
+			if (errno == EINTR) {
+				if (++intrs < FDWRITE_RETRIES)
+					continue;
+				else
+					return wbytes;
+			}
+			if (num_timeouts++ <= FDWRITE_RETRIES) {
+				continue;
+			} else {
+				log_perror("fdwrite() timeout", errno);
+				return wbytes > 0 ? wbytes : -1;
+			}
+		}
+		if (fdready < 1 || (fdready == 1 && fdset[0].revents != POLLOUT)) /* Timeout || error */
+			return -1;
+		ssize_t j = safe_write(fd, buf+wbytes, buf_size-wbytes);
+		if (j < 0) // Error writing
+			return j;
+		if (j == 0) { // No data, retry?
+			if (num_timeouts++ > FDREAD_RETRIES) {
+				return wbytes;
+			}
+			continue;
+		}
+		wbytes += j;
+		if (wbytes == (ssize_t)buf_size)
+			return wbytes;
+	}
+	return 0;
+}
+
+int fdputs(int fd, char *msg) {
+	return fdwrite(fd, msg, strlen(msg));
+}
+
+int fdputsf(int fd, char *fmt, ...) {
+	char msg[2048];
+	va_list args;
+	va_start(args, fmt);
+	vsnprintf(msg, sizeof(msg)-1, fmt, args);
+	va_end(args);
+	return fdwrite(fd, msg, strlen(msg));
+}
+
+
+void set_sock_nonblock(int sockfd) {
+	int arg = fcntl(sockfd, F_GETFL, NULL);
+	arg |= O_NONBLOCK; 
+	fcntl(sockfd, F_SETFL, arg);
+}
+
+void set_sock_block(int sockfd) {
+	int arg = fcntl(sockfd, F_GETFL, NULL);
+	arg &= (~O_NONBLOCK);
+	fcntl(sockfd, F_SETFL, arg);
+}
+
+
+int do_connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen, int timeout) {
+	set_sock_nonblock(sockfd);
+	// Trying to connect with timeout
+	int result = connect(sockfd, serv_addr, addrlen);
+	if (result < 0) { // Not connected
+		if (errno != EINPROGRESS) { // Not in progress
+			return -1;
+		} else { // Wait a timeout ms for socket to become ready to write into
+			struct pollfd fdset[1];
+			fdset[0].fd = sockfd;
+			fdset[0].events = POLLOUT | POLLERR | POLLHUP | POLLNVAL | POLLRDHUP;
+			do {
+				int fdready = poll(fdset, 1, timeout);
+				if (fdready == -1 && errno == EINTR)
+					continue;
+				if (fdready < 1 || (fdready == 1 && fdset[0].revents != POLLOUT)) { // Timeout || error
+					// Get socket error
+					unsigned int err_val=0, sz = sizeof(int); 
+					getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void*)(&err_val), &sz);
+					errno = err_val;
+					if (!errno) // It can't be success, so simulate timeout
+						errno = ENETDOWN;
+					return -1;
+				}
+				break;
+			} while (1);
+		}
+	}
+	set_sock_block(sockfd);
+	return 0;
+}

io.h

@@ -0,0 +1,40 @@
+/*
+ * UX IO functions header file
+ * Copyright (C) 2006-2009 Unix Solutions Ltd.
+ */
+
+#ifndef IO_H
+# define IO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/socket.h>
+#include <sys/types.h>
+
+char * chomp(char *x);
+
+ssize_t safe_read(int fd, void *buf, size_t len);
+ssize_t safe_write(int fd, const void *buf, size_t len);
+void shutdown_fd(int *in_fd);
+
+ssize_t fdgetline(int fd, char *buf, size_t buf_size);
+ssize_t fdread_ex(int fd, char *buf, size_t buf_size, int timeout, int retries, int waitfull);
+ssize_t fdread(int fd, char *buf, size_t buf_size);
+ssize_t fdread_nowaitfull(int fd, char *buf, size_t buf_size);
+ssize_t fdwrite(int fd, char *buf, size_t buf_size);
+
+int fdputs(int fd, char *msg);
+int fdputsf(int fd, char *fmt, ...);
+
+void set_sock_nonblock(int sockfd);
+void set_sock_block(int sockfd);
+
+int do_connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen, int timeout);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libfuncs.h

@@ -0,0 +1,42 @@
+/*
+ * UX libfuncs main header
+ * Copyright (C) 2006-2010 Unix Solutions Ltd.
+ */
+
+#ifndef LIBFUNCS_H
+# define LIBFUNCS_H
+
+#undef DEBUG
+//#define DEBUG 1
+
+#define DNS_RESOLVER_TIMEOUT 5000
+
+#define FDGETLINE_TIMEOUT 500
+#define FDGETLINE_RETRIES 30
+
+#define FDREAD_TIMEOUT 1500
+#define FDREAD_RETRIES 7
+
+#define FDWRITE_TIMEOUT 1500
+#define FDWRITE_RETRIES 7
+
+#ifndef FREE
+	#define FREE(x) if(x) { free(x); x=NULL; }
+#endif
+
+#ifndef POLLRDHUP
+	#define POLLRDHUP 0
+#endif
+
+#define min(a,b) ((a < b) ? a : b)
+#define max(a,b) ((a > b) ? a : b)
+
+#include "asyncdns.h"
+#include "http_response.h"
+#include "io.h"
+#include "list.h"
+#include "log.h"
+#include "queue.h"
+#include "server.h"
+
+#endif

list.c

@@ -0,0 +1,171 @@
+/*
+ * List manipulations
+ * Copyright (C) 2006-2010 Unix Solutions Ltd.
+ *
+ */
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <pthread.h>
+
+#include "libfuncs.h"
+#include "list.h"
+
+//#define LIST_DEBUG
+
+#ifdef LIST_DEBUG
+	#define Ldbg fprintf
+#else
+	#define Ldbg(...) do { /* ... */ } while(0)
+#endif
+
+LIST *list_new(char *name) {
+	pthread_mutex_t *mutex = malloc(sizeof(pthread_mutex_t));
+	if (pthread_mutex_init(mutex,NULL) != 0) {
+		perror("list_new: mutex_init");
+		return NULL;
+	}
+	LIST *list = calloc(1, sizeof(LIST));
+	if (!list)
+		return NULL;
+	list->mutex = mutex;
+	list->name = strdup(name);
+
+	LNODE *node = malloc(sizeof(LNODE));
+	if (!node)
+		return NULL;
+
+	node->data = NULL;
+	node->next = node;
+	node->prev = node;
+
+	list->head = node;	// Point to first
+	list->tail = node;	// Set prev element
+
+	Ldbg(stderr, "list_new(%s) l=%p l->head=%p l->tail=%p\n", list->name, list, list->head, list->tail);
+	return list;
+}
+
+void list_free(LIST **plist, void (*free_func)(), void (*freep_func)()) {
+	LIST *list = *plist;
+	if (!list)
+		return;
+	Ldbg(stderr, "list_free(%s)\n", list->name);
+	LNODE *node, *tmp;
+	list_lock(list);
+	list_for_each(list, node, tmp) {
+		if (free_func && node->data)
+			free_func(node->data);
+		if (freep_func && node->data)
+			freep_func(&node->data);
+		list_del_unlocked(list, &node);
+	}
+	FREE(list->head);
+	list_unlock(list);
+	pthread_mutex_destroy(list->mutex);
+	FREE(list->mutex);
+	FREE(list->name);
+	FREE(*plist);
+}
+
+void list_lock(LIST *list) {
+	pthread_mutex_lock(list->mutex);
+}
+
+void list_unlock(LIST *list) {
+	pthread_mutex_unlock(list->mutex);
+}
+
+void list_add(LIST *list, void *data) {
+	if (!list) {
+		Ldbg(stderr, "list_add(), list == NULL\n");
+		return;
+	}
+
+	if (!data) {
+		Ldbg(stderr, "list_add(%s), data == NULL\n", list->name);
+		return;
+	}
+
+	LNODE *node = malloc(sizeof(LNODE));
+	if (!node) {
+		Ldbg(stderr, "list_add(%s), can't alloc node\n", list->name);
+		return;
+	}
+
+	node->data = data;
+
+//	if (strcmp(list->name, "clients") == 0 || strcmp(list->name, "r->clients") == 0)
+	Ldbg(stderr, "list_add(%s), node=%p data=%p\n", list->name, node, node->data);
+
+	list_lock(list);
+
+	node->prev = list->tail;
+	node->next = list->head;
+
+	list->tail->next = node;
+	list->tail = node;
+	list->head->prev = node;
+
+	list->items++;
+	list_unlock(list);
+}
+
+void list_dump(LIST *list) {
+	if (list == NULL) {
+		fprintf(stderr, "list_dump(), list is null\n");
+		return;
+	}
+	fprintf(stderr, "list_dump(%s), nodes:%d\n", list->name, list->items);
+	LNODE *node, *tmp;
+	int i = 0;
+	list_for_each(list, node, tmp) {
+		fprintf(stderr, "   Node:%d Head:%p Tail:%p Node:%p NodeNext:%p NodePrev:%p Data:%p -> %s\n",
+			i++, list->head, list->tail, node, node->next, node->prev, node->data, (char *)node->data);
+	}
+}
+
+int list_del_unlocked(LIST *list, LNODE **node) {
+	if (!list || !*node)
+		return 0;
+
+	LNODE *prev = (*node)->prev;
+	LNODE *next = (*node)->next;
+
+	next->prev = prev;
+	prev->next = next;
+	if (*node == list->tail)
+		list->tail = prev;
+
+	list->items--;
+
+	FREE(*node);
+	return 1;
+}
+
+
+int list_del(LIST *list, LNODE **node) {
+	if (!list || !*node)
+		return 0;
+	list_lock(list);
+	int ret = list_del_unlocked(list, node);
+	list_unlock(list);
+	return ret;
+}
+
+int list_del_entry(LIST *list, void *data) {
+	int ret = 0;
+	if (!list || !data)
+		return 0;
+	Ldbg(stderr, "list_del_entry(%s, %p)\n", list->name, data);
+	list_lock(list);
+	LNODE *node, *tmp;
+	list_for_each(list, node, tmp) {
+		if (node->data == data) {
+			ret = list_del_unlocked(list, &node);
+			break;
+		}
+	}
+	list_unlock(list);
+	return ret;
+}

list.h

@@ -0,0 +1,62 @@
+/*
+ * List manipulations header file
+ * Copyright (C) 2006-2010 Unix Solutions Ltd.
+ *
+ */
+#ifndef LIST_H
+# define LIST_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <pthread.h>
+
+typedef struct LNODE {
+	struct LNODE *prev;
+	struct LNODE *next;
+	void *data;
+} LNODE;
+
+typedef struct LIST {
+	pthread_mutex_t *mutex;		// List's lock
+	struct LNODE *head;			// Points to first element of the list
+	struct LNODE *tail;			// Points to last element of the list
+	unsigned int items;			// How many items are in the list
+	char *name;
+} LIST;
+
+// Safe against calling list_del inside
+#define list_for_each(list, elem, tmp_el) \
+	for (elem = (list)->head->next, tmp_el = elem->next; elem != (list)->head && elem->data; elem = tmp_el, tmp_el = elem->next)
+
+#define list_for_each_reverse(list, elem, tmp_el) \
+	for (elem = (list)->head->prev, tmp_el = elem->prev; elem != (list)->head && elem->data; elem = tmp_el, tmp_el = elem->prev)
+
+// list_del can not be called inside this for
+#define list_for_each_unsafe(list, elem) \
+	for (elem = (list)->head->next; elem != (list)->head && elem->data; elem = elem->next)
+
+#define list_for_each_reverse_unsafe(list, elem) \
+	for (elem = (list)->head->prev; elem != (list)->head && elem->data; elem = elem->prev)
+
+LIST *list_new			(char *listname);
+void list_free			(LIST **l, void (*l_free)(), void (*l_freep)());
+
+void list_lock			(LIST *l);
+void list_unlock		(LIST *l);
+
+void list_add			(LIST *l, void *data);
+
+int  list_del			(LIST *l, LNODE **node);
+int  list_del_unlocked	(LIST *l, LNODE **node);
+
+int  list_del_entry		(LIST *l, void *data);
+
+void list_dump(LIST *l);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

log.c

@@ -0,0 +1,214 @@
+/*
+ * IPTV.bg Media Proxy
+ * LOG functions
+ * 
+ * Copyright (C) 2006-2008 Unix Solutions Ltd.
+ * Written by Luben Karavelov (luben@unixsol.org)
+ * 
+ */
+
+/* Needed for POLLRDHUP */
+#define _GNU_SOURCE 1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <string.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <poll.h>
+#include <errno.h>
+#include <time.h>
+#include <pthread.h>
+
+#include "libfuncs.h"
+#include "io.h"
+#include "queue.h"
+#include "asyncdns.h"
+#include "log.h"
+
+static FILE *OUT_FD = NULL;
+
+struct logger {
+	int			use_stderr;
+	int			use_syslog;
+
+	char		*host_ident;
+
+	char		*log_host;
+	int			log_port;
+	int			log_sock;
+
+	int			dienow : 1,
+				dying  : 1;
+
+	QUEUE		*queue;
+	pthread_t	thread;
+};
+
+static void log_connect(struct logger *l) {
+	struct sockaddr_in sockname;
+
+	if (!l->use_syslog)
+		return;
+
+	while (1) {
+		if (l->dying || l->dienow)
+			break;
+		int active = 1;
+		int dret = async_resolve_host(l->log_host, l->log_port, &sockname, 500, &active);
+		if (dret != 0) {
+			log_perror("Could not resolve log host.", errno);
+			sleep(2);
+			continue;
+		}
+		l->log_sock = socket(PF_INET, SOCK_STREAM, 0);
+		if (l->log_sock < 0) {
+			log_perror("Could not create syslog socket", errno);
+			sleep(2);
+			continue;
+		}
+		if (connect(l->log_sock, (struct sockaddr *) &sockname, sizeof (sockname)) < 0) {
+			log_perror("Could not connect to log host.", errno);
+			shutdown_fd(&l->log_sock);
+			sleep(2);
+			continue;
+		}
+		int on = 1;
+		setsockopt(l->log_sock, IPPROTO_TCP, TCP_NODELAY, (char *)&on, sizeof(int));
+		break;
+	}
+}
+
+static void * log_thread(void *param) {
+	char date[64], logline[1024], *msg=NULL;
+	struct logger *l = (struct logger *)param;
+
+	if (l->log_sock < 0)
+		log_connect(l);
+
+	while (l && !l->dienow) {
+		msg = queue_get(l->queue); // Waits...
+		if (!msg)
+			break;
+
+		time_t now = time(NULL);
+		memset(date, 0, sizeof(date));
+		struct tm ltime;
+		localtime_r(&now, &ltime);
+		strftime(date, sizeof(date)-1, "%b %d %H:%M:%S", &ltime);
+
+		memset(logline, 0, sizeof(logline));
+		snprintf(logline, sizeof(logline)-1, "<30>%s host %s: %s", date, l->host_ident, msg);
+		logline[sizeof(logline)-2] = '\n';
+		logline[sizeof(logline)-1] = '\0';
+
+		if (l->use_stderr)
+			fprintf(OUT_FD, "%s", logline+4);
+
+		while (l->use_syslog) {
+			struct pollfd fdset[1];
+			int fdready;
+			do {
+				fdset[0].fd = l->log_sock;
+				fdset[0].events = POLLOUT | POLLERR | POLLHUP | POLLNVAL | POLLRDHUP;
+				fdready = poll(fdset, 1, 5 * 1000);
+			} while (fdready == -1 && errno == EINTR);
+			if (fdready < 1 || (fdready == 1 && fdset[0].revents != POLLOUT)) { /* Timeout || error */
+				do { /* Try to reconnect to log host */
+					if (l->dienow)
+						goto OUT;
+					LOGf("ERROR: Lost connection to log server (%s), fd: %i\n", fdready == 1 ? "poll error" : "timeout", l->log_sock);
+					shutdown_fd(&l->log_sock);
+					log_connect(l);
+					sleep(2);
+				} while (l->log_sock < 0);
+			} else {
+				if (fdwrite(l->log_sock, logline, strlen(logline)) > 0)
+					break;
+				else
+					if (l->dienow)
+						goto OUT;
+			}
+		}
+
+		FREE(msg);
+	}
+OUT:
+	FREE(msg);
+	pthread_exit(0);
+}
+
+static struct logger *logger = NULL;
+
+void log_init(char *host_ident, int use_syslog, int use_stderr, char *log_host, int log_port) {
+	logger = calloc(1, sizeof(struct logger));
+
+	logger->queue = queue_new();
+	logger->host_ident = strdup(host_ident);
+
+	if (log_host)
+		logger->log_host = strdup(log_host);
+	logger->log_port = log_port;
+	logger->log_sock = -1;
+
+	logger->use_syslog = use_syslog;
+	logger->use_stderr = use_stderr;
+
+	pthread_create(&logger->thread, NULL , &log_thread, logger);
+}
+
+void log_set_out_fd(FILE *new_out_fd) {
+	OUT_FD = new_out_fd;
+}
+
+void log_close() {
+	logger->dying = 1;
+	int count = 0;
+	while (logger->queue->items && count++ < 250)
+		usleep(1000);
+	logger->dienow = 1;
+	queue_wakeup(logger->queue);
+	pthread_join(logger->thread, NULL);
+	shutdown_fd(&logger->log_sock);
+	queue_free(&logger->queue);
+	FREE(logger->host_ident);
+	FREE(logger->log_host);
+	FREE(logger);
+}
+
+void LOG(const char *msg) {
+	if (OUT_FD == NULL)
+		OUT_FD = stderr;
+	if (!logger || logger->dying) {
+		fprintf(OUT_FD, "%s", msg);
+	} else {
+		queue_add(logger->queue, strdup(msg));
+	}
+}
+
+void LOGf(const char *fmt, ...) {
+	char msg[1024];
+	va_list args;
+	va_start(args, fmt);
+	vsnprintf(msg, sizeof(msg)-1, fmt, args);
+	va_end(args);
+	msg[sizeof(msg)-2] = '\n';
+	msg[sizeof(msg)-1] = '\0';
+	LOG(msg);
+}
+
+void log_perror(const char *message, int _errno) {
+	char msg[1024];
+	snprintf(msg, sizeof(msg)-1, "PERROR: %s | %s\n", message, strerror(_errno));
+	msg[sizeof(msg)-2] = '\n';
+	msg[sizeof(msg)-1] = '\0';
+	LOG(msg);
+}

log.h

@@ -0,0 +1,43 @@
+/*
+ * IPTV.bg Media Proxy
+ * LOG functions header file
+ * 
+ * Copyright (C) 2006 Unix Solutions Ltd.
+ * Written by Luben Karavelov (luben@unixsol.org)
+ * 
+ */
+
+#ifndef LOG_H
+# define LOG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+
+void log_init  (char *host_ident, int use_syslog, int use_stderr, char *log_host, int log_port);
+void log_close ();
+
+void LOG (const char *msg);
+
+__attribute__ ((format(printf, 1, 2)))
+void LOGf(const char *fmt, ...);
+
+void log_perror(const char *message, int _errno);
+
+void log_set_out_fd(FILE *new_out_fd);
+
+#ifdef DEBUG
+	#define dbg_LOG  LOG
+	#define dbg_LOGf LOGf
+#else
+	#define dbg_LOG(arg)  do { /* arg */ } while(0)
+	#define dbg_LOGf(...) do { /* ... */ } while(0)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

queue.c

@@ -0,0 +1,112 @@
+/*
+ * IPTV.bg Media Proxy
+ * Request queue handling
+ * 
+ * Copyright (C) 2006 Unix Solutions Ltd.
+ * Written by Luben Karavelov (luben@unixsol.org)
+ * 
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <errno.h>
+#include <err.h>
+#include <pthread.h>
+
+#include "libfuncs.h"
+#include "queue.h"
+
+QUEUE *queue_new() {
+	pthread_mutex_t *mutex = malloc(sizeof(pthread_mutex_t));
+	if (pthread_mutex_init(mutex,NULL) != 0) {
+		perror("queue_new: mutex_init");
+		return NULL;
+	}
+	pthread_cond_t *cond = malloc(sizeof(pthread_cond_t));
+	if (pthread_cond_init(cond,NULL)!=0){
+		perror("queue_new: cond_init");
+		return NULL;
+	}
+    QUEUE *q = calloc(1, sizeof(QUEUE));
+	if (!q)
+		return NULL;
+    // initialize queue 
+    q->mutex = mutex;
+    q->cond  = cond;
+    return q;
+}
+
+void queue_free(QUEUE **pq) {
+	QUEUE *q = *pq;
+	void *data;
+	if (!q)
+		return;
+	while (q->items > 0) {
+		data = queue_get(q);
+	}
+	pthread_mutex_destroy(q->mutex);
+	FREE(q->mutex);
+	pthread_cond_destroy(q->cond);
+	FREE(q->cond);
+	FREE(*pq);
+}
+
+void queue_add(QUEUE *q, void *data) {
+	if (!q)
+		return;
+	QNODE *a_msg = malloc(sizeof(QNODE));
+	if (!a_msg) {
+		perror("queue_enqueue, malloc:");
+		return;
+	}
+	a_msg->data = data;
+	a_msg->next = NULL;
+	pthread_mutex_lock(q->mutex);
+	if (q->items == 0) { 			// special case - queue is empty 
+		q->head = a_msg;
+		q->tail = a_msg;
+	} else {
+		q->tail->next = a_msg;
+		q->tail = a_msg;
+	}
+	q->items++;
+	pthread_cond_signal(q->cond);
+	pthread_mutex_unlock(q->mutex);
+}
+
+void *queue_get(QUEUE *q) {
+	if (!q)
+		return NULL;
+	pthread_mutex_lock(q->mutex);
+	while (q->items==0) {
+		pthread_cond_wait(q->cond, q->mutex);
+		if (q->items == 0)
+			return NULL;
+	}
+	if (!q || !q->head || q->items == 0) // Can happen in free
+		return NULL;
+	QNODE *a_msg = q->head;
+	q->head = a_msg->next;
+	if (q->head == NULL) { 		// this was last msg
+	    q->tail = NULL;
+	}
+	q->items--;
+	pthread_cond_signal(q->cond);
+	pthread_mutex_unlock(q->mutex);
+	void *data = a_msg->data;
+	FREE(a_msg);
+    return data;
+}
+
+void *queue_get_nowait(QUEUE* q) {
+	if (!q || q->items == 0)
+		return NULL;
+	return queue_get(q);
+}
+
+void queue_wakeup(QUEUE *q) {
+	if (q) {
+		pthread_cond_signal(q->cond);
+	}
+}
+

queue.h

@@ -0,0 +1,43 @@
+/*
+ * IPTV.bg Media Proxy
+ * Request queue header file
+ * 
+ * Copyright (C) 2006 Unix Solutions Ltd.
+ * Written by Luben Karavelov (luben@unixsol.org)
+ * 
+ */
+#ifndef QUEUE_H
+# define QUEUE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <pthread.h>
+
+typedef struct QNODE {
+	struct QNODE *next;
+	void *data;
+} QNODE;
+
+typedef struct QUEUE {
+	QNODE *head;
+	QNODE *tail;
+	pthread_mutex_t *mutex;	// queue's mutex.
+	pthread_cond_t  *cond;	// queue's condition variable.
+	int items;				// number of messages in queue
+} QUEUE;
+
+QUEUE *queue_new		();
+void queue_free			(QUEUE **q);
+
+void queue_add			(QUEUE *q, void *data);
+void *queue_get			(QUEUE *q);
+void *queue_get_nowait	(QUEUE *q);
+void queue_wakeup		(QUEUE *q);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

server.c

@@ -0,0 +1,83 @@
+/*
+ * Server functions
+ * Copyright (C) 2006-2010 Unix Solutions Ltd.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <netdb.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+void daemonize(char *pidfile) {
+	if (!pidfile)
+		return;
+	printf("Daemonizing.\n");
+	pid_t pid = fork();
+	if (pid > 0) {
+		FILE *F = fopen(pidfile,"w");
+		if (F) {
+			fprintf(F,"%i\n",pid);
+			fclose(F);
+		}
+		exit(0);
+	}
+	// Child process continues...
+	setsid();	// request a new session (job control)
+	freopen("/dev/null", "r", stdin);
+	freopen("/dev/null", "w", stdout);
+	freopen("/dev/null", "w", stderr);
+}
+
+void init_server_socket(char *bind_addr, int bind_port, struct sockaddr_in *server, int *server_socket) {
+	char *binded;
+
+	struct hostent *host_ptr;
+	*server_socket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
+	if (*server_socket == -1) {
+		perror("socket(server_socket)");
+		exit(1);
+	}
+	int j = 1;
+	if (setsockopt(*server_socket, SOL_SOCKET, SO_REUSEADDR,(const char *) &j, sizeof(j))<0) {
+		perror("setsockopt(SO_REUSEADDR)");
+		exit(1);
+	}
+
+	memset(server, 0, sizeof(struct sockaddr_in));
+	if (!bind_addr) {
+		binded = "*";
+		server->sin_addr.s_addr = htonl(INADDR_ANY);
+	} else {
+		host_ptr = gethostbyname(bind_addr);
+		if (!host_ptr) {
+			fprintf(stderr,"Error can't resolve bind address: %s\n", bind_addr);
+			exit(1);
+		}
+		memcpy(&server->sin_addr, host_ptr->h_addr, sizeof(server->sin_addr));
+		binded = inet_ntoa(server->sin_addr);
+	}
+
+	/* Bind to server socket */
+	fprintf(stderr, "Binding to %s:%i\t", binded, bind_port);
+	if (strcmp(binded,"*")==0)
+		fprintf(stderr,"\t");
+
+	server->sin_family = AF_INET;
+	server->sin_port   = htons(bind_port);
+	if (bind(*server_socket, (struct sockaddr *)server, sizeof(struct sockaddr_in)) < 0) {
+		perror("bind(server_socket)");
+		exit(1);
+	}
+	if (listen(*server_socket, 256) < 0) {
+		perror("listen()");
+		exit(1);
+	}
+
+	fputs("[OK]\n",stderr);
+}

server.h

@@ -0,0 +1,22 @@
+/*
+ * Server functions
+ * Copyright (C) 2006-2010 Unix Solutions Ltd.
+ */
+#ifndef SERVER_H
+# define SERVER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <arpa/inet.h>
+#include <netinet/in.h>
+
+void daemonize(char *pidfile);
+void init_server_socket(char *bind_addr, int bind_port, struct sockaddr_in *server, int *server_socket);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif