Bip

if (strlen(hex) != 40)

fatal("Incorrect password format %s\n", hex);

for (i = 0; i < 20; i++) {

sscanf(hex + 2 * i, "%02x", &buf);

md5[i] = buf;

f = fopen(conf_pid_file, "r");

if (f)

goto pid_is_there;

fatal("%s %s", "gethostname", strerror(errno));

hname[511] = 0;

snprintf(longpath, longpath_max - 1, "%s.%s.%ld", conf_pid_file, hname,

n->serverv = NULL;

n->serverc = 0;

} else {

hash_insert(&bip->networks, name, n);

}

case LEX_BACKLOG:

ci->backlog = t2->ndata;

break;

}

if (t2->tuple_type == TUPLE_STR && t2->pdata)

free(t2->pdata);

}

u = hash_get(&bip->users, name);

if (!u) {

hash_insert(&bip->users, name, u);

hash_init(&u->connections, HASH_NOCASE);

u->admin = 0;

else

nick = LINK(ic)->prev_nick;

str[4095] = 0;

WRITE_LINE2(CONN(ic), P_IRCMASK, (LINK(ic)->user->bip_use_notice ?

"NOTICE" : "PRIVMSG"), nick, str);

if (conf_log_system && conf_daemonize) {

if (conf_global_log_file && conf_global_log_file != stderr)

fclose(conf_global_log_file);

FILE *f = fopen(buf, "a");

if (!f)

fatal("Can't open %s: %s", buf, strerror(errno));

pid = daemonize();

else

pid = getpid();

write(fd, buf, strlen(buf));

close(fd);

* Shitty: we might have written a partial line, so we hack the line...

* Callers of _write_socket muse provide a writable message

*/

if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINPROGRESS) {

memmove(message, message + tcount, size - tcount + 1);

return WRITE_KEEP;

}

char *incoming;

list_t *outgoing;

outgoing = list_new(NULL);

conn->anti_flood = anti_flood;

connection_t *conn;

char portbuf[20];

/* TODO: allow litteral service name in the function interface */

portbuf[19] = '\0';

/*

SSL_load_error_strings();

errbio = BIO_new_fp(conf_global_log_file, BIO_NOCLOSE);

NULL, NULL,NULL);

flags = O_RDONLY;

}

do {

if (ret <= 0) {

mylog(LOG_ERROR,"/dev/random: %s",

strerror(errno));

mylog(LOG_ERROR, "Can't open SSL certificate check store! Check path "

"and permissions.");

return conn;

}

switch (conn->ssl_check_mode) {

(void)ssl_client_certfile;

#endif

/* TODO: allow litteral service name in the function interface */

dstportbuf[19] = '\0';

if (srcport) {

srcportbuf[19] = '\0';

tmp = srcportbuf;

} else

return NULL;

}

switch (addr.sa_family) {

case AF_INET:

struct channel *channel_new(const char *name)

{

struct channel *chan;

chan->name = bip_strdup(name);

hash_init(&chan->ovmasks, HASH_NOCASE);

return chan;

list_t *ret;

hash_iterator_t hi;

size_t len = 0;

ret = list_new(NULL);

*str = 0;

if (len + strlen(nick) + 2 + (ovmask ? 1 : 0) >= NAMESIZE) {

list_add_last(ret, str);

*str = 0;

len = 0;

}

list_iterator_t itocs;

for (list_it_init(&LINK(server)->on_connect_send, &itocs);

list_it_item(&itocs); list_it_next(&itocs)) {

char *str = bip_malloc(len + 1);

sprintf(str, "%s\r\n", (char *)list_it_item(&itocs));

write_line(CONN(server), str);

if (LINK(server)->ignore_server_capab &&

irc_line_elem_equals(line, i, "CAPAB"))

irc_line_drop(line, i);

server_set_chanmodes(server, irc_line_elem(line, i) + 10);

server_set_prefix(server, irc_line_elem(line, i) + 7);

}

}

static char *irc_timestamp(void)

{

return ts;

}

if (!newconn)

return NULL;

CONN(ircc) = newconn;

TYPE(ircc) = IRC_TYPE_LOGGING_CLIENT;

CONN(ircc)->user_data = ircc;

{

struct link_client *c;

list_init(&c->who_queue, list_ptr_cmp);

return c;

{

struct link_server *s;

TYPE(s) = IRC_TYPE_SERVER;

hash_init(&s->channels, HASH_NOCASE);

content = (char *)bip_malloc(stats.st_size + 1);

(size_t)stats.st_size) {

mylog(LOG_WARN, "Can't read %s fully",

bip->oidentdpath);

bipstart = strstr(content, BIP_OIDENTD_START);

if (bipstart != NULL) {

mylog(LOG_DEBUG, "Can't reset %s size",

bip->oidentdpath);

free(content);

struct link *irc_link_new(void)

{

struct link *link;

link->l_server = NULL;

hash_init(&link->chan_infos, HASH_NOCASE);

modes = cur + 1;

} else {

// emptry string

}

mylog(LOG_DEBUGVERB, "[%s] Modes: '%s'", LINK(l)->name, dup);

array_push(&l->chanmodes, dup);

int backlog;

};

struct link_server {

struct link_connection _link_c;

void irc_server_free(struct link_server *is);

struct client *client_new(void);

void irc_main(bip_t *);

void irc_client_close(struct link_client *);

void irc_client_free(struct link_client *);

struct link *irc_link_new(void);

void irc_line_init(struct line *l);

void _irc_line_deinit(struct line *l);

void irc_line_write(struct line *l, connection_t *c);

void irc_line_append(struct line *l, const char *s);

struct line *irc_line_new_from_string(char *str);

int slash_ok = 1;

while (*tmp == '/') {

if (slash_ok) {

count++;

slash_ok = 0;

}

char *dest = bip_strdup(destination);

strtolower(dest);

time(&s);

now = localtime(&s);

conf_log_format);

replace_var(logfile, "%u", logdata->user->name, MAX_PATH_LEN);

replace_var(logfile, "%n", logdata->network, MAX_PATH_LEN);

return 0;

}

mylog(LOG_ERROR, "fseek(%s) %s", uniq_fname,

strerror(errno));

free(uniq_fname);

store = hash_get(&logdata->logfgs, destination);

if (!store) {

list_init(&store->file_group, NULL);

store->name = bip_strdup(destination);

store->skip_advance = 0;

void log_join(log_t *logdata, const char *ircmask, const char *channel)

{

"%s -!- %s has joined %s", timestamp(), ircmask,

channel);

log_write(logdata, channel, logdata->buffer);

const char *message)

{

if (message)

"%s -!- %s has left %s [%s]", timestamp(), ircmask,

channel, message);

else

"%s -!- %s has left %s", timestamp(), ircmask,

channel);

log_write(logdata, channel, logdata->buffer);

void log_kick(log_t *logdata, const char *ircmask, const char *channel,

const char *who, const char *message)

{

"%s -!- %s has been kicked by %s [%s]", timestamp(),

who, ircmask, message);

log_write(logdata, channel, logdata->buffer);

void log_quit(log_t *logdata, const char *ircmask, const char *channel,

const char *message)

{

"%s -!- %s has quit [%s]", timestamp(), ircmask,

message);

log_write(logdata, channel, logdata->buffer);

}

free(oldnick);

"%s -!- %s is now known as %s",

timestamp(), ircmask, newnick);

log_write(logdata, channel, logdata->buffer);

if (*message == '+' || *message == '-')

real_message++;

return;

msg = bip_strdup(real_message);

*(msg + strlen(msg) - 1) = '\0';

"%s %c * %s %s", timestamp(), dir,

from, msg + 8);

free(msg);

} else {

"%s %c %s: %s", timestamp(), dir,

from, message);

}

void log_topic(log_t *logdata, const char *ircmask, const char *channel,

const char *message)

{

"%s -!- %s changed topic of %s to: %s", timestamp(),

ircmask, channel, message);

log_write(logdata, channel, logdata->buffer);

void log_init_topic(log_t *logdata, const char *channel, const char *message)

{

"%s -!- Topic for %s: %s", timestamp(), channel,

message);

log_write(logdata, channel, logdata->buffer);

seconds = atoi(when);

time = localtime(&seconds);

timestr[0] = '\0';

if (time)

timestr[50] = '\0';

"%s -!- Topic set by %s [%s]", timestamp(), who,

timestr);

free(timestr);

const char *modes, array_t *mode_args)

{

int i;

char *tmp;

if (mode_args) {

for (i = 0; i < array_count(mode_args); i++) {

(char *)array_get(mode_args, i));

tmp = tmpbuf;

tmpbuf = tmpbuf2;

}

}

log_write(logdata, channel, logdata->buffer);

free(tmpbuf);

void log_disconnected(log_t *logdata)

{

hash_iterator_t hi;

" from server...", timestamp());

for (hash_it_init(&logdata->logfgs, &hi); hash_it_item(&hi);

hash_it_next(&hi))

list_t *l = log_backlogs(logdata);

char *s;

"%s -!- Ping timeout with server...", timestamp());

while ((s = list_remove_first(l))) {

log_write(logdata, s, logdata->buffer);

{

hash_iterator_t hi;

" server...", timestamp());

for (hash_it_init(&logdata->logfgs, &hi); hash_it_item(&hi);

hash_it_next(&hi)) {

lots = p - sots;

p++;

if (logdata->user->bl_msg_only)

return NULL;

else

}

} else {

//mylog(LOG_ERROR, "bread Seeking %s to %d", lf->filename, 0);

mylog(LOG_ERROR, "Can't seek in %s", lf->filename);

list_add_last(res, _log_wrap(store->name,

"Error seeking in logfile"));

}

}

for(;;) {

if (!fgets(buf, LOGLINE_MAXLEN, lf->file)) {

if (ferror(lf->file)) {

char *buf;

size_t count;

":" P_IRCMASK " PRIVMSG %s :%s\r\n", dest, line);

if (count >= LOGLINE_MAXLEN + 1) {

mylog(LOG_DEBUG, "line too long");

size_t len;

static char tmpstr[LOGLINE_MAXLEN + 1];

tmpstr[LOGLINE_MAXLEN] = 0;

if (store->memlog) {

len = strlen(tmpstr);

nbwrite = fwrite(tmpstr, sizeof(char), len, lf->file);

log_updatelast(lf);

if (nbwrite != len + 1)

mylog(LOG_ERROR, "Error writing to %s logfile", lf->filename);

{

log_t *logdata;

logdata->user = user;

logdata->network = bip_strdup(network);

hash_init(&logdata->logfgs, HASH_NOCASE);

logdata->buffer[LOGLINE_MAXLEN - 1] = 0; // debug

logdata->buffer[LOGLINE_MAXLEN] = 0;

logdata->connected = 0;

padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );

md5_update( ctx, md5_padding, padn );

PUT_UINT32( ctx->state[0], digest, 0 );

PUT_UINT32( ctx->state[1], digest, 4 );

ptr[3] = seed & 0xff;

memcpy(ptr + 4, str, length - 4);

md5_starts(&ctx);

md5_update(&ctx, ptr, length);

md5_finish(&ctx, md5 + 4);

md5_starts(&ctx);

md5_finish(&ctx, md5 + 4);

free(ptr);

return md5;

{

fflush(conf_global_log_file);

#define OOMMSG "Out of memory.\n"

#undef OOMMSG

fflush(conf_global_log_file);

exit(28);

time(&tv);

tm = localtime(&tv);

return ts;

}

return "never";

tm = localtime(&s);

return ts;

}