razzor
/
irclogbot
1
0
Fork 0
Code Issues Pull Requests Releases Activity
Browse Source

new irc impl

master
Olaf Rempel 15 years ago
parent
6b4a2d6f18
commit
92bed5d520
12 changed files with 919 additions and 230 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      Makefile
  2. 302
      event.c
  3. 42
      event.h
  4. 239
      irclogbot.c
  5. 121
      ircsession.c
  6. 34
      ircsession.h
  7. 135
      linebuffer.c
  8. 30
      linebuffer.h
  9. 99
      sockaddr.c
  10. 14
      sockaddr.h
  11. 117
      tcpsocket.c
  12. 12
      tcpsocket.h

4
Makefile
View File

@ -1,11 +1,11 @@
CFLAGS := -O2 -pipe -Wall
OBJS := configfile.o logging.o
OBJS := configfile.o event.o ircsession.o linebuffer.o logging.o sockaddr.o tcpsocket.o
all: irclogbot
irclogbot: $(OBJS) irclogbot.o
$(CC) $(CFLAGS) -o $@ $^ libircclient/src/libircclient.a
$(CC) $(CFLAGS) -o $@ $^
%.o: %.c
$(CC) $(CFLAGS) -c $< -o $@

302
event.c
View File

@ -0,0 +1,302 @@
/***************************************************************************
* Copyright (C) 10/2006 by Olaf Rempel *
* razzor@kopf-tisch.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/time.h>
#include <sys/types.h>
#include "list.h"
#include "logging.h"
#include "event.h"
static LIST_HEAD(event_fd_list);
static LIST_HEAD(event_timeout_list);
struct event_fd {
struct list_head list;
unsigned int flags;
int fd;
int (*read_cb)(int fd, void *privdata);
int (*write_cb)(int fd, void *privdata);
void *read_priv;
void *write_priv;
};
struct event_timeout {
struct list_head list;
unsigned int flags;
struct timeval intervall;
struct timeval nextrun;
int (*callback)(void *privdata);
void *privdata;
};
struct event_fd * event_add_fd(
struct event_fd *entry,
int fd,
int type,
int (*callback)(int fd, void *privdata),
void *privdata)
{
/* check valid filediskriptor */
if (fd < 0 || fd > FD_SETSIZE) {
log_print(LOG_ERROR, "event_add_fd(): invalid fd");
return NULL;
}
/* 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_fd));
if (entry == NULL) {
log_print(LOG_ERROR, "event_add_fd(): out of memory");
return NULL;
}
memset(entry, 0, sizeof(struct event_fd));
entry->flags |= EVENT_NEW;
entry->fd = fd;
/* 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 | EVENT_NEW) : (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 | EVENT_NEW) : (entry->flags & ~FD_WRITE);
entry->write_cb = callback;
entry->write_priv = privdata;
}
return entry;
}
int event_get_fd(struct event_fd *entry)
{
return (entry != NULL) ? entry->fd: -1;
}
void event_remove_fd(struct event_fd *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)
{
ret->tv_usec = a->tv_usec + b->tv_usec;
ret->tv_sec = a->tv_sec + b->tv_sec;
if (ret->tv_usec >= 1000000) {
ret->tv_usec -= 1000000;
ret->tv_sec++;
}
}
static void sub_timeval(struct timeval *ret, struct timeval *a, struct timeval *b)
{
ret->tv_usec = a->tv_usec - b->tv_usec;
ret->tv_sec = a->tv_sec - b->tv_sec;
if (ret->tv_usec < 0) {
ret->tv_usec += 1000000;
ret->tv_sec--;
}
}
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_timeout *entry, struct timeval *now)
{
add_timeval(&entry->nextrun, now, &entry->intervall);
struct event_timeout *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;
} else if (search->nextrun.tv_sec == entry->nextrun.tv_sec &&
search->nextrun.tv_usec > entry->nextrun.tv_usec) {
list_add_tail(&entry->list, &search->list);
return;
}
}
list_add_tail(&entry->list, &event_timeout_list);
}
struct event_timeout * event_add_timeout(
struct timeval *timeout,
int (*callback)(void *privdata),
void *privdata)
{
struct event_timeout *entry;
entry = malloc(sizeof(struct event_timeout));
if (entry == NULL) {
log_print(LOG_ERROR, "event_add_timeout(): out of memory");
return NULL;
}
entry->flags = 0;
memcpy(&entry->intervall, timeout, sizeof(entry->intervall));
entry->callback = callback;
entry->privdata = privdata;
struct timeval now;
gettimeofday(&now, NULL);
schedule_nextrun(entry, &now);
return entry;
}
void event_remove_timeout(struct event_timeout *entry)
{
/* mark the event as deleted -> remove in select() loop */
entry->flags |= EVENT_DELETE;
}
int event_loop(void)
{
fd_set *fdsets = malloc(sizeof(fd_set) * 2);
if (fdsets == NULL) {
log_print(LOG_ERROR, "event_loop(): out of memory");
return -1;
}
while (1) {
struct timeval timeout, *timeout_p = NULL;
if (!list_empty(&event_timeout_list)) {
struct timeval now;
gettimeofday(&now, NULL);
struct event_timeout *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);
}
}
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;
}
}
fd_set *readfds = NULL, *writefds = NULL;
struct event_fd *entry, *tmp;
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);
continue;
}
if (entry->flags & FD_READ) {
if (readfds == NULL) {
readfds = &fdsets[0];
FD_ZERO(readfds);
}
FD_SET(entry->fd, readfds);
}
if (entry->flags & FD_WRITE) {
if (writefds == NULL) {
writefds = &fdsets[1];
FD_ZERO(writefds);
}
FD_SET(entry->fd, writefds);
}
}
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
* undefined, so do not rely on their contents
* after an error.
*/
continue;
} else {
list_for_each_entry(entry, &event_fd_list, list) {
if (((entry->flags & (FD_READ | EVENT_NEW)) == 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 | EVENT_NEW)) == FD_WRITE) && FD_ISSET(entry->fd, writefds))
if (entry->write_cb(entry->fd, entry->write_priv) != 0)
entry->flags |= EVENT_DELETE;
}
}
}
free(fdsets);
}

42
event.h
View File

@ -0,0 +1,42 @@
#ifndef _EVENT_H_
#define _EVENT_H_
#include <sys/time.h>
#define EVENT_NEW 0x1000
#define EVENT_DELETE 0x2000
#define FD_READ 0x0001
#define FD_WRITE 0x0002
#define FD_TYPES (FD_READ | FD_WRITE)
#define event_add_readfd(entry, fd, callback, privdata) \
event_add_fd(entry, fd, FD_READ, callback, privdata)
#define event_add_writefd(entry, fd, callback, privdata) \
event_add_fd(entry, fd, FD_WRITE, callback, privdata)
/* inner details are not visible to external users (TODO: size unknown) */
struct event_fd;
struct event_timeout;
struct event_fd * event_add_fd(
struct event_fd *entry,
int fd,
int type,
int (*callback)(int fd, void *privdata),
void *privdata);
int event_get_fd(struct event_fd *entry);
void event_remove_fd(struct event_fd *entry);
struct event_timeout * event_add_timeout(
struct timeval *timeout,
int (*callback)(void *privdata),
void *privdata);
void event_remove_timeout(struct event_timeout *entry);
int event_loop(void);
#endif /* _EVENT_H_ */

239
irclogbot.c
View File

@ -1,244 +1,27 @@
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <getopt.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <errno.h>
#include "libircclient/include/libircclient.h"
#include "configfile.h"
#include "event.h"
#include "ircsession.h"
#include "list.h"
#include "logging.h"
#define DEFAULT_CONFIG "irclogbot.conf"
#define DEFAULT_LOGFILE "irclogbot.log"
static struct option opts[] = {
{"config", 1, 0, 'c'},
{"debug", 0, 0, 'd'},
{"help", 0, 0, 'h'},
{0, 0, 0, 0}
};
struct irc_client {
struct list_head list;
irc_session_t *session;
const char *server;
const char *nickname;
const char *channel;
const char *channelkey;
struct in_addr addr;
};
static LIST_HEAD(client_list);
static irc_callbacks_t irc_cbs;
static int add_client(const char *parameter, void *privdata)
{
struct irc_client *entry = malloc(sizeof(struct irc_client));
if (entry == NULL) {
log_print(LOG_ERROR, "add_client(): out of memory");
return -1;
}
if (inet_pton(AF_INET, parameter, &entry->addr) <= 0) {
log_print(LOG_ERROR, "add_client(): inet_pton()");
free(entry);
return -1;
}
const char *defserver = config_get_string("global", "server", NULL);
entry->server = config_get_string(parameter, "server", defserver);
if (entry->server == NULL) {
log_print(LOG_ERROR, "add_client(): client %s: no server given", parameter);
free(entry);
return -1;
}
const char *defchannel = config_get_string("global", "channel", NULL);
entry->channel = config_get_string(parameter, "channel", defchannel);
if (entry->channel == NULL) {
log_print(LOG_ERROR, "add_client(): client %s: no channel given", parameter);
free(entry);
return -1;
}
const char *defchannelkey = config_get_string("global", "channelkey", NULL);
entry->channelkey = config_get_string(parameter, "channelkey", defchannelkey);
entry->nickname = config_get_string(parameter, "nickname", NULL);
if (entry->nickname == NULL) {
log_print(LOG_ERROR, "add_client(): client %s: no nickname given", parameter);
free(entry);
return -1;
}
entry->session = irc_create_session(&irc_cbs);
if (entry->session == NULL) {
log_print(LOG_ERROR, "add_client(): irc_create_session()");
free(entry);
return -1;
}
irc_set_ctx(entry->session, entry);
irc_option_set(entry->session, LIBIRC_OPTION_STRIPNICKS);
int ret = irc_connect(entry->session, entry->server, 6667, NULL, entry->nickname, NULL, NULL);
if (ret != 0) {
log_print(LOG_ERROR, "add_client(): irc_connect(): %s", irc_strerror(irc_errno(entry->session)));
irc_destroy_session(entry->session);
free(entry);
return -1;
}
/* HACK: irc_connect() sets errno */
errno = 0;
log_print(LOG_DEBUG, "added client %s (server: %s chan: %s nickname: %s)",
parameter, entry->server, entry->channel, entry->nickname);
list_add(&entry->list, &client_list);
return 0;
}
static void event_connect(irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count)
{
struct irc_client *entry = (struct irc_client *) irc_get_ctx(session);
irc_cmd_join(session, entry->channel, entry->channelkey);
}
static void event_join(irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count)
{
struct irc_client *entry = (struct irc_client *) irc_get_ctx(session);
irc_cmd_user_mode(session, "+i");
char buf[32] = { "forwarding from " };
inet_ntop(AF_INET, &entry->addr, buf +16, 16);
irc_cmd_msg(session, params[0], buf);
}
static void event_numeric(irc_session_t *session, unsigned int event, const char *origin, const char **params, unsigned int count)
{
if (event < 400)
return;
log_print(LOG_INFO, "EVENT %d: %s: %s %s %s %s",
event, (origin ? origin : "unknown"), params[0],
count > 1 ? params[1] : "",
count > 2 ? params[2] : "",
count > 3 ? params[3] : "");
}
#include "sockaddr.h"
int main(int argc, char *argv[])
{
char *config = DEFAULT_CONFIG;
int code, arg = 0, debug = 0;
do {
code = getopt_long(argc, argv, "c:dh", opts, &arg);
switch (code) {
case 'c': /* config */
config = optarg;
break;
case 'd': /* debug */
debug = 1;
break;
case 'h': /* help */
printf("Usage: ctstat [options]\n"
"Options: \n"
" --config -c configfile use this configfile\n"
" --debug -d do not fork and log to stderr\n"
" --help -h this help\n"
"\n");
exit(0);
break;
case '?': /* error */
exit(-1);
break;
default: /* unknown / all options parsed */
break;
}
} while (code != -1);
/* parse config file */
if (config_parse(config))
exit(1);
int sock = socket(PF_INET, SOCK_DGRAM, 0);
if (sock < 0) {
log_print(LOG_ERROR, "socket()");
return -1;
}
struct sockaddr_in addr = {
.sin_family = AF_INET,
.sin_port = htons(514),
.sin_addr.s_addr = INADDR_ANY,
};
if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
log_print(LOG_ERROR, "bind()");
return -1;
}
irc_cbs.event_connect = event_connect;
irc_cbs.event_join = event_join;
irc_cbs.event_numeric = event_numeric;
int cnt = config_get_strings("global", "client", add_client, NULL);
if (cnt == 0) {
log_print(LOG_ERROR, "no clients defined");
close(sock);
exit(1);
}
char buf[1500];
while (1) {
fd_set rd_fds, wr_fds;
FD_ZERO(&rd_fds);
FD_ZERO(&wr_fds);
FD_SET(sock, &rd_fds);
int maxfd = sock;
struct irc_client *entry;
list_for_each_entry(entry, &client_list, list) {
int ret = irc_add_select_descriptors(entry->session, &rd_fds, &wr_fds, &maxfd);
if (ret != 0)
log_print(LOG_WARN, "irc_add_select_descriptors(): %s", irc_strerror(irc_errno(entry->session)));
}
struct irc_session *session = irc_create_session();
select(maxfd +1, &rd_fds, &wr_fds, NULL, NULL);
parse_sockaddr("83.140.172.211:6667", &session->srv_addr);
session->server_pass = NULL;
session->nickname = "logtest_";
// session->username = "logtest_";
// session->realname = "logtest_";
int len = 0;
if (FD_ISSET(sock, &rd_fds)) {
unsigned int i = sizeof(addr);
len = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr *)&addr, &i);
}
irc_connect(session);
list_for_each_entry(entry, &client_list, list) {
if (len > 0 && (entry->addr.s_addr == addr.sin_addr.s_addr))
irc_cmd_msg(entry->session, entry->channel, buf);
event_loop();
int ret = irc_process_select_descriptors(entry->session, &rd_fds, &wr_fds);
if (ret != 0)
log_print(LOG_WARN, "irc_process_select_descriptors(): %s", irc_strerror(irc_errno(entry->session)));
}
}
return 0;
}

121
ircsession.c
View File

@ -0,0 +1,121 @@
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdarg.h>
#include "event.h"
#include "ircsession.h"
#include "linebuffer.h"
#include "logging.h"
#include "sockaddr.h"
#include "tcpsocket.h"
struct irc_session * irc_create_session(void)
{
struct irc_session *session = malloc(sizeof(struct irc_session));
if (session == NULL)
return NULL;
session->state = IRC_NONE;
session->inbuf = create_linebuffer(4096);
session->outbuf = create_linebuffer(4096);
return session;
}
void irc_destroy_session(struct irc_session *session)
{
linebuffer_free(session->outbuf);
linebuffer_free(session->inbuf);
free(session);
}
static int irc_write_cb(int fd, void *privdata)
{
struct irc_session *session = (struct irc_session *)privdata;
linebuffer_writefd(session->outbuf, fd);
/* remove write fd again */
event_add_writefd(session->handler, 0, NULL, NULL);
return 0;
}
int irc_send(struct irc_session *session, const char *fmt, ...)
{
va_list az;
va_start(az, fmt);
linebuffer_vprintf(session->outbuf, fmt, az);
va_end (az);
linebuffer_put(session->outbuf, "\r\n", 2);
/* schedule a write */
event_add_writefd(session->handler, 0, irc_write_cb, session);
return 0;
}
static int irc_read_cb(int fd, void *privdata)
{
struct irc_session *session = (struct irc_session *)privdata;
int len = linebuffer_readfd(session->inbuf, fd);
if (len <= 0) {
session->state = IRC_DISCONNECTED;
log_print(LOG_DEBUG, "irc_read_cb(): disconnected from %s", get_sockaddr_buf(&session->srv_addr));
return -1;
}
char *line;
while ((line = linebuffer_getline(session->inbuf, NULL)) != NULL) {
log_print(LOG_DEBUG, "irc_read_cb(): from %s: %s", get_sockaddr_buf(&session->srv_addr), line);
if (strncmp(line, "PING", 4) == 0)
irc_send(session, "PONG %s", line +6);
linebuffer_freeline(session->inbuf);
}
return 0;
}
static int irc_connect_cb(int fd, void *privdata)
{
struct irc_session *session = (struct irc_session *)privdata;
if (tcp_connect_error(fd)) {
session->state = IRC_CONNECTION_FAILED;
log_print(LOG_DEBUG, "irc_connect_cb(): failed to connect to %s", get_sockaddr_buf(&session->srv_addr));
return -1;
}
session->state = IRC_CONNECTED;
event_add_readfd(session->handler, 0, irc_read_cb, session);
event_add_writefd(session->handler, 0, NULL, NULL);
log_print(LOG_DEBUG, "irc_connect_cb(): connected to %s", get_sockaddr_buf(&session->srv_addr));
if (session->server_pass != NULL)
irc_send(session, "PASS %s", session->server_pass);
irc_send(session, "NICK %s", session->nickname);
irc_send(session, "USER %s unknown unknown :%s",
session->username ? session->username : "nobody",
session->realname ? session->realname : "noname");
return 0;
}
int irc_connect(struct irc_session *session)
{
/* TODO: check state before connecting */
session->sock = tcp_connect_nonblock(&session->srv_addr);
if (session->sock < 0)
return -1;
session->state = IRC_CONNECTING;
session->handler = event_add_writefd(NULL, session->sock, irc_connect_cb, session);
log_print(LOG_DEBUG, "irc_connect(): connecting to %s", get_sockaddr_buf(&session->srv_addr));
return 0;
}

34
ircsession.h
View File

@ -0,0 +1,34 @@
#ifndef _IRCSESSION_H_
#define _IRCSESSION_H_
#include <netinet/in.h>
struct irc_session {
struct sockaddr_in srv_addr;
struct event_fd *handler;
int sock;
int state;
struct linebuffer *inbuf;
struct linebuffer *outbuf;
char *server_pass;
char *nickname;
char *username;
char *realname;
};
enum {
IRC_NONE = 0,
IRC_CONNECTING,
IRC_CONNECTION_FAILED,
IRC_CONNECTED,
IRC_DISCONNECTED,
};
struct irc_session * irc_create_session(void);
void irc_destroy_session(struct irc_session *session);
int irc_connect(struct irc_session *session);
#endif /* _IRCSESSION_H_ */

135
linebuffer.c
View File

@ -0,0 +1,135 @@
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdarg.h>
#include "linebuffer.h"
#define MIN(a,b) (((a) < (b)) ? (a) : (b))
struct linebuffer * create_linebuffer(int size)
{
struct linebuffer *buf = malloc(sizeof(struct linebuffer));
if (buf == NULL)
return NULL;
buf->size = size;
buf->data = malloc(buf->size);
if (buf->data == NULL) {
free(buf);
return NULL;
}
buf->pos = 0;
return buf;
}
void linebuffer_free(struct linebuffer *buf)
{
free(buf->data);
free(buf);
}
int linebuffer_clear(struct linebuffer *buf)
{
int oldpos = buf->pos;
buf->pos = 0;
return oldpos;
}
int linebuffer_put(struct linebuffer *buf, const char *src, unsigned int size)
{
int len = MIN(buf->size - buf->pos, size);
memcpy(buf->data + buf->pos, src, len);
buf->pos += len;
return len;
}
int linebuffer_readfd(struct linebuffer *buf, int fd)
{
int len = read(fd, buf->data + buf->pos, buf->size - buf->pos);
if (len <= 0)
return -1;
buf->pos += len;
return len;
}
int linebuffer_parsefd(struct linebuffer *buf, int fd)
{
char tmp[32];
int len = read(fd, tmp, sizeof(tmp));
if (len <= 0)
return -1;
int i;
for (i = 0; i < len; i++) {
/* "understand" backspace */
if (tmp[i] == 0x08 && buf->pos > 0) {
buf->pos--;
/* copy */
} else if (tmp[i] >= ' ' || tmp[i] == '\n') {
*(buf->data + buf->pos++) = tmp[i];
}
if (buf->pos > buf->size)
return -1;
}
return 0;
}
int linebuffer_writefd(struct linebuffer *buf, int fd)
{
int len = write(fd, buf->data, buf->pos);
if (len <= 0)
return -1;
/* TODO: now assuming everything is written */
buf->pos = 0;
return len;
}
int linebuffer_vprintf(struct linebuffer *buf, const char *fmt, va_list az)
{
int len = vsnprintf(buf->data + buf->pos, buf->size - buf->pos, fmt, az);
if (len < 0 || len >= (buf->size - buf->pos))
return -1;
buf->pos += len;
return len;
}
int linebuffer_printf(struct linebuffer *buf, const char *fmt, ...)
{
va_list az;
va_start(az, fmt);
int ret = linebuffer_vprintf(buf, fmt, az);
va_end(az);
return ret;
}
char * linebuffer_getline(struct linebuffer *buf, int *len)
{
buf->newline = memchr(buf->data, '\n', buf->pos);
if (buf->newline == NULL)
return NULL;
*(buf->newline) = '\0';
if (len != NULL)
*len = buf->newline - buf->data;
return buf->data;
}
int linebuffer_freeline(struct linebuffer *buf)
{
buf->pos -= (buf->newline - buf->data) +1;
memmove(buf->data, buf->newline +1, buf->pos);
buf->newline = NULL;
return buf->pos;
}

30
linebuffer.h
View File

@ -0,0 +1,30 @@
#ifndef _LINEBUFFER_H_
#define _LINEBUFFER_H_
#include <stdarg.h>
struct linebuffer {
unsigned int size;
unsigned int pos;
char *newline;
char *data;
};
struct linebuffer * create_linebuffer(int size);
void linebuffer_free(struct linebuffer *buf);
int linebuffer_clear(struct linebuffer *buf);
int linebuffer_readfd(struct linebuffer *buf, int fd);
int linebuffer_parsefd(struct linebuffer *buf, int fd);
int linebuffer_writefd(struct linebuffer *buf, int fd);
int linebuffer_put(struct linebuffer *buf, const char *src, unsigned int size);
int linebuffer_vprintf(struct linebuffer *buf, const char *fmt, va_list ap);
int linebuffer_printf(struct linebuffer *buf, const char *fmt, ...);
char * linebuffer_getline(struct linebuffer *buf, int *len);
int linebuffer_freeline(struct linebuffer *buf);
#endif /* _LINEBUFFER_H_ */

99
sockaddr.c
View File

@ -0,0 +1,99 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int parse_sockaddr(const char *addr, struct sockaddr_in *sa)
{
char *buf = strdup(addr);
if (buf == NULL)
return -1;
char *tmp;
char *ipstr = strtok_r(buf, ":", &tmp);
if (ipstr == NULL) {
free(buf);
return -2;
}
sa->sin_family = AF_INET;
if (inet_pton(AF_INET, ipstr, &sa->sin_addr) <= 0) {
free(buf);
return -3;
}
char *portstr = strtok_r(NULL, " \r\n", &tmp);
if (portstr == NULL) {
free(buf);
return -4;
}
int port = atoi(portstr);
if (port < 0 || port > 65535) {
free(buf);
return -5;
}
sa->sin_port = htons(port);
free(buf);
return 0;
}
int parse_subnet(const char *addr, struct in_addr *net, struct in_addr *mask)
{
char *buf = strdup(addr);
if (buf == NULL)
return -1;
char *tmp;
char *netstr = strtok_r(buf, "/", &tmp);
if (netstr == NULL) {
free(buf);
return -2;
}
if (inet_pton(AF_INET, netstr, net) <= 0) {
free(buf);
return -3;
}
char *maskstr = strtok_r(NULL, " \r\n", &tmp);
if (maskstr == NULL) {
mask->s_addr = ~0;
} else if (inet_pton(AF_INET, maskstr, mask) <= 0) {
int maskbits = atoi(maskstr);
if (maskbits < 0 || maskbits > 32) {
free(buf);
return -4;
}
mask->s_addr = htonl(~0 << (32 - maskbits));
}
free(buf);
return 0;
}
int get_sockaddr(char *buf, int size, struct sockaddr_in *addr)
{
return snprintf(buf, size, "%s:%d", inet_ntoa(addr->sin_addr), ntohs(addr->sin_port));
}
char * get_sockaddr_buf(struct sockaddr_in *addr)
{
static char ret[24];
get_sockaddr(ret, sizeof(ret), addr);
return ret;
}
int same_sockaddr(struct sockaddr_in *a, struct sockaddr_in *b)
{
return !((a->sin_family ^ b->sin_family) |
(a->sin_addr.s_addr ^ b->sin_addr.s_addr) |
(a->sin_port ^ b->sin_port));
}

14
sockaddr.h
View File

@ -0,0 +1,14 @@
#ifndef _SOCKADDR_H_
#define _SOCKADDR_H_
#include <netinet/in.h>
int parse_sockaddr(const char *addr, struct sockaddr_in *sa);
int parse_subnet(const char *addr, struct in_addr *net, struct in_addr *mask);
int get_sockaddr(char *buf, int size, struct sockaddr_in *addr);
char * get_sockaddr_buf(struct sockaddr_in *addr);
int same_sockaddr(struct sockaddr_in *a, struct sockaddr_in *b);
#endif /* _SOCKADDR_H_ */

117
tcpsocket.c
View File

@ -0,0 +1,117 @@
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <errno.h>
#include "logging.h"
#include "sockaddr.h"
int tcp_listen(struct sockaddr_in *sa)
{
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0 ) {
log_print(LOG_ERROR, "tcp_listen_socket(): socket()");
return -1;
}
int i = 1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i))) {
log_print(LOG_ERROR, "tcp_listen_socket(): setsockopt(SO_REUSEADDR)");
close(sock);
return -1;
}
if (bind(sock, (struct sockaddr *)sa, sizeof(*sa))) {
log_print(LOG_ERROR, "tcp_listen_socket(): bind(%s)", get_sockaddr_buf(sa));
close(sock);
return -1;
}
if (listen(sock, 8)) {
log_print(LOG_ERROR, "tcp_listen_socket(): listen()");
close(sock);
return -1;
}
return sock;
}
int tcp_connect(struct sockaddr_in *sa)
{
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0 ) {
log_print(LOG_ERROR, "tcp_connect_socket(): socket()");
return -1;
}
int ret = connect(sock, (struct sockaddr *)sa, sizeof(*sa));
if (ret != 0) {
log_print(LOG_ERROR, "tcp_connect(): connect(%s)", get_sockaddr_buf(sa));
close(sock);
return -1;
}
return sock;
}
int tcp_connect_nonblock(struct sockaddr_in *sa)
{
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0 ) {
log_print(LOG_ERROR, "tcp_connect_nonblock(): socket()");
return -1;
}
int flags = fcntl(sock, F_GETFL, 0);
if (flags < 0) {
log_print(LOG_ERROR, "tcp_connect_nonblock(): fcntl(F_GETFL)");
close(sock);
return -1;
}
/* non-blocking connect() */
if (fcntl(sock, F_SETFL, flags | O_NONBLOCK)) {
log_print(LOG_ERROR, "tcp_connect_nonblock(): fcntl(F_SETFL)");
close(sock);
return -1;
}
int ret = connect(sock, (struct sockaddr *)sa, sizeof(*sa));
if (ret && errno != EINPROGRESS) {
log_print(LOG_ERROR, "tcp_connect_nonblock(): connect(%s)", get_sockaddr_buf(sa));
close(sock);
return -1;
}
/* reset EINPROGRESS */
errno = 0;
/* all further actions are blocking */
if (fcntl(sock, F_SETFL, flags)) {
log_print(LOG_ERROR, "tcp_connect_nonblock(): fcntl(F_SETFL)");
close(sock);
return -1;
}
return sock;
}
int tcp_connect_error(int fd)
{
int err;
unsigned int err_size = sizeof(err);
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &err_size)) {
log_print(LOG_ERROR, "tcp_connect_error(): getsockopt(SO_ERROR)");
return -1;
}
if (err) {
errno = err;
return -1;
}
return 0;
}

12
tcpsocket.h
View File

@ -0,0 +1,12 @@
#ifndef _TCPSOCKET_H_
#define _TCPSOCKET_H_
#include <netinet/ip.h>
int tcp_listen(struct sockaddr_in *sa);
int tcp_connect(struct sockaddr_in *sa);
int tcp_connect_nonblock(struct sockaddr_in *sa);
int tcp_connect_error(int fd);
#endif // _TCPSOCKET_H_
Write Preview
Loading…
Cancel
Save