thorium1256/libircc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

split IRC.c and moved it to a different repo

Browse Source
This commit is contained in:
thorium1256
2026-05-24 10:07:02 +03:00
commit 7be1ef312e
20 changed files with 1279 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored Normal file
View File

@@ -0,0 +1,3 @@
build
libircc.so
compile_commands.json

29
Makefile Normal file
View File

@@ -0,0 +1,29 @@
CC = clang
CFLAGS = -I./include -fPIC -Wall -Wextra -O2 -fvisibility=hidden
LDFLAGS = -lssl -lcrypto
BUILD_DIR = build
LIBRARY = libircc.so
SRCS = $(shell find $(SRC_DIR) -name '*.c')
OBJS = $(patsubst %.c,$(BUILD_DIR)/%.o,$(SRCS))
.PHONY: libircc
all: $(BUILD_DIR) libircc
$(BUILD_DIR):
mkdir -p $(BUILD_DIR)
libircc: $(LIBRARY)
$(LIBRARY): $(OBJS)
$(CC) -shared -o $@ $^
$(BUILD_DIR)/%.o: %.c
mkdir -p $(dir $@)
$(CC) $(CFLAGS) -c $< -o $@
clean:
rm -f $(OBJS) $(LIBRARY)

9
include/IRC/IRC.h Normal file
View File

@@ -0,0 +1,9 @@
#ifndef IRC_H
#define IRC_H
#include "IRC/IRC_structs.h"
#include "IRC/IRC_events.h"
#include "IRC/IRC_numerics.h"
#include "IRC/IRC_functions.h"
#endif

16
include/IRC/IRC_events.h Normal file
View File

@@ -0,0 +1,16 @@
#ifndef IRC_EVENTS_H
#define IRC_EVENTS_H
typedef enum
{
IRC_EVENT_PRIVMSG,
IRC_EVENT_NOTICE,
IRC_EVENT_JOIN,
IRC_EVENT_PART,
IRC_EVENT_QUIT,
IRC_EVENT_MODESET,
IRC_EVENT_AWAY,
IRC_EVENT_KICK
} irc_event_type_t;
#endif

49
include/IRC/IRC_functions.h Normal file
View File

@@ -0,0 +1,49 @@
#ifndef IRC_FUNCTIONS_H
#define IRC_FUNCTIONS_H
#include "IRC_structs.h"
#include "defines.h"
PUBLIC void IRC_ParseMessage(char* line, irc_message_t *msg);
PUBLIC void IRC_ProcessMessage(irc_message_t *msg, irc_client_t *irc);
// various IRC commands
PUBLIC void IRC_PRIVMSG(char* to, char* msg, irc_client_t *irc);
PUBLIC void IRC_NOTICE(char* to, char* msg, irc_client_t *irc);
PUBLIC void IRC_NICK(char *nick, irc_client_t *irc);
PUBLIC void IRC_USER(char *ident, char* realname, irc_client_t *irc);
PUBLIC void IRC_CTCPSend(char *to, char *cmd, irc_client_t *irc);
// registration
PUBLIC void IRC_SetConnectionParameters(char* host, int port, irc_connection_type_t conntype, irc_client_t *irc);
PUBLIC void IRC_SetIdentityParameters(char* nickname, char* username, char* realname, irc_client_t *irc);
PUBLIC void IRC_Register(irc_client_t *irc);
PUBLIC void IRC_SetSASLParameters(irc_sasl_mechanism_t, char* username, char* password, irc_client_t *irc);
PUBLIC void IRC_RequestSASLAuthentication(irc_client_t *irc);
// Capability negotiation block
PUBLIC void IRC_StartCapabilityNegotiation(irc_client_t *irc);
PUBLIC void IRC_RequestCapabilities(char* caps, irc_client_t *irc);
PUBLIC void IRC_EndCapabilityNegotiation(irc_client_t *irc);
PUBLIC void IRC_NeedCapabilities(char* caps, irc_client_t *irc);
PUBLIC int IRC_ParseCapabilities(char* caps, irc_capability_t *capabilities, int capsLength);
// raw socket things
PUBLIC void IRC_Connect(irc_client_t *irc);
PUBLIC ssize_t IRC_Receive(irc_client_t *irc, char* toBuf, size_t bufSize);
PUBLIC void IRC_Send(irc_client_t *irc, char* toSend);
PUBLIC void IRC_Close(irc_client_t *irc);
// init
PUBLIC int IRC_Init(irc_client_t *irc);
PUBLIC void IRC_Free(irc_client_t *irc);
PUBLIC int IRC_PollEvent(irc_event_t *event, irc_client_t *irc);
void IRC_PushEvent(irc_event_t *event, irc_client_t *irc);
#endif

203
include/IRC/IRC_numerics.h Normal file
View File

@@ -0,0 +1,203 @@
#ifndef IRC_NUMERICS_H
#define IRC_NUMERICS_H
// * 0xx (initial login information)
#define RPL_WELCOME "001"
#define RPL_YOURHOST "002"
#define RPL_CREATED "003"
#define RPL_MYINFO "004"
#define RPL_ISUPPORT "005"
#define RPL_BOUNCE "010" /* deprecated */
// * 2xx (request information)
/* replies to STATS */
#define RPL_STATSCOMMANDS "212"
#define RPL_ENDOFSTATS "219"
#define RPL_STATSUPTIME "242"
/* server user modes on-connect */
#define RPL_UMODEIS "221"
/* replies to LUSERS */
#define RPL_LUSERCLIENT "251"
#define RPL_LUSEROP "252"
#define RPL_LUSERUNKNOWN "253"
#define RPL_LUSERCHANNELS "254"
#define RPL_LUSERME "255"
#define RPL_LOCALUSERS "265"
#define RPL_GLOBALUSERS "266"
/* replies to ADMIN */
#define RPL_ADMINME "256"
#define RPL_ADMINLOC1 "257"
#define RPL_ADMINLOC2 "258"
#define RPL_ADMINEMAIL "259"
/* generic replies (i.e. ratelimiting) */
#define RPL_TRYAGAIN "263"
/* WHOIS info */
#define RPL_WHOISCERTFP "276"
// * 3xx (information for clients)
#define RPL_NONE "300"
/* replies to WHOIS/WHOWAS */
#define RPL_AWAY "301"
#define RPL_WHOISREGNICK "307"
#define RPL_WHOISUSER "311"
#define RPL_WHOISSERVER "312"
#define RPL_WHOISOPERATOR "313"
#define RPL_WHOWASUSER "314"
#define RPL_WHOISIDLE "317"
#define RPL_WHOISCHANNELS "319"
#define RPL_WHOISSPECIAL "320"
#define RPL_WHOISACCOUNT "330"
#define RPL_WHOISACTUALLY "338"
#define RPL_WHOISHOST "378"
#define RPL_WHOISMODES "379"
#define RPL_ENDOFWHOIS "318"
#define RPL_ENDOFWHOWAS "369"
#define ERR_WASNOSUCHNICK "406" /* WHOWAS error */
#define RPL_WHOISSECURE "671"
/* replies to WHO */
#define RPL_WHOREPLY "352"
#define RPL_ENDOFWHO "315"
/* replies to LIST */
#define RPL_LISTSTART "321"
#define RPL_LIST "322"
#define RPL_LISTEND "323"
/* upon joining a channel */
#define RPL_CHANNELMODEIS "324"
#define RPL_CREATIONTIME "329"
#define RPL_TOPIC "332"
#define RPL_TOPICWHOTIME "333"
/* replies to TOPIC */
#define RPL_NOTOPIC "331"
/* replies to INVITE */
#define RPL_INVITELIST "336"
#define RPL_ENDOFINVITELIST "337"
#define RPL_INVITING "341"
/* replies to MODE */
#define RPL_INVEXLIST "346"
#define RPL_ENDOFINVEXLIST "347"
#define RPL_EXCEPTLIST "348"
#define RPL_ENDOFEXCEPTLIST "349"
#define RPL_BANLIST "367"
#define RPL_ENDOFBANLIST "368"
#define ERR_INVALIDMODEPARAM "696"
/* replies to INFO */
#define RPL_INFO "371"
#define RPL_ENDOFINFO "374"
/* when sending a Message of the Day */
#define RPL_MOTDSTART "375"
#define RPL_MOTD "372"
#define RPL_ENDOFMOTD "376"
/* replies to VERSION */
#define RPL_VERSION "351"
/* replies to NAMES */
#define RPL_NAMREPLY "353"
#define RPL_ENDOFNAMES "366"
/* replies to LINKS */
#define RPL_LINKS "364"
#define RPL_ENDOFLINKS "365"
/* replies to OPER */
#define RPL_YOUREOPER "381"
/* replies to REHASH */
#define RPL_REHASHING "382"
/* replies to TIME */
#define RPL_TIME "391"
/* replies to USERHOST */
#define RPL_USERHOST "302"
/* sent to clients to inform of away status */
#define RPL_UNAWAY "305"
#define RPL_NOWAWAY "306"
// * 4xx and 5xx (errors)
#define ERR_UNKNOWNERROR "400"
#define ERR_NOSUCHNICK "401"
#define ERR_NOSUCHSERVER "402"
#define ERR_NOSUCHCHANNEL "403"
#define ERR_CANNOTSENDTOCHAN "404"
#define ERR_TOOMANYCHANNELS "405"
#define ERR_NOORIGIN "409"
#define ERR_NORECIPIENT "411"
#define ERR_NOTEXTTOSEND "412"
#define ERR_INPUTTOOLONG "417"
#define ERR_UNKNOWNCOMMAND "421"
#define ERR_NOMOTD "422"
#define ERR_NONICKNAMEGIVEN "431"
#define ERR_ERRONEUSNICKNAME "432"
#define ERR_NICKNAMEINUSE "433"
#define ERR_NICKCOLLISION "436"
#define ERR_USERNOTINCHANNEL "441"
#define ERR_NOTONCHANNEL "442"
#define ERR_USERONCHANNEL "443"
#define ERR_NOTREGISTERED "451"
#define ERR_NEEDMOREPARAMS "461"
#define ERR_ALREADYREGISTERED "462"
#define ERR_PASSWDMISMATCH "464"
#define ERR_YOUREBANNEDCREEP "465"
#define ERR_CHANNELISFULL "471"
#define ERR_UNKNOWNMODE "472"
#define ERR_INVITEONLYCHAN "473"
#define ERR_BANNEDFROMCHAN "474"
#define ERR_BADCHANNELKEY "475"
#define ERR_BADCHANMASK "476"
#define ERR_NOPRIVILEGES "481"
#define ERR_CHANOPRIVSNEEDED "482"
#define ERR_CANTKILLSERVER "483"
#define ERR_NOOPERHOST "491"
#define ERR_UMODEUNKNOWNFLAG "501"
#define ERR_USERSDONTMATCH "502"
#define ERR_INVALIDKEY "525"
/* replies to HELP */
#define ERR_HELPNOTFOUND "524"
#define RPL_HELPSTART "704"
#define RPL_HELPTXT "705"
#define RPL_ENDOFHELP "706"
// * 6xx (various TLS and IRCv3 stuff)
/* STARTTLS stuff */
#define RPL_STARTTLS "670"
#define ERR_STARTTLS "691"
// * 7xx (various)
#define ERR_NOPRIVS "723"
// * 9xx (authentication)
/* SASL */
#define RPL_LOGGEDIN "900"
#define RPL_LOGGEDOUT "901"
#define RPL_SASLSUCCESS "903"
#define ERR_NICKLOCKED "902"
#define ERR_SASLFAIL "904"
#define ERR_SASLTOOLONG "905"
#define ERR_SASLABORTED "906"
#define ERR_SASLALREADY "907"
#define RPL_SASLMECHS "908"
#endif

123
include/IRC/IRC_structs.h Normal file
View File

@@ -0,0 +1,123 @@
#ifndef IRC_STRUCTS_H
#define IRC_STRUCTS_H
#include "IRC/IRC_events.h"
#include "netcode.h"
#include <stdbool.h>
#include <openssl/ssl.h>
typedef enum
{
SASL_MECHANISM_NONE,
SASL_MECHANISM_PLAIN,
SASL_MECHANISM_EXTERNAL
} irc_sasl_mechanism_t;
typedef struct
{
char nickname[32];
char ident[16];
char hostname;
} irc_hostmask_t;
typedef struct {
char line[513];
char *source;
char *command;
char *argv[16];
int argc;
} irc_message_t;
typedef struct
{
irc_event_type_t type;
irc_message_t orig_msg;
} irc_event_t;
typedef struct
{
irc_hostmask_t hostmask;
char prefix;
} irc_chanuser_t;
typedef struct
{
char name[64];
char topic[513];
irc_chanuser_t* users;
} irc_channel_t;
typedef struct
{
char capLine[96]; // A place for name and args to point to.
char *name;
char *args;
} irc_capability_t;
typedef struct
{
char username[32];
char password[64];
} irc_sasl_plain_credentials_t;
typedef struct
{
char nickname[32];
unsigned char fingerprint[20];
} irc_sasl_external_credentials_t;
typedef struct
{
irc_sasl_mechanism_t mechanism;
union {
irc_sasl_plain_credentials_t plain_credentials;
irc_sasl_external_credentials_t external_credentials;
};
} irc_auth_t;
typedef struct
{
char nick[32];
char altnick[32];
char altnick2[32];
char username[16];
char realname[128];
} irc_identity_t;
typedef enum
{
IRC_CONNECTION_PLAINTEXT,
IRC_CONNECTION_TLS
} irc_connection_type_t;
typedef struct
{
char host[128];
int port;
irc_connection_type_t connType;
} irc_connection_info_t;
typedef struct
{
irc_connection_info_t connectionInfo;
sslSockfd_t connection;
irc_hostmask_t ownHostmask;
char supportedCapabilities[513];
char requestedCapabilities[513];
irc_capability_t acked[16];
/* Authentication parameters */
irc_auth_t saslAuth;
/* Identity */
irc_identity_t identity;
irc_event_t* eventQueue; // lives on the heap
int eventQueuePtr;
} irc_client_t;
typedef struct {
const char *name;
void (*handler)(irc_message_t *msg, irc_client_t *irc);
} command_t;
#endif

9
include/IRC/base64.h Normal file
View File

@@ -0,0 +1,9 @@
#ifndef BASE64_H
#define BASE64_H
#include <stddef.h>
#include <stdint.h>
int base64_encode(const uint8_t *in, size_t in_len, char *out, size_t out_size);
#endif

7
include/IRC/defines.h Normal file
View File

@@ -0,0 +1,7 @@
#ifndef DEFINES_H
#define DEFINES_H
#define NUL '\0'
#define PUBLIC __attribute__((visibility("default")))
#endif

24
include/IRC/netcode.h Normal file
View File

@@ -0,0 +1,24 @@
#ifndef NETCODE_H
#define NETCODE_H
#include <openssl/crypto.h>
typedef struct
{
SSL *ssl;
int sockfd;
SSL_CTX *ctx;
} sslSockfd_t;
// Returns a socket file descriptor.
sslSockfd_t NET_Connect(const char* host, int port);
void NET_Send(sslSockfd_t info, const char* toSend);
void NET_Close(sslSockfd_t info);
// TLS versions of the same thing
sslSockfd_t NET_TLS_Connect(const char* host, int port);
void NET_TLS_Send(sslSockfd_t info, const char* toSend);
void NET_TLS_Close(sslSockfd_t info);
#endif

32
src/base64.c Normal file
View File

@@ -0,0 +1,32 @@
#include "IRC/base64.h"
#include <string.h>
#include <stdint.h>
static const char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
int base64_encode(const uint8_t *in, size_t in_len, char *out, size_t out_size)
{
size_t needed = ((in_len + 2) / 3) * 4 + 1;
if(out_size < needed) return -1;
size_t i = 0, o = 0;
while(i < in_len)
{
uint32_t n = 0;
int remaining = 3;
n |= (i < in_len ? in[i++] : 0) << 16;
n |= (i < in_len ? in[i++] : 0) << 8;
n |= (i < in_len ? in[i++] : 0);
if(i > in_len) remaining = in_len % 3;
out[o++] = b64[(n >> 18) & 63];
out[o++] = b64[(n >> 12) & 63];
out[o++] = remaining > 1 ? b64[(n >> 6) & 63] : '=';
out[o++] = remaining > 2 ? b64[n & 63] : '=';
}
out[o] = 0;
return o;
}

23
src/irc/irc_cap.c Normal file
View File

@@ -0,0 +1,23 @@
#include "IRC/IRC.h"
void IRC_StartCapabilityNegotiation(irc_client_t *irc)
{
IRC_Send(irc, "CAP LS 302\r\n");
}
void IRC_RequestCapabilities(char *caps, irc_client_t *irc)
{
char buf[513];
snprintf(buf, sizeof buf, "CAP REQ :%s\r\n", caps);
IRC_Send(irc, buf);
}
void IRC_NeedCapabilities(char *caps, irc_client_t *irc)
{
snprintf(irc->requestedCapabilities, sizeof irc->requestedCapabilities, "%s", caps);
}
void IRC_EndCapabilityNegotiation(irc_client_t *irc)
{
IRC_Send(irc, "CAP END\r\n");
}

48
src/irc/irc_commands.c Normal file
View File

@@ -0,0 +1,48 @@
#include "IRC/IRC.h"
#include <stdio.h>
void IRC_PRIVMSG(char *to, char *msg, irc_client_t *irc)
{
char buf[513];
snprintf(buf, sizeof buf, "PRIVMSG %s :%s\r\n", to, msg);
IRC_Send(irc, buf);
}
void IRC_NOTICE(char *to, char *msg, irc_client_t *irc)
{
char buf[513];
snprintf(buf, sizeof buf, "NOTICE %s :%s\r\n", to, msg);
IRC_Send(irc, buf);
}
void IRC_NICK(char *newNick, irc_client_t *irc)
{
char buf[513];
snprintf(buf, sizeof buf, "NICK %s\r\n", newNick);
IRC_Send(irc, buf);
}
void IRC_USER(char *ident, char *realname, irc_client_t *irc)
{
char buf[513];
snprintf(buf, sizeof buf, "USER %s 0 * :%s\r\n", ident, realname);
IRC_Send(irc, buf);
}
void IRC_Register(irc_client_t *irc)
{
if(irc->saslAuth.mechanism != SASL_MECHANISM_NONE)
{
IRC_NeedCapabilities("sasl", irc);
IRC_StartCapabilityNegotiation(irc);
}
IRC_NICK(irc->identity.nick, irc);
IRC_USER(irc->identity.username, irc->identity.realname, irc);
}
void IRC_CTCPSend(char *to, char *cmd, irc_client_t *irc)
{
char buf[513];
snprintf(buf, sizeof buf, "\x01%s\x01", cmd);
IRC_PRIVMSG(to, buf, irc);
}

22
src/irc/irc_events.c Normal file
View File

@@ -0,0 +1,22 @@
#include "IRC/IRC.h"
#define MAX_EVENT_QUEUE_SIZE 12
void IRC_PushEvent(irc_event_t *event, irc_client_t *irc)
{
// push the event to the queue
if(irc->eventQueuePtr >= MAX_EVENT_QUEUE_SIZE - 1) return;
irc->eventQueue[++irc->eventQueuePtr] = *event;
}
int IRC_PollEvent(irc_event_t *event, irc_client_t *irc)
{
// pop events from the queue
if(irc->eventQueuePtr < 0)
{
return 0;
}
*event = irc->eventQueue[irc->eventQueuePtr--];
return 1;
}

21
src/irc/irc_init.c Normal file
View File

@@ -0,0 +1,21 @@
#include "IRC/IRC.h"
#include <stdlib.h>
#define MAX_EVENT_QUEUE_SIZE 12
int IRC_Init(irc_client_t *irc)
{
// allocate the event queue space
irc->eventQueue = (irc_event_t*)malloc(sizeof(irc_event_t) * MAX_EVENT_QUEUE_SIZE);
if(irc->eventQueue == NULL)
{
return -1;
}
irc->eventQueuePtr = -1;
return 0;
}
void IRC_Free(irc_client_t *irc)
{
free(irc->eventQueue);
}

81
src/irc/irc_networking.c Normal file
View File

@@ -0,0 +1,81 @@
#include "IRC/IRC.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <openssl/ssl.h>
void IRC_Connect(irc_client_t *irc)
{
switch(irc->connectionInfo.connType)
{
case IRC_CONNECTION_PLAINTEXT:
irc->connection = NET_Connect(irc->connectionInfo.host, irc->connectionInfo.port);
break;
case IRC_CONNECTION_TLS:
irc->connection = NET_TLS_Connect(irc->connectionInfo.host, irc->connectionInfo.port);
break;
}
if (irc->connection.sockfd < 0) {
fprintf(stderr, "Connection failed\n");
exit(1);
}
}
ssize_t IRC_Receive(irc_client_t *irc, char *toBuf, size_t bufSize)
{
switch(irc->connectionInfo.connType)
{
case IRC_CONNECTION_PLAINTEXT:
{
return recv(irc->connection.sockfd, toBuf, bufSize, 0);
break;
}
case IRC_CONNECTION_TLS:
{
ssize_t n = SSL_read(irc->connection.ssl, toBuf, bufSize);
if (n <= 0) {
int err = SSL_get_error(irc->connection.ssl, n);
if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) {
return -2;
}
return -1;
}
return n;
}
}
return -1;
}
void IRC_Send(irc_client_t *irc, char *toSend)
{
switch(irc->connectionInfo.connType)
{
case IRC_CONNECTION_PLAINTEXT:
NET_Send(irc->connection, toSend);
break;
case IRC_CONNECTION_TLS:
NET_TLS_Send(irc->connection, toSend);
break;
}
}
void IRC_Close(irc_client_t *irc)
{
switch(irc->connectionInfo.connType)
{
case IRC_CONNECTION_PLAINTEXT:
NET_Close(irc->connection);
break;
case IRC_CONNECTION_TLS:
NET_TLS_Close(irc->connection);
break;
}
}

135
src/irc/irc_parser.c Normal file
View File

@@ -0,0 +1,135 @@
#include "IRC/IRC.h"
#include "IRC/defines.h"
#include <stddef.h>
// TODO: add IRCv3 tag support
void IRC_ParseMessage(char *line, irc_message_t *msg)
{
strncpy(msg->line, line, sizeof(msg->line) - 1);
char *ptr = msg->line;
ptr[sizeof(msg->line)] = NUL;
char *source = NULL;
char *command = NULL;
// get the source, if it exists (the : at the beginning of an IRC message)
if(*ptr == ':')
{
ptr++;
source = ptr;
while (*ptr && *ptr != ' ') ptr++;
if (*ptr) *ptr++ = NUL;
while (*ptr == ' ') ptr++; // skip any extra spaces
}
msg->source = source;
// read the command
command = ptr;
while(*ptr && *ptr != ' ') ptr++;
if (*ptr) *ptr++ = NUL;
msg->command = command;
while (*ptr == ' ') ptr++;
// read its arguments (until we encounter a colon/nullbyte)
msg->argc = 0;
while(*ptr && msg->argc <= 15)
{
if(*ptr == ':') // if it's a trailing arg
{
ptr++;
msg->argv[msg->argc] = ptr;
msg->argc++;
break;
}
msg->argv[msg->argc] = ptr;
while(*ptr && *ptr != ' ') ptr++;
if (*ptr)
{
*ptr++ = NUL;
while (*ptr == ' ') ptr++; // skip spaces for next arg
}
msg->argc++;
}
if (msg->argc > 0) {
char *last = msg->argv[msg->argc - 1];
size_t len = strlen(last);
while (len > 0 && (last[len-1] == '\r' || last[len-1] == '\n')) {
last[len-1] = '\0';
len--;
}
}
}
// Returns the number of capabilities found.
int IRC_ParseCapabilities(char *caps, irc_capability_t *capabilities, int capsLength)
{
while (*caps == ' ') caps++;
size_t len = strlen(caps);
while (len > 0 && (caps[len-1] == '\n' || caps[len-1] == '\r' || caps[len-1] == ' ')) {
caps[len-1] = '\0';
len--;
}
char capBak[513];
strncpy(capBak, caps, sizeof(capBak) - 1); // copy the capline so we don't destroy our parameter
capBak[sizeof(capBak) - 1] = 0;
char *ptr = capBak;
char *tmp = ptr;
int argc = 0;
while(*ptr && argc < capsLength)
{
while(*ptr == ' ') ptr++; // skip any spaces before a capability
if(!*ptr) break;
tmp = ptr;
while(*tmp && *tmp != ' ') tmp++;
*tmp++ = 0;
// copy the cap line while it's untampered with
strncpy(capabilities[argc].capLine, ptr, sizeof(capabilities[argc].capLine) - 1);
capabilities[argc].capLine[sizeof(capabilities[argc].capLine) - 1] = 0;
// ptr now points to the start of the next cap
ptr = tmp;
// set the name pointer there
char* walker = capabilities[argc].capLine;
capabilities[argc].name = walker;
while(*walker && *walker != '=') walker++;
if(*walker == '=')
{
*walker++ = 0;
// we don't need to move walker since it will be reinitialized in the next `while` iteration, and capLine already ends with a nullbyte
capabilities[argc].args = walker;
argc++;
}
else if (*walker == 0)
{
// the cap has no args
capabilities[argc].args = NULL;
argc++;
}
}
return argc;
}

139
src/irc/irc_processing.c Normal file
View File

@@ -0,0 +1,139 @@
#include "IRC/IRC_numerics.h"
#include "IRC/IRC_structs.h"
#include "IRC/defines.h"
#include "IRC/netcode.h"
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include "IRC/IRC.h"
#include "IRC/base64.h"
static void handlePing(irc_message_t *msg, irc_client_t *irc)
{
char buf[128]; // most pingpongs are usually short, with the servername being short too
snprintf(buf, sizeof buf, "PONG :%s\r\n", msg->argv[0]);
IRC_Send(irc, buf);
}
static void handleCapabilities(irc_message_t *msg, irc_client_t *irc)
{
// we are willing to tolerate some spaghetti...
if(strcmp(msg->argv[1], "LS") == 0)
{
snprintf(irc->supportedCapabilities, sizeof irc->supportedCapabilities, "%s", msg->argv[2]);
// parse the caps
irc_capability_t caps[24];
int capCount = IRC_ParseCapabilities(irc->supportedCapabilities, caps, sizeof(caps) / sizeof(irc_capability_t));
irc_capability_t reqCaps[24];
int reqCapCount = IRC_ParseCapabilities(irc->requestedCapabilities, reqCaps, sizeof(reqCaps) / sizeof(irc_capability_t));
char buf[513];
int bytesWritten = 0;
for(int i = 0; i < capCount; i++)
{
for(int j = 0; j < reqCapCount; j++)
{
if(strcmp(caps[i].name, reqCaps[j].name) == 0)
{
bytesWritten += snprintf(buf + bytesWritten, sizeof(buf) - bytesWritten, "%s ", reqCaps[j].name);
}
}
}
IRC_RequestCapabilities(buf, irc);
}
else if (strcmp(msg->argv[1], "ACK") == 0)
{
int ackedCount = IRC_ParseCapabilities(msg->argv[2], irc->acked, sizeof(irc->acked) / sizeof(irc_capability_t));
for(int i = 0; i < ackedCount; i++)
{
if(strcmp(irc->acked[i].name, "sasl") == 0)
{
IRC_RequestSASLAuthentication(irc);
}
}
}
// NAK is a no-op anyway, if it isn't in our irc->acked we just won't use it then.
}
static void handleAuthentication(irc_message_t *msg, irc_client_t *irc)
{
if(strcmp(msg->argv[0], "+") == 0)
{
// send our base64 sasl username and password
switch(irc->saslAuth.mechanism)
{
case SASL_MECHANISM_NONE:
break;
case SASL_MECHANISM_PLAIN:
{
const char *user = irc->saslAuth.plain_credentials.username;
const char *pass = irc->saslAuth.plain_credentials.password;
size_t user_len = strlen(user);
size_t pass_len = strlen(pass);
uint8_t sasl_data[user_len + pass_len + 3];
size_t idx = 0;
sasl_data[idx++] = 0;
memcpy(sasl_data + idx, user, user_len);
idx += user_len;
sasl_data[idx++] = 0;
memcpy(sasl_data + idx, pass, pass_len);
idx += pass_len;
char base64Out[513];
base64_encode(sasl_data, idx, base64Out, sizeof(base64Out));
char buf[513];
snprintf(buf, sizeof buf, "AUTHENTICATE %s\r\n", base64Out);
IRC_Send(irc, buf);
break;
}
case SASL_MECHANISM_EXTERNAL:
{
IRC_Send(irc, "AUTHENTICATE +\r\n");
break;
}
}
}
}
static void handleSaslSuccess(irc_message_t *msg, irc_client_t *irc)
{
// silence msg warning
(void)msg;
IRC_EndCapabilityNegotiation(irc);
}
/*
IRC_ProcessMessage is only used for commands that have no need to be a user-listenable event.
For pollable events, use IRC_PollEvent(&event).
*/
void IRC_ProcessMessage(irc_message_t *msg, irc_client_t *irc)
{
command_t commands[] =
{
{"PING", handlePing},
{"CAP", handleCapabilities},
{"AUTHENTICATE", handleAuthentication},
{RPL_SASLSUCCESS, handleSaslSuccess},
{NULL, NULL}
};
for(int i = 0; commands[i].name; i++)
{
if(strcmp(msg->command, commands[i].name) == 0)
{
commands[i].handler(msg, irc);
}
}
}

48
src/irc/irc_userparams.c Normal file
View File

@@ -0,0 +1,48 @@
#include "IRC/IRC.h"
void IRC_SetSASLParameters(irc_sasl_mechanism_t mechanism, char *username, char *password, irc_client_t *irc)
{
switch(mechanism)
{
case SASL_MECHANISM_NONE:
break;
case SASL_MECHANISM_EXTERNAL:
// unimplemented
break;
case SASL_MECHANISM_PLAIN:
irc->saslAuth.mechanism = mechanism;
strncpy(irc->saslAuth.plain_credentials.username, username, sizeof(irc->saslAuth.plain_credentials.username) - 1);
strncpy(irc->saslAuth.plain_credentials.password, password, sizeof(irc->saslAuth.plain_credentials.password) - 1);
}
}
void IRC_RequestSASLAuthentication(irc_client_t *irc)
{
switch(irc->saslAuth.mechanism)
{
case SASL_MECHANISM_NONE:
// why?
break;
case SASL_MECHANISM_PLAIN:
IRC_Send(irc, "AUTHENTICATE PLAIN\r\n");
break;
case SASL_MECHANISM_EXTERNAL:
IRC_Send(irc, "AUTHENTICATE EXTERNAL\r\n");
break;
}
}
void IRC_SetConnectionParameters(char *host, int port, irc_connection_type_t conntype, irc_client_t *irc)
{
snprintf(irc->connectionInfo.host, sizeof irc->connectionInfo.host, "%s", host);
irc->connectionInfo.port = port;
irc->connectionInfo.connType = conntype;
}
void IRC_SetIdentityParameters(char *nickname, char *username, char *realname, irc_client_t *irc)
{
snprintf(irc->identity.nick, sizeof irc->identity.nick, "%s", nickname);
snprintf(irc->identity.username, sizeof irc->identity.username, "%s", username);
snprintf(irc->identity.realname, sizeof irc->identity.realname, "%s", realname);
}

258
src/netcode.c Normal file
View File

@@ -0,0 +1,258 @@
#include "IRC/netcode.h"
#include <openssl/crypto.h>
#include <openssl/err.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <openssl/ssl.h>
#include <fcntl.h>
sslSockfd_t NET_Connect(const char *host, int port)
{
sslSockfd_t sock = {NULL, -1, NULL};
int status;
struct addrinfo hints, *res;
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
// save us from user or programmer stupidity
if(!host)
{
return sock;
}
char portNumber[6];
snprintf(portNumber, 6, "%d", port);
// DEFRAWT();
// PRINT_INFO(timeinfo);
printf("Looking up %s...\n", host);
if ((status = getaddrinfo(host, portNumber, &hints, &res)) == -1)
{
// PRINT_INFO(timeinfo);
fprintf(stderr, "Unable to lookup %s: %s\n", host, gai_strerror(status));
return sock;
}
char ipstr[INET6_ADDRSTRLEN];
for(struct addrinfo *p = res; p != NULL; p = p->ai_next)
{
void *addr;
struct sockaddr_in *ipv4;
struct sockaddr_in6 *ipv6;
if(p->ai_family == AF_INET)
{
ipv4 = (struct sockaddr_in *)p->ai_addr;
addr = &(ipv4->sin_addr);
}
else
{
ipv6 = (struct sockaddr_in6 *)p->ai_addr;
addr = &(ipv6->sin6_addr);
}
inet_ntop(p->ai_family, addr, ipstr, sizeof ipstr);
// REDEFRAWT();
// PRINT_INFO(timeinfo);
printf("Connecting to %s:%d (%s:%d)...\n", host, port, ipstr, port);
if((sock.sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1)
{
char perrorMsg[sizeof("Failed to connect to ") + sizeof ipstr];
snprintf(perrorMsg, sizeof perrorMsg, "Failed to connect to %s", ipstr);
perror(perrorMsg);
continue;
}
if((connect(sock.sockfd, p->ai_addr, p->ai_addrlen)) == -1)
{
close(sock.sockfd);
char perrorMsg[sizeof("Failed to connect to ") + sizeof ipstr];
snprintf(perrorMsg, sizeof perrorMsg, "Failed to connect to %s", ipstr);
perror(perrorMsg);
continue;
}
// REDEFRAWT();
// PRINT_INFO(timeinfo);
printf("Connected!\n");
break;
}
return sock;
}
void NET_Send(sslSockfd_t info, const char *toSend)
{
size_t bytesSent = 0;
size_t sendLen = strlen(toSend);
// printf("> %s", toSend);
while(bytesSent < sendLen)
{
ssize_t sent = send(info.sockfd, toSend, sendLen - bytesSent, 0);
if(sent == -1)
{
perror("NET_Send");
return;
}
if(sent == 0)
{
fprintf(stderr, "NET_Send: connection closed\n");
return;
}
bytesSent += sent;
}
}
void NET_Close(sslSockfd_t info)
{
if(info.sockfd >= 0)
{
shutdown(info.sockfd, SHUT_RDWR);
close(info.sockfd);
}
}
sslSockfd_t NET_TLS_Connect(const char *host, int port)
{
sslSockfd_t result;
result = NET_Connect(host, port);
if(result.sockfd < 0) return result;
int flags = fcntl(result.sockfd, F_GETFL, 0);
fcntl(result.sockfd, F_SETFL, flags | O_NONBLOCK);
// const char *const CIPHER_LIST =
// "ECDHE-ECDSA-AES128-GCM-SHA256:"
// "ECDHE-RSA-AES128-GCM-SHA256:"
// "ECDHE-ECDSA-AES256-GCM-SHA384:"
// "ECDHE-RSA-AES256-GCM-SHA384:"
// "ECDHE-ECDSA-CHACHA20-POLY1305:"
// "ECDHE-RSA-CHACHA20-POLY1305:"
// "DHE-RSA-AES128-GCM-SHA256:"
// "DHE-RSA-AES256-GCM-SHA384:"
// "DHE-RSA-CHACHA20-POLY1305";
// if (SSL_CTX_set_cipher_list(result.ctx, CIPHER_LIST) != 1) {
// fprintf(stderr, "Failed to set cipher list\n");
// exit(1);
// }
result.ctx = SSL_CTX_new(TLS_client_method());
if (!result.ctx) return result;
// SSL_CTX_set_verify(result.ctx, SSL_VERIFY_NONE, NULL);
// SSL_CTX_set_min_proto_version(result.ctx, TLS1_2_VERSION);
// SSL_CTX_set_max_proto_version(result.ctx, TLS1_2_VERSION);
// SSL_CTX_set_options(result.ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_COMPRESSION);
// SSL_CTX_set_mode(result.ctx, SSL_MODE_AUTO_RETRY);
result.ssl = SSL_new(result.ctx);
if(!result.ssl)
{
SSL_CTX_free(result.ctx);
return result;
}
// SSL_set_tlsext_host_name(result.ssl, host);
SSL_set_fd(result.ssl, result.sockfd);
SSL_set_connect_state(result.ssl);
int ret;
while((ret = SSL_connect(result.ssl)) != 1)
{
int err = SSL_get_error(result.ssl, ret);
if(err == SSL_ERROR_WANT_READ)
{
fd_set fds;
FD_ZERO(&fds);
FD_SET(result.sockfd, &fds);
select(result.sockfd + 1, &fds, NULL, NULL, NULL);
continue;
}
else if (err == SSL_ERROR_WANT_WRITE)
{
fd_set fds;
FD_ZERO(&fds);
FD_SET(result.sockfd, &fds);
select(result.sockfd + 1, NULL, &fds, NULL, NULL);
continue;
}
else
{
SSL_free(result.ssl);
SSL_CTX_free(result.ctx);
result.ssl = NULL;
result.ctx = NULL;
result.sockfd = -1;
return result;
}
}
return result;
}
void NET_TLS_Send(sslSockfd_t info, const char* toSend)
{
size_t bytesSent = 0;
size_t sendLen = strlen(toSend);
printf("> %s", toSend);
while(bytesSent < sendLen)
{
ssize_t sent = SSL_write(info.ssl, toSend + bytesSent, sendLen - bytesSent);
if(sent <= 0)
{
int err = SSL_get_error(info.ssl, sent);
if (err == SSL_ERROR_WANT_WRITE) {
usleep(1000);
continue;
} else if (err == SSL_ERROR_WANT_READ) {
usleep(1000);
continue;
} else {
unsigned long errcode = ERR_get_error();
char errbuf[256];
ERR_error_string_n(errcode, errbuf, sizeof(errbuf));
fprintf(stderr, "NET_TLS_Send: SSL_write error: %s\n", errbuf);
return;
}
}
bytesSent += sent;
}
}
void NET_TLS_Close(sslSockfd_t info)
{
if (info.ssl) {
SSL_shutdown(info.ssl);
SSL_free(info.ssl);
SSL_CTX_free(info.ctx);
}
if (info.sockfd >= 0) {
close(info.sockfd);
}
}