irclibs/C/irc.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include "irc.h"

int IRCC_urecv(IRCC_client *irc, char **buf, const size_t size) {
	#if defined(ENABLE_SSL) || defined(ENABLE_TLS)
		if (irc->irc_usingssl)
			return SSL_read(irc->irc_ssl, *buf, size);
	#endif

	return recv(irc->irc_socket, *buf, size, 0);
}

int IRCC_usend(IRCC_client *irc, const char *msg, const size_t size) {
	#if defined(ENABLE_SSL) || defined(ENABLE_TLS)
		if (irc->irc_usingssl)
			return SSL_write(irc->irc_ssl, msg, size);
	#endif

	return send(irc->irc_socket, msg, size, 0);
}

int IRCC_connect(IRCC_client *irc, const char *ip, const int port) {
	memset(irc, 0, sizeof(IRCC_client));

	struct hostent *hp = gethostbyname(ip);
	if (!hp)
		return IRCC_ERROR;

	/* Only ipv4 */
	struct sockaddr_in client_str;
	memset(&client_str, 0, sizeof(client_str));
	client_str.sin_family = AF_INET;
	client_str.sin_port = htons(port);
	client_str.sin_addr.s_addr = inet_addr(inet_ntoa(*(struct in_addr *)hp->h_addr));

	irc->irc_socket = socket(AF_INET, SOCK_STREAM, 0);
	if (irc->irc_socket < 0)
		return IRCC_ERROR;

	struct timeval tv = {IRCC_PING_TIMEOUT, 0};
	if (setsockopt(irc->irc_socket, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
		close(irc->irc_socket);
		return IRCC_ERROR;
	}

	int status = connect(irc->irc_socket, (struct sockaddr *)&client_str, sizeof(client_str));
	if (status < 0) {
		close(irc->irc_socket);
		return IRCC_ERROR;
	}

	irc->irc_alloc = 1;
	return IRCC_SUCCESS;
}

void IRCC_parse_msg(char *tmp, IRCC_client *irc) {
	if (tmp != NULL) {
		/* Message */
		char *val = strchr(tmp, ':');
		if (val != NULL) {
			val[0] = '\0';
			irc->irc_msg = val + 1;

			/* Del space before : */
			*(val - 1) = '\0';
		}

		/* Channel */
		val = strchr(tmp, ' ');
		if (val != NULL) {
			val[0] = '\0';
			irc->irc_channel = val + 1;
		}
 
		/* Nickname */
		val = strchr(irc->irc_raw, '!');
		if (val != NULL) {
			val[0] = '\0';
			irc->irc_nick = irc->irc_raw + 1;
		}
	}
}

int IRCC_recv(IRCC_client *irc) {
	if (irc->irc_raw && irc->irc_alloc)
		free(irc->irc_raw);

	irc->irc_raw = NULL;

	size_t size = 0;
	char *buf = malloc(1);
	if (buf == NULL)
		return IRCC_ALLOC;

	/* Read message chunk */
	char flag = 0;
	while (1) {
		size++;
		char *bckp = realloc(buf, size + 1);
		if (bckp == NULL) {
			free(buf);
			return IRCC_ALLOC;
		}
		buf = bckp;

		char *ptr = buf + size - 1;
		int msg_size = IRCC_urecv(irc, &ptr, 1);
		if (msg_size <= 0) {
			free(buf);
			return IRCC_DISCONNECTED;
		}

		*(ptr + 1) = '\0';
		if (flag)
			break;

		if (*ptr == '\r')
			flag = 1;
	}

	irc->irc_raw = buf;
	return IRCC_SUCCESS;
}

int IRCC_parse(IRCC_client *irc) {
	irc->irc_channel = NULL;
	irc->irc_msg = NULL;
	irc->irc_nick = NULL;

	char *ptr;
	if ((ptr = strstr(irc->irc_raw, "PING :")) != NULL) {
		*(strchr(ptr, 'I')) = 'O';
		if (IRCC_usend(irc, ptr, strlen(irc->irc_raw)) == -1)
			return IRCC_ERROR;

		return IRCC_PING;
	}

	/* Check end of motd */
	if (strstr(irc->irc_raw, "PRIVMSG ") == NULL && strstr(irc->irc_raw, "MOTD"))
		return IRCC_CONNECTED;

	else if (strstr(irc->irc_raw, "PRIVMSG ")) {
		IRCC_parse_msg(strstr(irc->irc_raw, "PRIVMSG "), irc);
		return IRCC_PRIVMSG;
	}

	else if (strstr(irc->irc_raw, "NICK ")) {
		IRCC_parse_msg(strstr(irc->irc_raw, "NICK "), irc);
		return IRCC_NICK;
	}

	else if (strstr(irc->irc_raw, "TOPIC ")) {
		IRCC_parse_msg(strstr(irc->irc_raw, "TOPIC "), irc);
		return IRCC_TOPIC;
	}

	else if (strstr(irc->irc_raw, "MODE ")) {
		IRCC_parse_msg(strstr(irc->irc_raw, "MODE "), irc);
		return IRCC_MODE;
	}

	else if (strstr(irc->irc_raw, "JOIN ")) {
		IRCC_parse_msg(strstr(irc->irc_raw, "JOIN "), irc);
		return IRCC_JOIN;
	}

	else if (strstr(irc->irc_raw, "PART ") || strstr(irc->irc_raw, "QUIT ")) {
		IRCC_parse_msg(strstr(irc->irc_raw, "PART "), irc);
		IRCC_parse_msg(strstr(irc->irc_raw, "QUIT "), irc);
		return IRCC_QUIT;
	}

	return IRCC_SUCCESS;
}

int IRCC_register(IRCC_client *irc, const char *nickname) {
	char buf[512];

	int bytes = snprintf(buf, sizeof(buf) - 1, "NICK %s\r\n", nickname);
	if (IRCC_usend(irc, buf, bytes) < 0)
		return IRCC_ERROR;

	bytes = snprintf(buf, sizeof(buf) - 1, "USER %s 0 localhost :%s\r\n", nickname, nickname);
	if (IRCC_usend(irc, buf, bytes) < 0)
		return IRCC_ERROR;

	return IRCC_SUCCESS;
}

int IRCC_join(IRCC_client *irc, const char *channel, const char *key) {
	char buf[512];
	ssize_t bytes = snprintf(buf, sizeof(buf) - 1, "JOIN %s %s\r\n", channel, (key) ? key : "");
	if (IRCC_usend(irc, buf, bytes) < 0)
		return IRCC_ERROR;

	return IRCC_SUCCESS;
}

int IRCC_send(IRCC_client *irc, const char *channel, const char *msg) {
	char buf[512];
	ssize_t bytes = snprintf(buf, sizeof(buf) - 1, "PRIVMSG %s :%s\r\n", channel, msg);
	if (IRCC_usend(irc, buf, bytes) < 0)
		return IRCC_ERROR;

	return IRCC_SUCCESS;

}

int IRCC_initssl(IRCC_client *irc) {
	#if defined(ENABLE_SSL) || defined(ENABLE_TLS)
		irc->irc_ssl = NULL;
		irc->irc_sslctx = NULL;
		irc->irc_sslmethod = NULL;

		OpenSSL_add_all_algorithms();

		if (SSL_library_init() < 0)
			return IRCC_ERROR;

		irc->irc_sslmethod = (SSL_METHOD *)SSLv23_client_method();
		irc->irc_sslctx = SSL_CTX_new(irc->irc_sslmethod);
		if (irc->irc_sslctx == NULL)
			return IRCC_ERROR;

		SSL_CTX_set_options(irc->irc_sslctx, SSL_OP_NO_SSLv2);
		irc->irc_ssl = SSL_new(irc->irc_sslctx);

		SSL_set_fd(irc->irc_ssl, irc->irc_socket);
		if (SSL_connect(irc->irc_ssl) != 1)
			return IRCC_ERROR;

		irc->irc_usingssl = 1;

	#else
		(void)irc;

	#endif

	return IRCC_SUCCESS;
}

void IRCC_close(IRCC_client *irc) {
	if (irc->irc_alloc)
		free(irc->irc_raw);

	if (irc->irc_connected)
		close(irc->irc_socket);

	irc->irc_msg = irc->irc_nick = irc->irc_channel = NULL;

	#if defined(ENABLE_SSL) || defined(ENABLE_TLS)
		if (!irc->irc_usingssl)
			return;

		if (irc->irc_ssl != NULL) {
			SSL_shutdown(irc->irc_ssl);
			SSL_free(irc->irc_ssl);
		}

		if (irc->irc_sslctx != NULL)
			SSL_CTX_free(irc->irc_sslctx);
	#endif
}