working version

This commit is contained in:
Olaf Rempel 2007-03-11 17:23:34 +01:00
parent 1eb9d49ae6
commit b602d7c17f
5 changed files with 257 additions and 167 deletions

View File

@ -18,8 +18,9 @@ struct connection {
struct sockaddr_in src_addr;
struct sockaddr_in dst_addr;
int src_fd;
int dst_fd;
struct event_entry *src_event;
struct event_entry *dst_event;
struct event_entry *timeout;
time_t login_time;
};
@ -34,26 +35,26 @@ static struct connection * create_connection()
return 0;
}
con->src_fd = con->dst_fd = -1;
con->src_addr.sin_addr.s_addr = con->src_addr.sin_addr.s_addr = 0;
con->src_addr.sin_port = con->src_addr.sin_port = 0;
memset(con, 0, sizeof(struct connection));
con->login_time = time(NULL);
return con;
}
static int destroy_connection(struct connection *con)
{
// TODO: detroy connect-timeout?
if (con->timeout != NULL)
event_remove(con->timeout);
if (con->src_fd != -1) {
close(con->src_fd);
event_remove_fd(con->src_fd);
int src_fd = event_get_fd(con->src_event);
if (src_fd != -1) {
close(src_fd);
event_remove(con->src_event);
}
if (con->dst_fd != -1) {
close(con->dst_fd);
event_remove_fd(con->dst_fd);
int dst_fd = event_get_fd(con->dst_event);
if (dst_fd != -1) {
close(dst_fd);
event_remove(con->dst_event);
}
free(con);
@ -72,13 +73,16 @@ static int forward_handler(int fd, void *privdata)
return -1;
}
int src_fd = event_get_fd(con->src_event);
int dst_fd = event_get_fd(con->dst_event);
/* client -> device */
if (con->src_fd == fd)
write(con->dst_fd, buf, len);
if (src_fd == fd && dst_fd != -1)
write(dst_fd, buf, len);
/* device -> client */
else if (con->dst_fd == fd)
write(con->src_fd, buf, len);
if (dst_fd == fd && src_fd != -1)
write(src_fd, buf, len);
return 0;
}
@ -94,10 +98,32 @@ static int connect_handler(int fd, void *privdata)
}
log_print(LOG_INFO, "forwarding to %s", get_sockaddr_buf(&con->dst_addr));
event_add_readfd(con->dst_fd, forward_handler, con);
event_add_readfd(con->src_fd, forward_handler, con);
/* dismiss connect_handler */
/* everything from dst will be forwarded */
event_add_readfd(con->dst_event, 0, forward_handler, con);
/* remove connect_handler */
event_add_writefd(con->dst_event, 0, NULL, NULL);
/* remove timeout */
event_remove(con->timeout);
con->timeout = NULL;
log_print(LOG_DEBUG, "connect_handler(): exit");
return 0;
}
static int connect_timeout(void *privdata)
{
struct connection *con = (struct connection *)privdata;
log_print(LOG_INFO, "connect to %s timed out", get_sockaddr_buf(&con->dst_addr));
list_del(&con->list);
destroy_connection(con);
/* singleshot timer */
return -1;
}
@ -119,21 +145,29 @@ static int client_handler(int fd, void *privdata)
return -1;
}
// check destination
con->dst_fd = tcp_connect_socket(&con->dst_addr);
if (con->dst_fd < 0) {
// TODO: check destination
int dst_fd = tcp_connect_socket(&con->dst_addr);
if (dst_fd < 0) {
list_del(&con->list);
destroy_connection(con);
return -1;
}
// TODO: start connect timeout, callback destroys connection
log_print(LOG_INFO, "connecting to %s", get_sockaddr_buf(&con->dst_addr));
event_add_writefd(con->dst_fd, connect_handler, con);
/* dismiss client_handler */
return -1;
struct timeval tv;
tv.tv_sec = 5;
tv.tv_usec = 0;
con->timeout = event_add_timeout(&tv, connect_timeout, con);
/* wait for connect() (non-blocking) */
con->dst_event = event_add_writefd(NULL, dst_fd, connect_handler, con);
/* everything from src will be forwarded */
event_add_readfd(con->src_event, 0, forward_handler, con);
return 0;
}
static int admin_handler(int fd, void *privdata)
@ -151,9 +185,9 @@ static int admin_handler(int fd, void *privdata)
if (strncmp(buf, "list", 4) == 0) {
struct connection *entry;
list_for_each_entry(entry, &connection_list, list) {
len = snprintf(buf, sizeof(buf), "%d,", entry->src_fd);
len = snprintf(buf, sizeof(buf), "%d,", event_get_fd(entry->src_event));
len += get_sockaddr(&entry->src_addr, buf + len, sizeof(buf) - len);
len += snprintf(buf + len, sizeof(buf) - len, ",%d,", entry->dst_fd);
len += snprintf(buf + len, sizeof(buf) - len, ",%d,", event_get_fd(entry->dst_event));
len += get_sockaddr(&entry->dst_addr, buf + len, sizeof(buf) - len);
len += snprintf(buf + len, sizeof(buf) - len, ",%ld\n", (time(NULL) - entry->login_time));
write(fd, buf, len);
@ -182,8 +216,8 @@ int listen_handler(int fd, void *privdata)
}
unsigned int i = sizeof(con->src_addr);
con->src_fd = accept(fd, (struct sockaddr *)&con->src_addr, &i);
if (con->src_fd < 0) {
int src_fd = accept(fd, (struct sockaddr *)&con->src_addr, &i);
if (src_fd < 0) {
free(con);
return 0;
}
@ -193,9 +227,10 @@ int listen_handler(int fd, void *privdata)
list_add_tail(&con->list, &connection_list);
if (mode == CON_ADMIN)
event_add_readfd(con->src_fd, admin_handler, con);
else
event_add_readfd(con->src_fd, client_handler, con);
con->src_event = event_add_readfd(NULL, src_fd, admin_handler, con);
else if (mode == CON_NORMAL)
con->src_event = event_add_readfd(NULL, src_fd, client_handler, con);
return 0;
}

233
event.c
View File

@ -29,58 +29,103 @@
#include "event.h"
#define FD_TYPE (FD_READ | FD_WRITE | FD_EXCEPT)
#define FD_NEW 0x10
#define FD_DELETE 0x20
static LIST_HEAD(event_fd_list);
static LIST_HEAD(event_timeout_list);
static LIST_HEAD(fd_list);
static LIST_HEAD(timeout_list);
struct fd_entry {
struct event_entry {
struct list_head list;
unsigned int flags;
union {
struct {
int fd;
int flags;
int (*callback)(int fd, void *privdata);
void *privdata;
};
struct timeout_entry {
struct list_head list;
int (*read_cb)(int fd, void *privdata);
int (*write_cb)(int fd, void *privdata);
void *read_priv;
void *write_priv;
};
struct {
struct timeval intervall;
struct timeval nextrun;
int (*callback)(void *privdata);
void *privdata;
};
};
};
int event_add_fd(int fd, int type, int (*callback)(int fd, void *privdata), void *privdata)
struct event_entry * event_add_fd(
struct event_entry *entry,
int fd,
int type,
int (*callback)(int fd, void *privdata),
void *privdata)
{
if (fd < 0 || fd > FD_SETSIZE || type == 0)
return -1;
/* check valid filediskriptor */
if (fd < 0 || fd > FD_SETSIZE) {
log_print(LOG_ERROR, "event_add_fd(): invalid fd");
return NULL;
}
struct fd_entry *entry;
entry = malloc(sizeof(struct fd_entry));
/* check valid type (read/write) */
if (!(type & FD_TYPES)) {
log_print(LOG_ERROR, "event_add_fd(): invalid type");
return NULL;
}
/* create new entry */
if (entry == NULL) {
entry = malloc(sizeof(struct event_entry));
if (entry == NULL) {
log_print(LOG_ERROR, "event_add_fd(): out of memory");
return -1;
return NULL;
}
entry->flags = EVENT_FD_CB;
entry->fd = fd;
entry->flags = (type & FD_TYPE) | FD_NEW;
entry->callback = callback;
entry->privdata = privdata;
list_add_tail(&entry->list, &fd_list);
return 0;
/* put it on the list */
list_add_tail(&entry->list, &event_fd_list);
}
if (type & FD_READ) {
entry->flags = (callback != NULL) ? (entry->flags | FD_READ) : (entry->flags & ~FD_READ);
entry->read_cb = callback;
entry->read_priv = privdata;
} else if (type & FD_WRITE) {
entry->flags = (callback != NULL) ? (entry->flags | FD_WRITE) : (entry->flags & ~FD_WRITE);
entry->write_cb = callback;
entry->write_priv = privdata;
}
entry->flags |= EVENT_NEW;
return entry;
}
int event_remove_fd(int fd)
int event_get_fd(struct event_entry *entry)
{
struct fd_entry *entry, *tmp;
list_for_each_entry_safe(entry, tmp, &fd_list, list) {
if (entry->fd == fd)
entry->flags |= FD_DELETE;
if (entry == NULL || !(entry->flags & EVENT_FD_CB))
return -1;
return entry->fd;
}
void event_remove_fd(int fd)
{
struct event_entry *entry, *tmp;
list_for_each_entry_safe(entry, tmp, &event_fd_list, list) {
if (entry->fd == fd) {
entry->flags |= EVENT_DELETE;
return;
}
return 0;
}
return;
}
void event_remove(struct event_entry *entry)
{
/* mark the event as deleted -> remove in select() loop */
entry->flags |= EVENT_DELETE;
}
static void add_timeval(struct timeval *ret, struct timeval *a, struct timeval *b)
@ -105,12 +150,29 @@ static void sub_timeval(struct timeval *ret, struct timeval *a, struct timeval *
}
}
static void schedule_nextrun(struct timeout_entry *entry, struct timeval *now)
static int cmp_timeval(struct timeval *a, struct timeval *b)
{
if (a->tv_sec > b->tv_sec)
return -1;
if (a->tv_sec < b->tv_sec)
return 1;
if (a->tv_usec > b->tv_usec)
return -1;
if (a->tv_usec < b->tv_usec)
return 1;
return 0;
}
static void schedule_nextrun(struct event_entry *entry, struct timeval *now)
{
add_timeval(&entry->nextrun, now, &entry->intervall);
struct timeout_entry *search;
list_for_each_entry(search, &timeout_list, list) {
struct event_entry *search;
list_for_each_entry(search, &event_timeout_list, list) {
if (search->nextrun.tv_sec > entry->nextrun.tv_sec) {
list_add_tail(&entry->list, &search->list);
return;
@ -121,106 +183,108 @@ static void schedule_nextrun(struct timeout_entry *entry, struct timeval *now)
return;
}
}
list_add_tail(&entry->list, &timeout_list);
list_add_tail(&entry->list, &event_timeout_list);
}
int event_add_timeout(struct timeval *timeout, int (*callback)(void *privdata), void *privdata)
struct event_entry * event_add_timeout(
struct timeval *timeout,
int (*callback)(void *privdata),
void *privdata)
{
struct timeout_entry *entry;
entry = malloc(sizeof(struct timeout_entry));
struct event_entry *entry;
entry = malloc(sizeof(struct event_entry));
if (entry == NULL) {
log_print(LOG_ERROR, "event_add_timeout(): out of memory");
return -1;
return NULL;
}
entry->flags = EVENT_TIMEOUT;
memcpy(&entry->intervall, timeout, sizeof(entry->intervall));
entry->callback = callback;
entry->privdata = privdata;
struct timeval now;
gettimeofday(&now, NULL);
schedule_nextrun(entry, &now);
return 0;
return entry;
}
int event_remove_timeout(int id)
{
}
int event_loop(void)
{
fd_set *fdsets = malloc(sizeof(fd_set) * 3);
fd_set *fdsets = malloc(sizeof(fd_set) * 2);
if (fdsets == NULL) {
log_print(LOG_ERROR, "event_loop(): out of memory");
return -1;
}
while (1) {
fd_set *readfds = NULL, *writefds = NULL, *exceptfds = NULL;
struct fd_entry *entry, *tmp;
list_for_each_entry_safe(entry, tmp, &fd_list, list) {
entry->flags &= ~FD_NEW;
fd_set *readfds = NULL, *writefds = NULL;
struct event_entry *entry, *tmp;
if (entry->flags & FD_DELETE) {
list_for_each_entry_safe(entry, tmp, &event_fd_list, list) {
entry->flags &= ~EVENT_NEW;
if (entry->flags & EVENT_DELETE) {
list_del(&entry->list);
free(entry);
} else if ((entry->flags & FD_READ) != 0) {
} else if (entry->flags & FD_READ) {
if (readfds == NULL) {
readfds = &fdsets[0];
FD_ZERO(readfds);
}
FD_SET(entry->fd, readfds);
} else if ((entry->flags & FD_WRITE) != 0) {
} else if (entry->flags & FD_WRITE) {
if (writefds == NULL) {
writefds = &fdsets[1];
FD_ZERO(writefds);
}
FD_SET(entry->fd, writefds);
} else if ((entry->flags & FD_EXCEPT) != 0) {
if (exceptfds == NULL) {
exceptfds = &fdsets[2];
FD_ZERO(exceptfds);
}
FD_SET(entry->fd, exceptfds);
}
}
struct timeval timeout, *timeout_p = NULL;
if (!list_empty(&timeout_list)) {
if (!list_empty(&event_timeout_list)) {
struct timeval now;
gettimeofday(&now, NULL);
struct timeout_entry *entry, *tmp;
list_for_each_entry_safe(entry, tmp, &timeout_list, list) {
/* timeout elapsed */
if (entry->nextrun.tv_sec < now.tv_sec ||
(entry->nextrun.tv_sec == now.tv_sec && entry->nextrun.tv_usec < now.tv_usec)) {
struct event_entry *entry, *tmp;
list_for_each_entry_safe(entry, tmp, &event_timeout_list, list) {
if (entry->flags & EVENT_DELETE) {
list_del(&entry->list);
free(entry);
continue;
}
/* timeout not elapsed, exit search (since list is sorted) */
if (cmp_timeval(&entry->nextrun, &now) == -1)
break;
/* remove event from list */
list_del(&entry->list);
/* execute callback, when callback returns 0 -> schedule event again */
if (entry->callback(entry->privdata)) {
free(entry);
} else {
schedule_nextrun(entry, &now);
}
} else {
break;
}
}
entry = list_entry(timeout_list.next, typeof(*entry), list);
if (!list_empty(&event_timeout_list)) {
entry = list_entry(event_timeout_list.next, typeof(*entry), list);
/* calc select() timeout */
sub_timeval(&timeout, &entry->nextrun, &now);
timeout_p = &timeout;
}
}
int i = select(FD_SETSIZE, readfds, writefds, exceptfds, timeout_p);
int i = select(FD_SETSIZE, readfds, writefds, NULL, timeout_p);
if (i <= 0) {
/* On error, -1 is returned, and errno is set
* appropriately; the sets and timeout become
@ -230,26 +294,19 @@ int event_loop(void)
continue;
} else {
list_for_each_entry(entry, &fd_list, list) {
if ((entry->flags & FD_NEW) != 0) {
list_for_each_entry(entry, &event_fd_list, list) {
if ((entry->flags & EVENT_NEW) != 0) {
/* entry has just been added, execute it next round */
continue;
} else if ((entry->flags & FD_READ) != 0) {
if (!FD_ISSET(entry->fd, readfds))
continue;
} else if ((entry->flags & FD_WRITE) != 0) {
if (!FD_ISSET(entry->fd, writefds))
continue;
} else if ((entry->flags & FD_EXCEPT) != 0) {
if (!FD_ISSET(entry->fd, exceptfds))
continue;
}
if (entry->callback(entry->fd, entry->privdata) != 0)
entry->flags |= FD_DELETE;
if ((entry->flags & FD_READ) && FD_ISSET(entry->fd, readfds))
if (entry->read_cb(entry->fd, entry->read_priv) != 0)
entry->flags |= EVENT_DELETE;
if ((entry->flags & FD_WRITE) && FD_ISSET(entry->fd, writefds))
if (entry->write_cb(entry->fd, entry->write_priv) != 0)
entry->flags |= EVENT_DELETE;
}
}
}

35
event.h
View File

@ -3,23 +3,38 @@
#include <sys/time.h>
#define EVENT_FD_CB 0x10000000
#define EVENT_TIMEOUT 0x20000000
#define EVENT_NEW 0x01000000
#define EVENT_DELETE 0x02000000
#define FD_READ 0x01
#define FD_WRITE 0x02
#define FD_EXCEPT 0x04
#define FD_TYPES (FD_READ | FD_WRITE)
#define event_add_readfd(fd, callback, privdata) \
event_add_fd(fd, FD_READ, callback, privdata)
#define event_add_readfd(entry, fd, callback, privdata) \
event_add_fd(entry, fd, FD_READ, callback, privdata)
#define event_add_writefd(fd, callback, privdata) \
event_add_fd(fd, FD_WRITE, callback, privdata)
#define event_add_writefd(entry, fd, callback, privdata) \
event_add_fd(entry, fd, FD_WRITE, callback, privdata)
#define event_add_exceptfd(fd, callback, privdata) \
event_add_fd(fd, FD_EXCEPT, callback, privdata)
struct event_entry * event_add_fd(
struct event_entry *entry,
int fd,
int type,
int (*callback)(int fd, void *privdata),
void *privdata);
int event_add_fd(int fd, int type, int (*callback)(int fd, void *privdata), void *privdata);
int event_add_timeout(struct timeval *timeout, int (*callback)(void *privdata), void *privdata);
struct event_entry * event_add_timeout(
struct timeval *timeout,
int (*callback)(void *privdata),
void *privdata);
int event_remove_fd(int fd);
int event_get_fd(struct event_entry *entry);
void event_remove_fd(int fd);
void event_remove(struct event_entry *entry);
int event_loop(void);

View File

@ -94,7 +94,7 @@ int tcp_connect_socket(struct sockaddr_in *sa)
return -1;
}
/* non-blocking */
/* non-blocking connect() */
if (fcntl(sock, F_SETFL, flags | O_NONBLOCK)) {
log_print(LOG_ERROR, "tcp_connect_socket(): fcntl(F_SETFL)");
close(sock);
@ -111,7 +111,7 @@ int tcp_connect_socket(struct sockaddr_in *sa)
/* reset EINPROGRESS */
errno = 0;
/* blocking */
/* all further actions are blocking */
if (fcntl(sock, F_SETFL, flags)) {
log_print(LOG_ERROR, "tcp_connect_socket(): fcntl(F_SETFL)");
close(sock);

View File

@ -24,20 +24,13 @@ static int listen_init(const char *value, void *privdata)
if (sock < 0)
return -1;
event_add_readfd(sock, listen_handler, privdata);
event_add_readfd(NULL, sock, listen_handler, privdata);
log_print(LOG_INFO, "listen on %s", get_sockaddr_buf(&addr));
return 0;
}
static int trigger(void *privdata)
{
log_print(LOG_DEBUG, "%s", (char *)privdata);
return 0;
}
int main(int argc, char *argv[])
{
/*
if (config_parse("telnetproxy.conf") == -1)
return -1;
@ -52,16 +45,6 @@ int main(int argc, char *argv[])
log_print(LOG_ERROR, "no admin_listen sockets defined!");
return -1;
}
*/
struct timeval tv;
tv.tv_usec = 0;
tv.tv_sec = 1;
event_add_timeout(&tv, trigger, "trigger 1");
tv.tv_sec = 2;
event_add_timeout(&tv, trigger, "trigger 2");
tv.tv_sec = 3;
event_add_timeout(&tv, trigger, "trigger 3");
event_loop();