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;

}