working version
This commit is contained in:
parent
1eb9d49ae6
commit
b602d7c17f
105
connection.c
105
connection.c
@ -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
233
event.c
@ -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
35
event.h
@ -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);
|
||||
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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();
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user