cbec2d0660
git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@6024 fc73d0e0-1445-4013-8a0c-d673dee63da5
2821 lines
74 KiB
C
2821 lines
74 KiB
C
//Released under the terms of the gpl as this file uses a bit of quake derived code. All sections of the like are marked as such
|
|
// changes name to while in channel
|
|
// mode command
|
|
// Spike can you implement nick tab completion. ~moodles
|
|
// need option for whois on receiving PM
|
|
// bug: setting channel to private, crashes fte when trying to join it.
|
|
// http://www.mirc.net/raws/
|
|
// http://www.ircle.com/reference/commands.shtml
|
|
|
|
|
|
#include "../plugin.h"
|
|
static plugsubconsolefuncs_t *confuncs;
|
|
static plugfsfuncs_t *filefuncs;
|
|
static plugnetfuncs_t *netfuncs;
|
|
static plug2dfuncs_t *drawfuncs;
|
|
#include <time.h>
|
|
#include <ctype.h>
|
|
#include "../../engine/common/netinc.h"
|
|
|
|
#define handleisvalid(h) ((h)>=0)
|
|
#define invalid_handle -1
|
|
|
|
enum tlsmode_e
|
|
{
|
|
TLS_OFF,
|
|
TLS_INITIAL, //tls only
|
|
TLS_START, //tls upgrade
|
|
|
|
TLS_STARTING //don't send any nick/user/pass info while this is set
|
|
};
|
|
|
|
#define irccvars "IRC Console Variables"
|
|
static vmcvar_t irc_debug = {"irc_debug", "0", irccvars, 0};
|
|
static vmcvar_t irc_motd = {"irc_motd", "0", irccvars, 0};
|
|
static vmcvar_t irc_nick = {"irc_nick", "", irccvars, 0};
|
|
static vmcvar_t irc_altnick = {"irc_altnick", "", irccvars, 0};
|
|
static vmcvar_t irc_realname = {"irc_realname", "FTE IRC-Plugin", irccvars, 0};
|
|
static vmcvar_t irc_hostname = {"irc_hostname", "localhost", irccvars, 0};
|
|
static vmcvar_t irc_username = {"irc_username", "FTE", irccvars, 0};
|
|
static vmcvar_t irc_timestamp = {"irc_timestamp", "0", irccvars, 0};
|
|
static vmcvar_t irc_quitmessage = {"irc_quitmessage", "", irccvars, 0};
|
|
static vmcvar_t irc_config = {"irc_config", "1", irccvars, 0};
|
|
#undef irccvars
|
|
|
|
static vmcvar_t *cvarlist[] ={
|
|
&irc_debug,
|
|
&irc_motd,
|
|
&irc_nick,
|
|
&irc_altnick,
|
|
&irc_realname,
|
|
&irc_hostname,
|
|
&irc_username,
|
|
&irc_timestamp,
|
|
&irc_quitmessage,
|
|
NULL
|
|
};
|
|
|
|
static icefuncs_t *piceapi;
|
|
static int next_window_x;
|
|
static int next_window_y;
|
|
static qboolean reloadconfig;
|
|
//static char commandname[64]; // belongs to magic tokenizer
|
|
static char subvar[9][1000]; // etghack
|
|
static char casevar[9][1000]; //numbered_command
|
|
//static char servername[64]; // store server name
|
|
#define CURRENTCONSOLE "" // need to make this the current console
|
|
#define DEFAULTCONSOLE ""
|
|
#define COMMANDNAME "irc"
|
|
|
|
#if defined(SVNREVISION)
|
|
#define RELEASE STRINGIFY(SVNREVISION)
|
|
#else
|
|
#define RELEASE __DATE__
|
|
#endif
|
|
|
|
static struct
|
|
{
|
|
int width;
|
|
int height;
|
|
} pvid;
|
|
static void QDECL IRC_UpdateVideo(int width, int height)
|
|
{
|
|
pvid.width = width;
|
|
pvid.height = height;
|
|
}
|
|
|
|
static qboolean (*Con_TrySubPrint)(const char *subname, const char *text);
|
|
static qboolean Con_FakeSubPrint(const char *subname, const char *text)
|
|
{
|
|
plugfuncs->Print(text);
|
|
return true;
|
|
}
|
|
|
|
//porting zone:
|
|
|
|
|
|
#define COLOURGREEN "^2"
|
|
#define COLORWHITE "^7"
|
|
#define COLOURWHITE "^7" // word
|
|
#define COLOURRED "^1"
|
|
#define COLOURYELLOW "^3"
|
|
#define COLOURPURPLE "^5"
|
|
#define COLOURBLUE "^4"
|
|
#define COLOURINDIGO "^6"
|
|
|
|
|
|
#define IRC_Malloc malloc
|
|
#define IRC_Free free
|
|
#undef COM_Parse
|
|
static char *COM_Parse (char *data, char *token_out, int token_maxlen) //this is taken out of quake
|
|
{
|
|
int c;
|
|
int len;
|
|
|
|
len = 0;
|
|
token_out[0] = 0;
|
|
|
|
if (!data)
|
|
return NULL;
|
|
|
|
// skip whitespace
|
|
skipwhite:
|
|
while ( (c = *data) <= ' ')
|
|
{
|
|
if (c == 0)
|
|
return NULL; // end of file;
|
|
data++;
|
|
}
|
|
|
|
// skip // comments
|
|
if (c=='/')
|
|
{
|
|
if (data[1] == '/')
|
|
{
|
|
while (*data && *data != '\n')
|
|
data++;
|
|
goto skipwhite;
|
|
}
|
|
}
|
|
|
|
|
|
// handle quoted strings specially
|
|
if (c == '\"')
|
|
{
|
|
data++;
|
|
while (1)
|
|
{
|
|
if (len >= token_maxlen-1)
|
|
return data;
|
|
|
|
c = *data++;
|
|
if (c=='\"' || !c)
|
|
{
|
|
token_out[len] = 0;
|
|
return data;
|
|
}
|
|
token_out[len] = c;
|
|
len++;
|
|
}
|
|
}
|
|
|
|
// parse a regular word
|
|
do
|
|
{
|
|
if (len >= token_maxlen-1)
|
|
return data;
|
|
|
|
token_out[len] = c;
|
|
data++;
|
|
len++;
|
|
c = *data;
|
|
} while (c>32);
|
|
|
|
token_out[len] = 0;
|
|
return data;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//\r\n is used to end a line.
|
|
//meaning \0s are valid.
|
|
//but never used cos it breaks strings
|
|
|
|
|
|
|
|
#define IRC_MAXNICKLEN 32 //9 and a null term
|
|
#define IRC_MAXMSGLEN 512
|
|
#define IRC_MAXOUTBUFFER (IRC_MAXMSGLEN*16)
|
|
|
|
|
|
typedef struct ircclient_s {
|
|
struct ircclient_s *next;
|
|
|
|
char id[64]; //used for console prints, so we can match up consoles and clients.
|
|
|
|
char server[64];
|
|
int port;
|
|
|
|
qhandle_t socket;
|
|
|
|
enum tlsmode_e tlsmode;
|
|
qboolean quitting;
|
|
qboolean connecting;
|
|
char nick[IRC_MAXNICKLEN]; //nick that we're actually using
|
|
size_t nicktries; //so we can cycle nicks till we get one that works.
|
|
|
|
qboolean persist; //server connection is persistent across restarts
|
|
char primarynick[IRC_MAXNICKLEN]; //primary nick the connection was configured with
|
|
char pwd[128]; //server password
|
|
char realname[128]; //this is your descriptive OS user account... supposedly.
|
|
char username[128]; //this is your unique OS user name... supposedly.
|
|
char hostname[128]; //this is your OS hostname... supposedly.
|
|
char autochannels[256]; //"#chan,pwd #foo,bar #fred #splodge" for four channnels, two with a password
|
|
|
|
char defaultdest[IRC_MAXNICKLEN];//channel or nick
|
|
|
|
char bufferedinmessage[IRC_MAXMSGLEN+1]; //there is a max size for protocol. (conveinient eh?) (and it's text format)
|
|
int bufferedinammount;
|
|
|
|
|
|
char bufferedoutmessage[IRC_MAXOUTBUFFER+1]; //there is a max size for protocol. (conveinient eh?) (and it's text format)
|
|
int bufferedoutammount;
|
|
|
|
struct ircice_s
|
|
{
|
|
struct ircice_s *next;
|
|
|
|
enum iceproto_e type;
|
|
char peer[IRC_MAXNICKLEN];
|
|
qboolean host; //the host is the person that initiated the call/etc. they're the ones responsible for resolving deadlocks.
|
|
qboolean allowed; //user allowed it. woot.
|
|
qboolean accepted; //peer accepted it. connection is active.
|
|
|
|
struct icestate_s *ice;
|
|
} *ice;
|
|
} ircclient_t;
|
|
static ircclient_t *ircclients;
|
|
|
|
|
|
static void IRC_SetFooter(ircclient_t *irc, const char *subname, const char *format, ...)
|
|
{
|
|
va_list argptr;
|
|
static char string[1024];
|
|
char lwr[128];
|
|
int i;
|
|
const char *channame = subname;
|
|
|
|
va_start (argptr, format);
|
|
Q_vsnprintf (string, sizeof(string), format,argptr);
|
|
va_end (argptr);
|
|
|
|
if (irc)
|
|
{
|
|
Q_strlcpy(lwr, irc->id, sizeof(lwr));
|
|
for (i = strlen(lwr); *subname && i < sizeof(lwr)-2; i++, subname++)
|
|
{
|
|
if (*subname >= 'A' && *subname <= 'Z')
|
|
lwr[i] = *subname - 'A' + 'a';
|
|
else
|
|
lwr[i] = *subname;
|
|
}
|
|
|
|
lwr[i] = '\0';
|
|
|
|
if (confuncs && confuncs->GetConsoleFloat(lwr, "iswindow") < true)
|
|
{
|
|
confuncs->SetConsoleString(lwr, "title", *channame?channame:irc->server);
|
|
confuncs->SetConsoleString(lwr, "prompt", va("[^1%s^7]: ", irc->nick));
|
|
confuncs->SetConsoleFloat(lwr, "iswindow", 2);
|
|
confuncs->SetConsoleFloat(lwr, "forceutf8", true);
|
|
confuncs->SetConsoleFloat(lwr, "wnd_w", 256);
|
|
confuncs->SetConsoleFloat(lwr, "wnd_h", 320);
|
|
|
|
//lame, but whatever.
|
|
if (next_window_x + 256 > pvid.width)
|
|
{
|
|
next_window_x = 0;
|
|
next_window_y += 320;
|
|
if (next_window_y + 320 > pvid.height)
|
|
next_window_y = 0;
|
|
}
|
|
confuncs->SetConsoleFloat(lwr, "wnd_x", next_window_x);
|
|
confuncs->SetConsoleFloat(lwr, "wnd_y", next_window_y);
|
|
next_window_x += 256;
|
|
}
|
|
|
|
if (confuncs)
|
|
confuncs->SetConsoleString(lwr, "footer", string);
|
|
}
|
|
}
|
|
static qboolean IRC_WindowShown(ircclient_t *irc, const char *subname)
|
|
{
|
|
char lwr[128];
|
|
int i;
|
|
if (irc)
|
|
{
|
|
Q_strlcpy(lwr, irc->id, sizeof(lwr));
|
|
for (i = strlen(lwr); *subname && i < sizeof(lwr)-2; i++, subname++)
|
|
{
|
|
if (*subname >= 'A' && *subname <= 'Z')
|
|
lwr[i] = *subname - 'A' + 'a';
|
|
else
|
|
lwr[i] = *subname;
|
|
}
|
|
|
|
lwr[i] = '\0';
|
|
|
|
if (confuncs && confuncs->GetConsoleFloat(lwr, "iswindow") < true)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
static void IRC_Printf(ircclient_t *irc, const char *subname, const char *format, ...) LIKEPRINTF(3);
|
|
static void IRC_Printf(ircclient_t *irc, const char *subname, const char *format, ...)
|
|
{
|
|
va_list argptr;
|
|
static char string[1024];
|
|
char lwr[128];
|
|
int i;
|
|
const char *channame = subname;
|
|
|
|
va_start (argptr, format);
|
|
Q_vsnprintf (string, sizeof(string), format,argptr);
|
|
va_end (argptr);
|
|
|
|
if (!irc)
|
|
plugfuncs->Print(string);
|
|
else
|
|
{
|
|
Q_strlcpy(lwr, irc->id, sizeof(lwr));
|
|
for (i = strlen(lwr); *subname && i < sizeof(lwr)-2; i++, subname++)
|
|
{
|
|
if (*subname >= 'A' && *subname <= 'Z')
|
|
lwr[i] = *subname - 'A' + 'a';
|
|
else
|
|
lwr[i] = *subname;
|
|
}
|
|
|
|
lwr[i] = '\0';
|
|
|
|
if (confuncs && confuncs->GetConsoleFloat(lwr, "iswindow") < true)
|
|
{
|
|
confuncs->SetConsoleString(lwr, "title", *channame?channame:irc->server);
|
|
confuncs->SetConsoleString(lwr, "prompt", va("[^1%s^7]: ", irc->nick));
|
|
confuncs->SetConsoleFloat(lwr, "iswindow", 2);
|
|
confuncs->SetConsoleFloat(lwr, "forceutf8", true);
|
|
confuncs->SetConsoleFloat(lwr, "wnd_w", 256);
|
|
confuncs->SetConsoleFloat(lwr, "wnd_h", 320);
|
|
|
|
//lame, but whatever.
|
|
if (next_window_x + 256 > pvid.width)
|
|
{
|
|
next_window_x = 0;
|
|
next_window_y += 320;
|
|
if (next_window_y + 320 > pvid.height)
|
|
next_window_y = 0;
|
|
}
|
|
confuncs->SetConsoleFloat(lwr, "wnd_x", next_window_x);
|
|
confuncs->SetConsoleFloat(lwr, "wnd_y", next_window_y);
|
|
next_window_x += 256;
|
|
}
|
|
if (!*string)
|
|
confuncs->SetActive(lwr);
|
|
|
|
Con_TrySubPrint(lwr, string);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
static void IRC_InitCvars(void)
|
|
{
|
|
vmcvar_t *v;
|
|
int i;
|
|
for (i=0; cvarlist[i]; i++)
|
|
{
|
|
v = cvarlist[i];
|
|
v->handle = cvarfuncs->Register(v->name, v->string, v->flags, v->group);
|
|
}
|
|
}
|
|
|
|
static int IRC_CvarUpdate(void) // perhaps void instead?
|
|
{
|
|
vmcvar_t *v;
|
|
int i;
|
|
for (i=0; cvarlist[i]; i++)
|
|
{
|
|
v = cvarlist[i];
|
|
cvarfuncs->Update(v->handle, &v->modificationcount, v->string, sizeof(v->string), &v->value);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void IRC_Command(ircclient_t *ircclient, char *dest, char *args);
|
|
qboolean IRC_ExecuteCommand(qboolean isinsecure);
|
|
int IRC_ConExecuteCommand(qboolean isinsecure);
|
|
void IRC_Frame(double realtime, double gametime);
|
|
qboolean IRC_ConsoleLink(void);
|
|
|
|
qboolean Plug_Init(void)
|
|
{
|
|
confuncs = plugfuncs->GetEngineInterface(plugsubconsolefuncs_name, sizeof(*confuncs));
|
|
filefuncs = plugfuncs->GetEngineInterface(plugfsfuncs_name, sizeof(*filefuncs));
|
|
netfuncs = plugfuncs->GetEngineInterface(plugnetfuncs_name, sizeof(*netfuncs));
|
|
drawfuncs = plugfuncs->GetEngineInterface(plug2dfuncs_name, sizeof(*drawfuncs));
|
|
piceapi = plugfuncs->GetEngineInterface(ICE_API_CURRENT, sizeof(*piceapi));
|
|
plugfuncs->ExportFunction("UpdateVideo", IRC_UpdateVideo);
|
|
|
|
if (netfuncs &&
|
|
filefuncs &&
|
|
plugfuncs->ExportFunction("Tick", IRC_Frame) &&
|
|
plugfuncs->ExportFunction("ExecuteCommand", IRC_ExecuteCommand))
|
|
{
|
|
cmdfuncs->AddCommand(COMMANDNAME);
|
|
|
|
plugfuncs->ExportFunction("ConsoleLink", IRC_ConsoleLink);
|
|
if (!confuncs || !plugfuncs->ExportFunction("ConExecuteCommand", IRC_ConExecuteCommand))
|
|
Con_TrySubPrint = Con_FakeSubPrint;
|
|
else
|
|
Con_TrySubPrint = confuncs->SubPrint;
|
|
|
|
reloadconfig = true;
|
|
IRC_InitCvars();
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
plugfuncs->Print("IRC Client Plugin failed\n");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
qboolean IRC_ExecuteCommand(qboolean isinsecure)
|
|
{
|
|
char cmd[256];
|
|
cmdfuncs->Argv(0, cmd, sizeof(cmd));
|
|
if (!strcmp(cmd, COMMANDNAME))
|
|
{
|
|
ircclient_t *ircclient = ircclients;
|
|
char imsg[8192];
|
|
cmdfuncs->Args(imsg, sizeof(imsg));
|
|
//FIXME: select an irc network more inteligently
|
|
IRC_Command(ircclient, ircclient?ircclient->defaultdest:"", imsg);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
int IRC_ConExecuteCommand(qboolean isinsecure)
|
|
{
|
|
char buffer[256];
|
|
char imsg[8192];
|
|
ircclient_t *ircclient;
|
|
//FIXME: select the right network
|
|
|
|
cmdfuncs->Argv(0, buffer, sizeof(buffer));
|
|
cmdfuncs->Args(imsg, sizeof(imsg));
|
|
|
|
//buffer is something like: irc53:#foo
|
|
for (ircclient = ircclients; ircclient; ircclient = ircclient->next)
|
|
{
|
|
if (!strncmp(ircclient->id, buffer, strlen(ircclient->id)))
|
|
break;
|
|
}
|
|
|
|
if (!ircclient)
|
|
{
|
|
if (*buffer == '/')
|
|
IRC_Command(NULL, "", imsg);
|
|
else
|
|
Con_TrySubPrint(buffer, "You were disconnected\n");
|
|
return true;
|
|
}
|
|
|
|
IRC_Command(ircclient, buffer+strlen(ircclient->id), imsg);
|
|
return true;
|
|
}
|
|
|
|
static void IRC_AddClientMessage(ircclient_t *irc, char *msg)
|
|
{
|
|
char output[4096];
|
|
int len;
|
|
|
|
Q_strlcpy(output, msg, sizeof(output));
|
|
Q_strlcat(output, "\n", sizeof(output));
|
|
len = strlen(output);
|
|
|
|
if (irc->bufferedoutammount + len > sizeof(irc->bufferedoutmessage))
|
|
return;
|
|
memcpy(irc->bufferedoutmessage + irc->bufferedoutammount, output, len);
|
|
irc->bufferedoutammount += len;
|
|
|
|
if (irc_debug.value == 1) { IRC_Printf(irc, DEFAULTCONSOLE,COLOURYELLOW "<< %s \n",msg); }
|
|
}
|
|
|
|
static ircclient_t *IRC_FindAccount(const char *server)
|
|
{
|
|
ircclient_t *irc;
|
|
for (irc = ircclients; irc; irc = irc->next)
|
|
{
|
|
if (!strcmp(irc->server, server))
|
|
return irc;
|
|
}
|
|
return NULL; //no match
|
|
}
|
|
|
|
static ircclient_t *IRC_Create(const char *server, const char *nick, const char *realname, const char *hostname, const char *username, const char *password, const char *channels)
|
|
{
|
|
ircclient_t *irc;
|
|
|
|
//FIXME: accept server:+port for starttls
|
|
//FIXME: accept server:*port for initial tls
|
|
|
|
irc = IRC_Malloc(sizeof(ircclient_t));
|
|
if (!irc)
|
|
return NULL;
|
|
|
|
memset(irc, 0, sizeof(ircclient_t));
|
|
Q_snprintf(irc->id, sizeof(irc->id), "IRC%x%x:", rand(),rand());
|
|
irc->connecting = true;
|
|
irc->tlsmode = TLS_OFF;
|
|
irc->quitting = false;
|
|
irc->socket = invalid_handle;
|
|
|
|
Q_strlcpy(irc->server, server, sizeof(irc->server));
|
|
|
|
IRC_CvarUpdate();
|
|
|
|
Q_strlcpy(irc->primarynick, nick, sizeof(irc->primarynick));
|
|
Q_strlcpy(irc->nick, nick, sizeof(irc->nick));
|
|
Q_strlcpy(irc->realname, realname, sizeof(irc->realname));
|
|
Q_strlcpy(irc->hostname, hostname, sizeof(irc->hostname));
|
|
Q_strlcpy(irc->username, username, sizeof(irc->username));
|
|
Q_strlcpy(irc->pwd, password, sizeof(irc->pwd));
|
|
|
|
Q_strlcpy(irc->autochannels,channels, sizeof(irc->autochannels));
|
|
|
|
// gethostname(irc->hostname, sizeof(irc->hostname));
|
|
// irc->hostname[sizeof(irc->hostname)-1] = 0;
|
|
|
|
irc->next = ircclients;
|
|
ircclients = irc;
|
|
|
|
return irc;
|
|
}
|
|
|
|
static void IRC_SetPass(ircclient_t *irc, char *pass)
|
|
{
|
|
if (irc->pwd != pass)
|
|
Q_strlcpy(irc->pwd, pass, sizeof(irc->pwd));
|
|
if (*pass && irc->tlsmode != TLS_STARTING)
|
|
IRC_AddClientMessage(irc, va("PASS %s", pass));
|
|
}
|
|
static void IRC_SetNick(ircclient_t *irc, char *nick)
|
|
{
|
|
if (irc->nick != nick)
|
|
Q_strlcpy(irc->nick, nick, sizeof(irc->nick));
|
|
if (irc->tlsmode != TLS_STARTING)
|
|
IRC_AddClientMessage(irc, va("NICK %s", irc->nick));
|
|
}
|
|
static void IRC_SetUser(ircclient_t *irc, char *user)
|
|
{
|
|
IRC_CvarUpdate();
|
|
|
|
if (irc->tlsmode != TLS_STARTING)
|
|
{
|
|
const char *username = irc->username;
|
|
const char *realname = irc->realname;
|
|
if (!*username)
|
|
username = getenv("USER");
|
|
if (!username)
|
|
username = "FTE"; //we need something.
|
|
|
|
if (!*realname)
|
|
realname = username;
|
|
//servers will usually ignore the server arg, as they usually know their own dns name already...
|
|
//servers SHOULD ignore the hostname arg too (using a reverse dns). or they'll just replace it with an ip address (note: could use this instead of a STUN server).
|
|
//the username+realname are used, and need to be persistent for auto-op type mechanisms.
|
|
IRC_AddClientMessage(irc, va("USER %s %s %s :%s", username, irc->hostname, irc->server, realname));
|
|
}
|
|
}
|
|
|
|
static qboolean IRC_Establish(ircclient_t *irc)
|
|
{
|
|
if (!irc)
|
|
return false;
|
|
|
|
if (handleisvalid(irc->socket)) //don't need to do anything.
|
|
return true;
|
|
|
|
//clear up any stale state
|
|
irc->bufferedoutammount = 0;
|
|
irc->bufferedinammount = 0;
|
|
irc->quitting = false;
|
|
|
|
irc->socket = netfuncs->TCPConnect(irc->server, 6667); //port is only used if the url doesn't contain one. It's a default.
|
|
|
|
//not yet blocking. So no frequent attempts please...
|
|
//non blocking prevents connect from returning worthwhile sensible value.
|
|
if (!handleisvalid(irc->socket))
|
|
{
|
|
Con_Printf("IRC_OpenSocket: couldn't connect\n");
|
|
return false;
|
|
}
|
|
|
|
if (irc->tlsmode == TLS_INITIAL)
|
|
{
|
|
if (netfuncs->SetTLSClient(irc->socket, irc->server) < 0)
|
|
{
|
|
netfuncs->Close(irc->socket);
|
|
irc->socket = invalid_handle;
|
|
return false;
|
|
}
|
|
}
|
|
else if (irc->tlsmode != TLS_OFF)
|
|
{
|
|
IRC_AddClientMessage(irc, "STARTTLS");
|
|
irc->tlsmode = TLS_STARTING;
|
|
}
|
|
else
|
|
{
|
|
irc->nicktries = 0;
|
|
IRC_SetPass(irc, irc->pwd);
|
|
IRC_SetNick(irc, irc->nick);
|
|
IRC_SetUser(irc, irc_username.string);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void IRC_ParseConfig(void)
|
|
{
|
|
qhandle_t config;
|
|
int len = filefuncs->Open("**plugconfig", &config, 1);
|
|
if (len >= 0)
|
|
{
|
|
char *buf = malloc(len+1);
|
|
char *msg = buf;
|
|
buf[len] = 0;
|
|
filefuncs->Read(config, buf, len);
|
|
filefuncs->Close(config);
|
|
|
|
while (msg && *msg)
|
|
{
|
|
ircclient_t *irc;
|
|
char server[256];
|
|
char channels[1024];
|
|
char nick[256];
|
|
char password[256];
|
|
char realname[256];
|
|
char hostname[256];
|
|
char username[256];
|
|
|
|
msg = COM_Parse(msg, server, sizeof(server));
|
|
msg = COM_Parse(msg, channels, sizeof(channels));
|
|
msg = COM_Parse(msg, nick, sizeof(nick));
|
|
msg = COM_Parse(msg, password, sizeof(password));
|
|
msg = COM_Parse(msg, realname, sizeof(realname));
|
|
msg = COM_Parse(msg, hostname, sizeof(hostname));
|
|
msg = COM_Parse(msg, username, sizeof(username));
|
|
if (*server)
|
|
{
|
|
irc = IRC_Create(server, nick, realname, hostname, username, password, channels);
|
|
if (irc)
|
|
{
|
|
irc->persist = true;
|
|
if (IRC_Establish(irc))
|
|
{
|
|
if (!*irc->autochannels)
|
|
IRC_Printf(irc, DEFAULTCONSOLE, "Trying to connect to %s\n", irc->server);
|
|
}
|
|
else
|
|
IRC_Printf(irc, DEFAULTCONSOLE, "Unable to connect to %s\n", irc->server);
|
|
}
|
|
}
|
|
}
|
|
|
|
free(buf);
|
|
}
|
|
}
|
|
static void IRC_WriteConfig(void)
|
|
{
|
|
qhandle_t config;
|
|
|
|
if (irc_config.value == 0)
|
|
return;
|
|
|
|
filefuncs->Open("**plugconfig", &config, 2);
|
|
if (config >= 0)
|
|
{
|
|
ircclient_t *irc;
|
|
for(irc = ircclients; irc; irc = irc->next)
|
|
{
|
|
char *s = va("\"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"\n", irc->server, irc->autochannels, irc->primarynick, irc->pwd, irc->realname, irc->hostname, irc->username);
|
|
if (irc->quitting || !irc->persist)
|
|
continue;
|
|
filefuncs->Write(config, s, strlen(s));
|
|
}
|
|
|
|
filefuncs->Close(config);
|
|
}
|
|
}
|
|
static void IRC_MakeDefault(ircclient_t *irc)
|
|
{ //unlinks the client, then links it at the head, so that its the first found (thus the default)
|
|
ircclient_t **link;
|
|
|
|
for (link = &ircclients; *link; link = &(*link)->next)
|
|
{
|
|
if (*link == irc)
|
|
{
|
|
*link = irc->next;
|
|
break;
|
|
}
|
|
}
|
|
|
|
irc->next = ircclients;
|
|
ircclients = irc;
|
|
}
|
|
|
|
static void IRC_PartChannelInternal(ircclient_t *irc, char *channelname)
|
|
{
|
|
char ac[countof(irc->autochannels)];
|
|
char *chan;
|
|
strcpy(ac, irc->autochannels);
|
|
chan = strtok(ac, " ");
|
|
*irc->autochannels = 0;
|
|
while(chan)
|
|
{
|
|
if (*chan)
|
|
{
|
|
char *pwd = strchr(chan, ',');
|
|
if (pwd)
|
|
*pwd++ = 0;
|
|
|
|
if (strcmp(chan, channelname))
|
|
{
|
|
if (*irc->autochannels)
|
|
Q_strncatz(irc->autochannels, " ", sizeof(irc->autochannels));
|
|
if (pwd)
|
|
Q_strncatz(irc->autochannels, va("%s,%s", chan, pwd), sizeof(irc->autochannels));
|
|
else
|
|
Q_strncatz(irc->autochannels, va("%s", chan), sizeof(irc->autochannels));
|
|
}
|
|
}
|
|
chan = strtok(NULL, " ");
|
|
}
|
|
}
|
|
|
|
static void IRC_PartChannel(ircclient_t *irc, char *channelname)
|
|
{
|
|
IRC_PartChannelInternal(irc, channelname);
|
|
IRC_AddClientMessage(irc, va("PART %s", channelname));
|
|
}
|
|
|
|
static void IRC_JoinChannel(ircclient_t *irc, char *channel, char *key) // i screwed up, its actually: <channel>{,<channel>} [<key>{,<key>}]
|
|
{
|
|
IRC_PartChannelInternal(irc, channel);
|
|
|
|
if (*irc->autochannels)
|
|
Q_strncatz(irc->autochannels, " ", sizeof(irc->autochannels));
|
|
Q_strncatz(irc->autochannels, va("%s,%s", channel, key), sizeof(irc->autochannels));
|
|
|
|
if (key)
|
|
{
|
|
/*if (*channel != '#')
|
|
IRC_AddClientMessage(irc, va("JOIN #%s %s", channel,key));
|
|
else*/
|
|
IRC_AddClientMessage(irc, va("JOIN %s %s", channel,key));
|
|
}
|
|
else
|
|
{
|
|
/*if (*channel != '#')
|
|
IRC_AddClientMessage(irc, va("JOIN #%s", channel));
|
|
else*/
|
|
IRC_AddClientMessage(irc, va("JOIN %s", channel));
|
|
}
|
|
}
|
|
|
|
static void IRC_JoinChannels(ircclient_t *irc, char *channelstring)
|
|
{
|
|
char *chan = strtok(channelstring, " ");
|
|
while(chan)
|
|
{
|
|
if (*chan)
|
|
{
|
|
char *line = va("JOIN %s", chan);
|
|
char *comma = strchr(line, ',');
|
|
if (comma)
|
|
*comma = ' ';
|
|
IRC_AddClientMessage(irc, line);
|
|
}
|
|
chan = strtok(NULL, " ");
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
|
|
ATTN: Spike
|
|
|
|
# (just for reference) == Ctrl+K in mirc to put the color code symbol in
|
|
|
|
now to have a background color, you must specify a forground color first (#0,15)
|
|
|
|
, denotes end of forground color, and start of background color
|
|
|
|
irc colors work in many strange ways:
|
|
|
|
#0-#15 for forground color // the code currently converts to this one, which is not the "proper" irc way, read the next one to understand. Still need to support it, just not output as it.
|
|
|
|
#00-#15 for forground color (note #010 to #015 is not valid) --- this is the "proper" irc way, because I could say "#11+1=2" (which means I want 1+1=2 to appear black (1), but instead it will come out as indigo (11) and look like this: +1=2)
|
|
|
|
background examples: (note
|
|
|
|
#0,15 (white forground, light gray background)
|
|
|
|
#00,15 (white forground, light gray background) // proper way
|
|
|
|
#15,0 (white forground, light gray background)
|
|
|
|
#15,00 (white forground, light gray background) // proper way
|
|
|
|
I hope this makes sense to you, to be able to edit the IRC_FilterMircColours function ~ Moodles
|
|
|
|
*/
|
|
static void IRC_FilterMircColours(char *msg)
|
|
{
|
|
int i;
|
|
int chars;
|
|
while(*msg)
|
|
{
|
|
if (*msg == 3)
|
|
{
|
|
chars = 2;
|
|
if (msg[1] >= '0' && msg[1] <= '9')
|
|
{
|
|
i = msg[1]- '0';
|
|
if (msg[2] >= '0' && msg[2] <= '9')
|
|
{
|
|
i = i*10 + (msg[2]-'0');
|
|
chars = 3;
|
|
}
|
|
}
|
|
else
|
|
i = msg[1];
|
|
switch(i)
|
|
{
|
|
case 0:
|
|
msg[1] = '7'; //white
|
|
break;
|
|
case 1:
|
|
msg[1] = '0'; //black
|
|
break;
|
|
case 2:
|
|
msg[1] = '4'; //darkblue
|
|
break;
|
|
case 3:
|
|
msg[1] = '2'; //darkgreen
|
|
break;
|
|
case 4:
|
|
msg[1] = '1'; //red
|
|
break;
|
|
case 5:
|
|
msg[1] = '1'; //brown
|
|
break;
|
|
case 6:
|
|
msg[1] = '5'; //purple
|
|
break;
|
|
case 7:
|
|
msg[1] = '3'; //orange
|
|
break;
|
|
case 8:
|
|
msg[1] = '3'; //yellow
|
|
break;
|
|
case 9:
|
|
msg[1] = '2'; //lightgreen
|
|
break;
|
|
case 10:
|
|
msg[1] = '6'; //darkcyan
|
|
break;
|
|
case 11:
|
|
msg[1] = '6'; //lightcyan
|
|
break;
|
|
case 12:
|
|
msg[1] = '4'; //lightblue
|
|
break;
|
|
case 13:
|
|
msg[1] = '5'; //pink
|
|
break;
|
|
case 14:
|
|
msg[1] = '7'; //grey
|
|
break;
|
|
case 15:
|
|
msg[1] = '7'; //lightgrey
|
|
break;
|
|
default:
|
|
msg++;
|
|
continue;
|
|
}
|
|
*msg = '^';
|
|
msg+=2;
|
|
if (chars==3)
|
|
memmove(msg, msg+1, strlen(msg));
|
|
continue;
|
|
}
|
|
msg++;
|
|
}
|
|
}
|
|
|
|
#define IRC_DONE 0
|
|
#define IRC_CONTINUE 1
|
|
#define IRC_KILL 2
|
|
|
|
static void magic_tokenizer(int word,char *thestring)
|
|
{
|
|
char *temp;
|
|
int i = 1;
|
|
|
|
strcpy(casevar[1],thestring);
|
|
|
|
temp = strchr(casevar[1], ' ');
|
|
|
|
while (i < 8)
|
|
{
|
|
i++;
|
|
|
|
if (temp != NULL)
|
|
{
|
|
strcpy(casevar[i],temp+1);
|
|
}
|
|
else
|
|
{
|
|
strcpy(casevar[i], "");
|
|
}
|
|
|
|
temp=strchr(casevar[i], ' ');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
static void magic_etghack(char *thestring)
|
|
{
|
|
char *temp;
|
|
int i = 1;
|
|
|
|
strcpy(subvar[1],thestring);
|
|
|
|
temp = strchr(subvar[1], ' ');
|
|
|
|
while (i < 8)
|
|
{
|
|
i++;
|
|
|
|
if (temp != NULL)
|
|
{
|
|
strcpy(subvar[i],temp+1);
|
|
}
|
|
else
|
|
{
|
|
strcpy(subvar[i], "");
|
|
}
|
|
|
|
temp=strchr(subvar[i], ' ');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
static void IRC_TryNewNick(ircclient_t *irc, char *nickname)
|
|
{
|
|
char *seedednick;
|
|
|
|
IRC_CvarUpdate();
|
|
|
|
if (irc->tlsmode == TLS_STARTING)
|
|
{
|
|
//don't submit any of this info here.
|
|
return;
|
|
}
|
|
if (irc->connecting)
|
|
{
|
|
if (irc->nicktries == 0)
|
|
{
|
|
irc->nicktries++;
|
|
if (*irc->primarynick && strcmp(nickname, irc->primarynick))
|
|
{
|
|
IRC_SetNick(irc, irc->primarynick);
|
|
return;
|
|
}
|
|
}
|
|
if (irc->nicktries == 1)
|
|
{
|
|
irc->nicktries++;
|
|
if (*irc_nick.string && strcmp(nickname, irc_nick.string))
|
|
{
|
|
IRC_SetNick(irc, irc_nick.string);
|
|
return;
|
|
}
|
|
}
|
|
if (irc->nicktries == 2)
|
|
{
|
|
irc->nicktries++;
|
|
if (*irc_altnick.string && strcmp(nickname, irc_altnick.string))
|
|
{
|
|
IRC_SetNick(irc, irc_altnick.string);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (++irc->nicktries == 10)
|
|
{
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURRED "ERROR: Unable to obtain usable nickname\n");
|
|
return;
|
|
}
|
|
|
|
//panic and pick something at random
|
|
//IRC_Printf(irc, DEFAULTCONSOLE, COLOURRED "ERROR: primary nickname in use. Attempting random nickname.\n");
|
|
if (*irc->primarynick && irc->nicktries < 7)
|
|
seedednick = va("%.6s%i", irc->primarynick, rand());
|
|
else if (*irc_nick.string && irc->nicktries < 8)
|
|
seedednick = va("%.6s%i", irc_nick.string, rand());
|
|
else if (*irc_altnick.string && irc->nicktries < 9)
|
|
seedednick = va("%.6s%i", irc_altnick.string, rand());
|
|
else
|
|
seedednick = va("%.6s%i", "FTE", rand());
|
|
seedednick[9] = 0; //'Each client is distinguished from other clients by a unique nickname having a maximum length of nine (9) characters'
|
|
|
|
IRC_SetNick(irc, seedednick);
|
|
}
|
|
}
|
|
|
|
//==================================================
|
|
|
|
static void numbered_command(int comm, char *msg, ircclient_t *irc) // move vars up 1 more than debug says
|
|
{
|
|
magic_tokenizer(0,msg);
|
|
|
|
switch (comm)
|
|
{
|
|
case 1: /* RPL_WELCOME */
|
|
case 2: /* RPL_YOURHOST */
|
|
case 3: /* RPL_CREATED */
|
|
case 4: /* RPL_MYINFO */
|
|
case 5: /* RPL_ISUPPORT */
|
|
{
|
|
if (irc->tlsmode != TLS_STARTING)
|
|
irc->connecting = 0; // ok we are connected
|
|
|
|
if (irc_motd.value)
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURYELLOW "SERVER STATS: %s\n",casevar[3]);
|
|
return;
|
|
}
|
|
// case 5: /* RPL_BOUNCE */
|
|
// {
|
|
// IRC_Printf(irc, DEFAULTCONSOLE, COLOURRED "RPL_BOUNCE: %s\n",casevar[3]);
|
|
// return;
|
|
// }
|
|
case 20: /* RPL_HELLO */
|
|
{
|
|
if (irc_motd.value)
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURYELLOW "%s\n",casevar[3]);
|
|
return;
|
|
}
|
|
case 42: /*RPL_YOURID */
|
|
{
|
|
if (irc_motd.value)
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURYELLOW "%s\n",casevar[3]);
|
|
return;
|
|
}
|
|
case 250:
|
|
case 251: /* RPL_LUSERCLIENT */
|
|
case 252: /* RPL_LUSEROP */
|
|
case 253: /* RPL_LUSERUNKNOWN */
|
|
case 254: /* RPL_LUSERCHANNELS */
|
|
case 255: /* RPL_LUSERME */
|
|
case 256: /* RPL_ADMINME */
|
|
case 257: /* RPL_ADMINLOC1 */
|
|
case 258: /* RPL_ADMINLOC2 */
|
|
case 259: /* RPL_ADMINEMAIL */
|
|
case 265:
|
|
case 266:
|
|
{
|
|
if (irc_motd.value)
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURYELLOW "SERVER STATS: %s\n",casevar[3]);
|
|
return;
|
|
}
|
|
case 301: /* #define RPL_AWAY 301 */
|
|
{
|
|
char *username = strtok(casevar[3], " ");
|
|
char *awaymessage = casevar[4]+1;
|
|
|
|
IRC_Printf(irc, DEFAULTCONSOLE,"WHOIS: <%s> (Away Message: %s)\n",username,awaymessage);
|
|
return;
|
|
}
|
|
case 305: /* RPL_UNAWAY */
|
|
case 306: /* RPL_NOWAWAY */
|
|
{
|
|
char *away = casevar[3]+1;
|
|
|
|
IRC_Printf(irc, CURRENTCONSOLE,"%s\n",away);
|
|
return;
|
|
}
|
|
case 311: /* #define RPL_WHOISUSER 311 */
|
|
{
|
|
char *username = strtok(casevar[3], " ");
|
|
char *ident = strtok(casevar[4], " ");
|
|
char *address = strtok(casevar[5], " ");
|
|
char *realname = casevar[7]+1;
|
|
|
|
IRC_Printf(irc, DEFAULTCONSOLE,"WHOIS: <%s> (Ident: %s) (Address: %s) (Realname: %s) \n", username, ident, address, realname);
|
|
return;
|
|
}
|
|
case 312: /* #define RPL_WHOISSERVER 312 */ //seems to be /whowas also
|
|
{
|
|
char *username = strtok(casevar[3], " ");
|
|
char *serverhostname = strtok(casevar[4], " ");
|
|
char *servername = casevar[5]+1;
|
|
|
|
IRC_Printf(irc, DEFAULTCONSOLE,"WHOIS: <%s> (Server: %s) (Server Name: %s) \n", username, serverhostname, servername);
|
|
return;
|
|
}
|
|
case 313: /* RPL_WHOISOPERATOR */
|
|
{
|
|
char *username = strtok(casevar[3], " ");
|
|
char *isoperator = casevar[4]+1;
|
|
|
|
IRC_Printf(irc, DEFAULTCONSOLE,"WHOIS: <%s> (%s)\n", username,isoperator);
|
|
|
|
return;
|
|
}
|
|
case 317: /* #define RPL_WHOISIDLE 317 */
|
|
{
|
|
char *username = strtok(casevar[3], " ");
|
|
char *secondsidle = strtok(casevar[4], " ");
|
|
char *signontime = strtok(casevar[5], " ");
|
|
time_t t;
|
|
const struct tm *tm;
|
|
char buffer[100];
|
|
|
|
t=strtoul(signontime, 0, 0);
|
|
tm=localtime(&t);
|
|
|
|
strftime (buffer, 100, "%a %b %d %H:%M:%S", tm);
|
|
|
|
IRC_Printf(irc, DEFAULTCONSOLE,"WHOIS: <%s> (Idle Time: %s seconds) (Signon Time: %s) \n", username, secondsidle, buffer);
|
|
return;
|
|
}
|
|
case 318: /* #define RPL_ENDOFWHOIS 318 */
|
|
{
|
|
char *endofwhois = casevar[4]+1;
|
|
|
|
IRC_Printf(irc, DEFAULTCONSOLE,"WHOIS: %s\n", endofwhois);
|
|
|
|
return;
|
|
}
|
|
case 319: /* #define RPL_WHOISCHANNELS 319 */
|
|
{
|
|
char *username = strtok(casevar[3], " ");
|
|
char *channels = casevar[4]+1;
|
|
|
|
IRC_Printf(irc, DEFAULTCONSOLE,"WHOIS: <%s> (Channels: %s)\n",username,channels); // need to remove the space from the end of channels
|
|
return;
|
|
}
|
|
case 321:
|
|
{
|
|
// IRC_Printf(irc, "list", "Start /LIST\n");
|
|
|
|
return;
|
|
}
|
|
case 322: /* #define RPL_LIST 322 */
|
|
{
|
|
char *channel = strtok(casevar[3], " ");
|
|
char *users = strtok(casevar[4], " ");
|
|
char *topic = casevar[5]+1;
|
|
|
|
IRC_Printf(irc, "list", "^1Channel:^7 %s ^1Users:^7 %s ^1Topic:^7 %s\n\n", channel,users,topic);
|
|
return;
|
|
}
|
|
case 323: /* RPL_LISTEND*/
|
|
{
|
|
//char *endoflist = casevar[3]+1;
|
|
|
|
// IRC_Printf(irc, "list", "%s\n",endoflist);
|
|
|
|
return;
|
|
}
|
|
case 333: /* RPL_TOPICWHOTIME channel user timestamp*/
|
|
return;
|
|
case 366: /* RPL_ENDOFNAMES */
|
|
{
|
|
char *channel = strtok(casevar[3], " ");
|
|
char *endofnameslist = casevar[4]+1;
|
|
|
|
IRC_Printf(irc, channel,"%s\n",endofnameslist);
|
|
return;
|
|
}
|
|
case 372: /* RPL_MOTD */
|
|
case 375: /* RPL_MOTDSTART */
|
|
case 376: /* RPL_ENDOFMOTD */
|
|
{
|
|
char *motdmessage = casevar[3]+1;
|
|
|
|
IRC_CvarUpdate();
|
|
|
|
if (irc_motd.value == 2)
|
|
IRC_Printf(irc, DEFAULTCONSOLE, "MOTD: %s\n", motdmessage);
|
|
else if (irc_motd.value)
|
|
IRC_Printf(irc, DEFAULTCONSOLE, "%s\n", motdmessage);
|
|
|
|
if (*irc->autochannels)
|
|
IRC_JoinChannels(irc, irc->autochannels);
|
|
|
|
return;
|
|
}
|
|
case 378:
|
|
{
|
|
IRC_Printf(irc, DEFAULTCONSOLE, "%s\n", msg);
|
|
return;
|
|
}
|
|
case 401: /* ERR_NOSUCHNICK */
|
|
case 403: /* ERR_NOSUCHCHANNEL */
|
|
case 404: /* ERR_CANNOTSENDTOCHAN */
|
|
case 405: /* ERR_TOOMANYCHANNELS */
|
|
case 442: /* ERR_NOTONCHANNEL */
|
|
{
|
|
char *username = strtok(casevar[3], " ");
|
|
char *error = casevar[4]+1;
|
|
|
|
IRC_Printf(irc, username, COLOURRED "ERROR <%s>: %s\n",username,error);
|
|
return;
|
|
}
|
|
case 432: /* #define ERR_ERRONEUSNICKNAME 432 */
|
|
{
|
|
IRC_Printf(irc, DEFAULTCONSOLE, "Erroneous/invalid nickname given\n");
|
|
IRC_TryNewNick(irc, "FTEUser");
|
|
return;
|
|
}
|
|
case 433: /* #define ERR_NICKNAMEINUSE 433 */
|
|
case 438:
|
|
case 453:
|
|
{
|
|
char *nickname = strtok(casevar[4], " ");
|
|
char *badnickname = ":Nickname";
|
|
|
|
if ( !strcasecmp(nickname,badnickname) ) // bug with ircd, the nickname actually shifts position.
|
|
{
|
|
nickname = strtok(casevar[3], " ");
|
|
}
|
|
|
|
// IRC_Printf(irc, DEFAULTCONSOLE, COLOURRED "ERROR: <%s> is already in use.\n",nickname);
|
|
|
|
IRC_TryNewNick(irc, nickname);
|
|
return;
|
|
}
|
|
case 471: /* ERR_CHANNELISFULL */
|
|
{
|
|
char *channel = strtok(casevar[3], " ");
|
|
char *error = casevar[4]+1;
|
|
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURRED "ERROR: <%s>: %s (Channel is full and has reached user limit)\n",channel,error);
|
|
return;
|
|
}
|
|
case 472: /* ERR_UNKNOWNMODE */
|
|
{
|
|
char *mode = strtok(casevar[3], " ");
|
|
char *error = casevar[4]+1;
|
|
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURRED "ERROR: <%s>: %s (Unknown mode)\n",mode,error);
|
|
return;
|
|
}
|
|
case 473: /* ERR_INVITEONLYCHAN */
|
|
{
|
|
char *channel = strtok(casevar[3], " ");
|
|
char *error = casevar[4]+1;
|
|
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURRED "ERROR: <%s>: %s (Invite only)\n",channel,error);
|
|
return;
|
|
}
|
|
case 474: /* ERR_BANNEDFROMCHAN */
|
|
{
|
|
char *channel = strtok(casevar[3], " ");
|
|
char *error = casevar[4]+1;
|
|
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURRED "ERROR: <%s>: %s (You are banned)\n",channel,error);
|
|
return;
|
|
}
|
|
case 475: /* ERR_BADCHANNELKEY */
|
|
{
|
|
char *channel = strtok(casevar[3], " ");
|
|
char *error = casevar[4]+1;
|
|
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURRED "ERROR: <%s>: %s (Need the correct channel key. Example: /join %s bananas)\n",channel,error,channel);
|
|
return;
|
|
}
|
|
case 482: /* ERR_CHANOPRIVSNEEDED */
|
|
{
|
|
char *channel = strtok(casevar[3], " ");
|
|
char *error = casevar[4]+1;
|
|
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURRED "ERROR: <%s>: %s (Need +o or @ status)\n",channel,error);
|
|
return;
|
|
}
|
|
case 670: /* RPL_STARTTLS */
|
|
{
|
|
netfuncs->SetTLSClient(irc->socket, irc->server);
|
|
irc->tlsmode = TLS_START;
|
|
irc->nicktries = 0;
|
|
IRC_SetPass(irc, irc->pwd);
|
|
IRC_SetNick(irc, irc->nick);
|
|
IRC_SetUser(irc, irc_username.string);
|
|
return;
|
|
}
|
|
case 691: /* ERR_STARTTLS */
|
|
{
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURYELLOW "STARTTLS Failed: %s\n", casevar[3]);
|
|
netfuncs->Close(irc->socket);
|
|
irc->socket = invalid_handle;
|
|
return;
|
|
}
|
|
}
|
|
|
|
IRC_Printf(irc, DEFAULTCONSOLE, "%s\n", msg); // if no raw number exists, print the thing
|
|
}
|
|
|
|
static struct ircice_s *IRC_ICE_Find(ircclient_t *irc, const char *sender, enum iceproto_e type)
|
|
{
|
|
struct ircice_s *ice;
|
|
for (ice = irc->ice; ice; ice = ice->next)
|
|
{
|
|
if (ice->type == type && !strcmp(ice->peer, sender))
|
|
return ice;
|
|
}
|
|
return NULL;
|
|
}
|
|
static struct ircice_s *IRC_ICE_Create(ircclient_t *irc, const char *sender, enum iceproto_e type, qboolean creator)
|
|
{
|
|
struct icestate_s *ice;
|
|
struct ircice_s *ircice;
|
|
if (!piceapi)
|
|
return NULL;
|
|
|
|
if (!creator && type == ICEP_QWSERVER)
|
|
ice = piceapi->ICE_Create(NULL, NULL, sender, ICEM_ICE, ICEP_QWCLIENT);
|
|
else if (!creator && type == ICEP_QWCLIENT)
|
|
ice = piceapi->ICE_Create(NULL, NULL, sender, ICEM_ICE, ICEP_QWSERVER);
|
|
else
|
|
ice = piceapi->ICE_Create(NULL, NULL, sender, ICEM_ICE, type);
|
|
|
|
if (!ice)
|
|
return NULL;
|
|
|
|
piceapi->ICE_Set(ice, "controller", creator?"1":"0");
|
|
if (creator && type == ICEP_VOICE)
|
|
{
|
|
//note: the engine will ignore codecs it does not support.
|
|
piceapi->ICE_Set(ice, "codec96", "opus@48000");
|
|
piceapi->ICE_Set(ice, "codec97", "speex@16000"); //wide
|
|
piceapi->ICE_Set(ice, "codec98", "speex@8000"); //narrow
|
|
piceapi->ICE_Set(ice, "codec99", "speex@32000"); //ultrawide
|
|
piceapi->ICE_Set(ice, "codec8", "pcma@8000");
|
|
piceapi->ICE_Set(ice, "codec0", "pcmu@8000");
|
|
}
|
|
|
|
//query dns to see if there's a stunserver hosted by the same domain
|
|
//nslookup -querytype=SRV _stun._udp.example.com
|
|
// Q_snprintf(stunhost, sizeof(stunhost), "_stun._udp.%s", ice->server);
|
|
// if (NET_DNSLookup_SRV(stunhost, stunhost, sizeof(stunhost)))
|
|
// piceapi->ICE_Set(ice, "stunip", stunhost);
|
|
// else
|
|
{
|
|
//irc services tend to not provide any stun info, so steal someone's... hopefully they won't mind too much. :(
|
|
piceapi->ICE_Set(ice, "stunport", "19302");
|
|
piceapi->ICE_Set(ice, "stunip", "stun.l.google.com");
|
|
}
|
|
|
|
ircice = malloc(sizeof(*ircice));
|
|
memset(ircice, 0, sizeof(*ircice));
|
|
ircice->next = irc->ice;
|
|
irc->ice = ircice;
|
|
|
|
ircice->type = type;
|
|
Q_strlcpy(ircice->peer, sender, sizeof(ircice->peer));
|
|
ircice->host = creator;
|
|
ircice->accepted = false;
|
|
ircice->allowed = creator;
|
|
ircice->ice = ice;
|
|
|
|
return ircice;
|
|
}
|
|
static void IRC_ICE_Update(ircclient_t *irc, struct ircice_s *ice, char updatetype)
|
|
{
|
|
//'+' propose ('hey, can I call you please?')
|
|
//'=' offer ('these are my details')
|
|
//'*' finalise ('this is what I'm going to use')
|
|
//'-' reject ('get lost, I don't want to talk to you any more')
|
|
//'%' candiate ('try this address')
|
|
//I was originally using colons to separate terms, but switched to slashes to avoid smilies for irc clients that print unknown CTCP messages.
|
|
char message[1024];
|
|
struct icecandinfo_s *c;
|
|
char *icetype;
|
|
|
|
if (!ice->allowed && updatetype != '-')
|
|
return;
|
|
|
|
*message = 0;
|
|
|
|
switch(ice->type)
|
|
{
|
|
default:
|
|
case ICEP_VOICE:
|
|
icetype = "voice";
|
|
break;
|
|
case ICEP_QWSERVER:
|
|
icetype = "qwserver";
|
|
break;
|
|
case ICEP_QWCLIENT:
|
|
icetype = "qwclient";
|
|
break;
|
|
}
|
|
|
|
if (updatetype == '=' || updatetype == '*')
|
|
{
|
|
char ufrag[256];
|
|
char pwd[256];
|
|
|
|
piceapi->ICE_Get(ice->ice, "lufrag", ufrag, sizeof(ufrag));
|
|
piceapi->ICE_Get(ice->ice, "lpwd", pwd, sizeof(pwd));
|
|
|
|
Q_snprintf(message, sizeof(message), " ufrag/%s pwd/%s", ufrag, pwd);
|
|
}
|
|
|
|
if (updatetype == '+' || updatetype == '=')
|
|
{
|
|
unsigned int i;
|
|
for (i = 0; i <= 127; i++)
|
|
{
|
|
char codec[256];
|
|
char codecname[64];
|
|
char argn[64];
|
|
Q_snprintf(argn, sizeof(argn), "codec%i", i);
|
|
if (!piceapi->ICE_Get(ice->ice, argn, codecname, sizeof(codecname)))
|
|
continue;
|
|
|
|
if (!strcmp(codecname, "speex@8000")) //speex narrowband
|
|
Q_snprintf(codec, sizeof(codec), "codec/%i/speex/8000", i);
|
|
else if (!strcmp(codecname, "speex@16000")) //speex wideband
|
|
Q_snprintf(codec, sizeof(codec), "codec/%i/speex/16000", i);
|
|
else if (!strcmp(codecname, "speex@32000")) //speex ultrawideband
|
|
Q_snprintf(codec, sizeof(codec), "codec/%i/speex/32000", i);
|
|
else if (!strcmp(codecname, "pcma@8000")) //speex wideband
|
|
Q_snprintf(codec, sizeof(codec), "codec/%i/pcma/8000", i);
|
|
else if (!strcmp(codecname, "pcmu@8000")) //speex ultrawideband
|
|
Q_snprintf(codec, sizeof(codec), "codec/%i/pcmu/8000", i);
|
|
else if (!strcmp(codecname, "opus@48000")) //opus codec.
|
|
Q_snprintf(codec, sizeof(codec), "codec/%i/opus/48000", i);
|
|
else
|
|
continue;
|
|
|
|
if (strlen(message) + strlen(codec) + 2 > 256)
|
|
{
|
|
IRC_AddClientMessage(irc, va("NOTICE %s :\001FTEICE %c%s%s\001", ice->peer, updatetype, icetype, message));
|
|
updatetype = '%';
|
|
*message = 0;
|
|
}
|
|
|
|
Q_strlcat(message, " ", sizeof(message));
|
|
Q_strlcat(message, codec, sizeof(message));
|
|
}
|
|
}
|
|
|
|
/* if (*message)
|
|
{
|
|
IRC_AddClientMessage(irc, va("NOTICE %s :\001FTEICE %c%s%s\001", ice->peer, updatetype, icetype, message));
|
|
*message = 0;
|
|
}
|
|
*/
|
|
if (updatetype != '+' && updatetype != '-')
|
|
{
|
|
while ((c = piceapi->ICE_GetLCandidateInfo(ice->ice)))
|
|
{
|
|
char type[] = "hspr";
|
|
char cand[256];
|
|
Q_snprintf(cand, sizeof(cand), "cand/"
|
|
"%c%c/%i/%i/"
|
|
"%i/%i/%i/"
|
|
"%i/%s/%s",
|
|
type[c->type], 'u', c->priority, c->port,
|
|
c->network, c->generation, c->foundation,
|
|
c->component, c->candidateid, c->addr);
|
|
|
|
if (strlen(message) + strlen(cand) + 2 > 256)
|
|
{
|
|
IRC_AddClientMessage(irc, va("NOTICE %s :\001FTEICE %c%s%s\001", ice->peer, updatetype, icetype, message));
|
|
updatetype = '%';
|
|
*message = 0;
|
|
}
|
|
|
|
Q_strlcat(message, " ", sizeof(message));
|
|
Q_strlcat(message, cand, sizeof(message));
|
|
}
|
|
}
|
|
if (*message || updatetype != '%')
|
|
IRC_AddClientMessage(irc, va("NOTICE %s :\001FTEICE %c%s%s\001", ice->peer, updatetype, icetype, message));
|
|
}
|
|
|
|
static void IRC_ICE_ParseCandidate(struct icestate_s *ice, char *cand)
|
|
{
|
|
char *addr;
|
|
struct icecandinfo_s info;
|
|
if (strlen(cand) < 12)
|
|
return;
|
|
switch(cand[5])
|
|
{
|
|
case 'h': info.type = ICE_HOST; break;
|
|
case 's': info.type = ICE_SRFLX; break;
|
|
case 'p': info.type = ICE_PRFLX; break;
|
|
default:
|
|
case 'r': info.type = ICE_RELAY; break;
|
|
}
|
|
info.transport = (cand[6] == 't')?1:0;
|
|
info.priority = strtol(cand+8, &cand, 0); if (*cand != '/')return;
|
|
info.port = strtol(cand+1, &cand, 0); if (*cand != '/')return;
|
|
info.network = strtol(cand+1, &cand, 0); if (*cand != '/')return;
|
|
info.generation = strtol(cand+1, &cand, 0); if (*cand != '/')return;
|
|
info.foundation = strtol(cand+1, &cand, 0); if (*cand != '/')return;
|
|
info.component = strtol(cand+1, &cand, 0); if (*cand != '/')return;
|
|
addr = strchr(cand+1, '/');
|
|
if (!addr)
|
|
return;
|
|
*addr++ = 0;
|
|
Q_strlcpy(info.candidateid, cand+1, sizeof(info.candidateid));
|
|
Q_strlcpy(info.addr, addr, sizeof(info.candidateid));
|
|
|
|
piceapi->ICE_AddRCandidateInfo(ice, &info);
|
|
}
|
|
|
|
static void IRC_ICE_ParseCodec(struct icestate_s *ice, char *codec)
|
|
{
|
|
char *start;
|
|
unsigned int num;
|
|
char name[64];
|
|
unsigned int rate;
|
|
num = strtoul(codec+6, &codec, 0); if (*codec != '/')return;
|
|
start = codec+1; codec = strchr(codec, '/'); if (!codec)return;*codec = 0; Q_strlcpy(name, start, sizeof(name));
|
|
rate = strtoul(codec+1, &codec, 0);
|
|
|
|
Q_strlcat(name, va("@%u", rate), sizeof(name));
|
|
|
|
piceapi->ICE_Set(ice, va("codec%i", num), name);
|
|
}
|
|
|
|
static void IRC_ICE_Parse(ircclient_t *irc, const char *sender, char *message)
|
|
{
|
|
struct ircice_s *ice;
|
|
char token[256];
|
|
enum iceproto_e type = ICEP_INVALID;
|
|
message = COM_Parse(message, token, sizeof(token));
|
|
if (*token == '+' || *token == '=' || *token == '*' || *token == '%')
|
|
{ //+ is offer or accept for a new content type
|
|
//= is an ack from the receiver
|
|
//* is the final handshake that includes offerer's full details
|
|
//% is extra updates.
|
|
char icetype = *token;
|
|
if (!strcmp(token+1, "voice"))
|
|
type = ICEP_VOICE;
|
|
else if (!strcmp(token+1, "qwserver"))
|
|
type = ICEP_QWSERVER;
|
|
else if (!strcmp(token+1, "qwclient"))
|
|
type = ICEP_QWCLIENT;
|
|
else
|
|
{
|
|
IRC_Printf(irc, sender, "ICE session type %s is not recognised\n", token);
|
|
return;
|
|
}
|
|
|
|
ice = IRC_ICE_Find(irc, sender, type);
|
|
if (!ice && (icetype == '+' || icetype == '='))
|
|
ice = IRC_ICE_Create(irc, sender, type, false);//icetype=='=');
|
|
|
|
if (ice)
|
|
{
|
|
while(message)
|
|
{
|
|
message = COM_Parse(message, token, sizeof(token));
|
|
if (!strncmp(token, "cand/", 5))
|
|
IRC_ICE_ParseCandidate(ice->ice, token);
|
|
else if (!strncmp(token, "codec/", 6))
|
|
IRC_ICE_ParseCodec(ice->ice, token);
|
|
else if (!strncmp(token, "ufrag/", 6))
|
|
piceapi->ICE_Set(ice->ice, "rufrag", token+6);
|
|
else if (!strncmp(token, "pwd/", 4))
|
|
piceapi->ICE_Set(ice->ice, "rpwd", token+4);
|
|
else if (*token)
|
|
IRC_Printf(irc, sender, "unknown ice token %s\n", token);
|
|
}
|
|
|
|
if ((icetype == '=' || icetype == '*') && !ice->accepted && ice->allowed)
|
|
{
|
|
piceapi->ICE_Set(ice->ice, "state", STRINGIFY(ICE_CONNECTING));
|
|
ice->accepted = true;
|
|
}
|
|
|
|
switch(icetype)
|
|
{
|
|
case '+':
|
|
//needs user
|
|
if (!ice->allowed)
|
|
{
|
|
switch(type)
|
|
{
|
|
case ICEP_VOICE: IRC_Printf(irc, sender, "%s is trying to call you. ^[[Click to Converse]\\act\\iceaccept_v\\who\\%s^] ^[[Click to Decline]\\act\\icedecline_v\\who\\%s^] \n", sender, sender, sender); break;
|
|
case ICEP_QWSERVER: IRC_Printf(irc, sender, "%s wants you to join their game. ^[[Click to Join]\\act\\iceaccept_s\\who\\%s^] ^[[Click to Decline]\\act\\icedecline_s\\who\\%s^] \n", sender, sender, sender); break;
|
|
case ICEP_QWCLIENT: IRC_Printf(irc, sender, "%s is trying to gatecrash your game. ^[[Click to Allow]\\act\\iceaccept_c\\who\\%s^] ^[[Click to Decline]\\act\\icedecline_c\\who\\%s^] \n", sender, sender, sender); break;
|
|
case ICEP_INVALID: break;
|
|
case ICEP_VIDEO: break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch(type)
|
|
{
|
|
case ICEP_VOICE: IRC_Printf(irc, sender, "Accepting voice call\n"); break;
|
|
case ICEP_QWSERVER: IRC_Printf(irc, sender, "Accepting game invite\n"); break;
|
|
case ICEP_QWCLIENT: IRC_Printf(irc, sender, "Accepting gatecrash\n"); break;
|
|
case ICEP_INVALID: break;
|
|
case ICEP_VIDEO: break;
|
|
}
|
|
IRC_ICE_Update(irc, ice, '=');
|
|
}
|
|
break;
|
|
case '=':
|
|
switch(type)
|
|
{
|
|
case ICEP_VOICE: IRC_Printf(irc, sender, "Establishing voice call\n"); break;
|
|
case ICEP_QWSERVER: IRC_Printf(irc, sender, "Establishing game invite\n"); break;
|
|
case ICEP_QWCLIENT: IRC_Printf(irc, sender, "Establishing gatecrash\n"); break;
|
|
case ICEP_INVALID: break;
|
|
case ICEP_VIDEO: break;
|
|
}
|
|
IRC_ICE_Update(irc, ice, '*');
|
|
break;
|
|
default:
|
|
switch(type)
|
|
{
|
|
case ICEP_VOICE: IRC_Printf(irc, sender, "Updating voice call\n"); break;
|
|
case ICEP_QWSERVER: IRC_Printf(irc, sender, "Updating game invite\n"); break;
|
|
case ICEP_QWCLIENT: IRC_Printf(irc, sender, "Updating gatecrash\n"); break;
|
|
case ICEP_INVALID: break;
|
|
case ICEP_VIDEO: break;
|
|
}
|
|
IRC_ICE_Update(irc, ice, '%');
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (*token == '-')
|
|
{
|
|
IRC_Printf(irc, sender, "dropping connections is not supported yet: %s\n", token);
|
|
}
|
|
else
|
|
IRC_Printf(irc, sender, "ICE command type not supported: %s\n", token);
|
|
}
|
|
|
|
static void IRC_ICE_Frame(ircclient_t *irc)
|
|
{
|
|
char bah[8];
|
|
struct ircice_s *ice;
|
|
for (ice = irc->ice; ice; ice = ice->next)
|
|
{
|
|
if (!ice->accepted || !ice->allowed)
|
|
continue;
|
|
//ice needs some maintainence. if things change then we need to be prepared to send updated candidate info
|
|
piceapi->ICE_Get(ice->ice, "newlc", bah, sizeof(bah));
|
|
if (atoi(bah))
|
|
{
|
|
IRC_Printf(irc, ice->peer, "Sending updated peer info\n");
|
|
IRC_ICE_Update(irc, ice, '%');
|
|
}
|
|
|
|
//FIXME: detect when the ice connection goes idle.
|
|
}
|
|
}
|
|
|
|
static void IRC_ICE_Authorise(ircclient_t *irc, const char *with, enum iceproto_e type, qboolean authorize, char *announce)
|
|
{
|
|
struct ircice_s *ice, **link;
|
|
for (link = &irc->ice; *link; link = &(*link)->next)
|
|
{
|
|
ice = *link;
|
|
if (ice->type == type)
|
|
if (!strcmp(ice->peer, with))
|
|
{
|
|
if (authorize)
|
|
{
|
|
if (ice->allowed)
|
|
{
|
|
IRC_Printf(irc, announce, "Connection is already authorised\n");
|
|
return; //nothing to do
|
|
}
|
|
|
|
//yay! its good to go!
|
|
ice->allowed = true;
|
|
switch(type)
|
|
{
|
|
case ICEP_VOICE: IRC_Printf(irc, announce, "Accepting voice call\n"); break;
|
|
case ICEP_QWSERVER: IRC_Printf(irc, announce, "Accepting game invite\n"); break;
|
|
case ICEP_QWCLIENT: IRC_Printf(irc, announce, "Accepting gatecrash\n"); break;
|
|
case ICEP_VIDEO: break;
|
|
case ICEP_INVALID: break;
|
|
}
|
|
IRC_ICE_Update(irc, ice, '=');
|
|
}
|
|
else
|
|
{
|
|
IRC_ICE_Update(irc, ice, '-');
|
|
*link = ice->next;
|
|
if (ice->ice)
|
|
piceapi->ICE_Close(ice->ice);
|
|
IRC_Free(ice);
|
|
|
|
IRC_Printf(irc, announce, "Connection terminated\n");
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
IRC_Printf(irc, announce, "Connection is already terminated\n");
|
|
}
|
|
|
|
qboolean IRC_ConsoleLink(void)
|
|
{
|
|
ircclient_t *irc;
|
|
char link[256];
|
|
char *who = NULL;
|
|
char *channel = NULL;
|
|
char what[256];
|
|
char whobuf[256];
|
|
char which[512];
|
|
enum iceproto_e type;
|
|
// cmdfuncs->Argv(0, text, sizeof(text));
|
|
cmdfuncs->Argv(1, link, sizeof(link));
|
|
cmdfuncs->Argv(2, which, sizeof(which));
|
|
|
|
Plug_Info_ValueForKey(link, "act", what, sizeof(what));
|
|
who = Plug_Info_ValueForKey(link, "who", whobuf, sizeof(whobuf));
|
|
|
|
for (irc = ircclients; irc; irc = irc->next)
|
|
{
|
|
if (!strncmp(irc->id, which, strlen(irc->id)))
|
|
{
|
|
channel = which + strlen(irc->id);
|
|
if (!*who)
|
|
who = channel;
|
|
break;
|
|
}
|
|
}
|
|
if (!irc || !who || !*what)
|
|
return false;
|
|
|
|
if (!strcmp(what, "reconnect"))
|
|
{
|
|
if (handleisvalid(irc->socket))
|
|
IRC_Printf(irc, channel, "Already %s.\n", irc->connecting?"reconnecting":"connected");
|
|
else if (IRC_Establish(irc))
|
|
IRC_Printf(irc, channel, "Reconnecting...\n");
|
|
else
|
|
IRC_Printf(irc, channel, "Unable to connect\n");
|
|
return true;
|
|
}
|
|
if (!*who)
|
|
return false; //that seems wrong. probably nothing to do with irc.
|
|
|
|
if (irc->tlsmode == TLS_STARTING || irc->connecting)
|
|
{
|
|
IRC_SetFooter(irc, channel, "Still connecting. Please wait.\n");
|
|
return true;
|
|
}
|
|
|
|
if (!strcmp(what, "iceaccept_v") || !strcmp(what, "iceaccept_s") || !strcmp(what, "iceaccept_c"))
|
|
{
|
|
switch(what[10])
|
|
{default:
|
|
case 'v': type = ICEP_VOICE; break;
|
|
case 's': type = ICEP_QWSERVER; break;
|
|
case 'c': type = ICEP_QWCLIENT; break;
|
|
}
|
|
IRC_Printf(irc, channel, "Accepting foo from %s\n", who);
|
|
IRC_ICE_Authorise(irc, who, type, true, channel);
|
|
return true;
|
|
}
|
|
else if (!strcmp(what, "icedecline_v") || !strcmp(what, "icedecline_s") || !strcmp(what, "icedecline_c"))
|
|
{
|
|
switch(what[11])
|
|
{default:
|
|
case 'v': type = ICEP_VOICE; break;
|
|
case 's': type = ICEP_QWSERVER; break;
|
|
case 'c': type = ICEP_QWCLIENT; break;
|
|
}
|
|
IRC_ICE_Authorise(irc, who, type, false, channel);
|
|
return true;
|
|
}
|
|
else if (!strcmp(what, "user"))
|
|
{
|
|
char links[2048];
|
|
char link[512];
|
|
Q_snprintf(links, sizeof(links), "%s:", who);
|
|
if (1)
|
|
{
|
|
Q_snprintf(link, sizeof(link), " ^[[Message]\\act\\msg\\who\\%s^]", who);
|
|
Q_strlcat(links, link, sizeof(links));
|
|
}
|
|
if (IRC_ICE_Find(irc, who, ICEP_VOICE))
|
|
{
|
|
Q_snprintf(link, sizeof(link), " ^[[Hang up]\\act\\icedecline_v\\who\\%s^]", who);
|
|
Q_strlcat(links, link, sizeof(links));
|
|
}
|
|
else
|
|
{
|
|
Q_snprintf(link, sizeof(link), " ^[[Call]\\act\\icestart_v\\who\\%s^]", who);
|
|
Q_strlcat(links, link, sizeof(links));
|
|
}
|
|
if (IRC_ICE_Find(irc, who, ICEP_QWSERVER))
|
|
{
|
|
Q_snprintf(link, sizeof(link), " ^[[Disconnect]\\act\\icedecline_s\\who\\%s^]", who);
|
|
Q_strlcat(links, link, sizeof(links));
|
|
}
|
|
else
|
|
{
|
|
Q_snprintf(link, sizeof(link), " ^[[Invite]\\act\\icestart_s\\who\\%s^]", who);
|
|
Q_strlcat(links, link, sizeof(links));
|
|
}
|
|
if (IRC_ICE_Find(irc, who, ICEP_QWCLIENT))
|
|
{
|
|
Q_snprintf(link, sizeof(link), " ^[[Disconnect]\\act\\icedecline_c\\who\\%s^]", who);
|
|
Q_strlcat(links, link, sizeof(links));
|
|
}
|
|
else
|
|
{
|
|
Q_snprintf(link, sizeof(link), " ^[[Gatecrash]\\act\\icestart_c\\who\\%s^]", who);
|
|
Q_strlcat(links, link, sizeof(links));
|
|
}
|
|
IRC_SetFooter(irc, channel, links);
|
|
return true;
|
|
}
|
|
else if (!strcmp(what, "msg"))
|
|
{
|
|
IRC_Printf(irc, who, "");
|
|
return true;
|
|
}
|
|
else if (!strcmp(what, "icestart_v") || !strcmp(what, "icestart_s") || !strcmp(what, "icestart_c"))
|
|
{
|
|
struct ircice_s *ice;
|
|
char *text;
|
|
char link[512];
|
|
switch(what[9])
|
|
{default:
|
|
case 'v': type = ICEP_VOICE; text = "Calling"; break;
|
|
case 's': type = ICEP_QWSERVER; text = "Inviting"; break;
|
|
case 'c': type = ICEP_QWCLIENT; text = "Gatecrashing"; break;
|
|
}
|
|
ice = IRC_ICE_Create(irc, who, type, true);
|
|
if (ice)
|
|
{
|
|
Q_snprintf(link, sizeof(link), "^["COLOURGREEN"%s\\act\\user^]", ice->peer);
|
|
IRC_ICE_Update(irc, ice, '+');
|
|
IRC_Printf(irc, ice->peer, "<%s %s ^[[Abort]\\act\\icedecline_%c\\who\\%s^]>\n", text, link, what[9], ice->peer);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//==================================================
|
|
|
|
static int IRC_ClientFrame(ircclient_t *irc)
|
|
{
|
|
char prefix[256];
|
|
int ret;
|
|
char *nextmsg, *msg;
|
|
char *temp;
|
|
char token[1024];
|
|
char var[9][1000];
|
|
|
|
int i = 1;
|
|
|
|
ret = netfuncs->Recv(irc->socket, irc->bufferedinmessage+irc->bufferedinammount, sizeof(irc->bufferedinmessage)-1 - irc->bufferedinammount);
|
|
if (ret == 0)
|
|
{
|
|
if (!irc->bufferedinammount) //if we are half way through a message, read any possible conjunctions.
|
|
return IRC_DONE; //remove
|
|
}
|
|
if (ret < 0)
|
|
return IRC_KILL;
|
|
|
|
if (ret>0)
|
|
irc->bufferedinammount+=ret;
|
|
irc->bufferedinmessage[irc->bufferedinammount] = '\0';
|
|
nextmsg = strstr(irc->bufferedinmessage, "\r\n");
|
|
if (!nextmsg)
|
|
return IRC_DONE;
|
|
|
|
*nextmsg = '\0';
|
|
nextmsg+=2;
|
|
|
|
msg = irc->bufferedinmessage;
|
|
|
|
strcpy(var[1],msg);
|
|
|
|
temp = strchr(var[1], ' ');
|
|
|
|
while (i < 8)
|
|
{
|
|
i++;
|
|
|
|
if (temp != NULL)
|
|
{
|
|
strcpy(var[i],temp+1);
|
|
}
|
|
else
|
|
{
|
|
strcpy(var[i], "");
|
|
}
|
|
|
|
temp=strchr(var[i], ' ');
|
|
|
|
}
|
|
|
|
IRC_CvarUpdate(); // is this the right place for it?
|
|
|
|
// if (irc_debug.value == 1) { IRC_Printf(irc, DEFAULTCONSOLE,COLOURRED "!!!!! ^11: %s ^22: %s ^33: %s ^44: %s ^55: %s ^66: %s ^77: %s ^88: %s\n",var[1],var[2],var[3],var[4],var[5],var[6],var[7],var[8]); }
|
|
if (irc_debug.value == 1) { IRC_Printf(irc, DEFAULTCONSOLE,COLOURRED "%s\n",var[1]); }
|
|
|
|
if (*msg == ':') //we need to strip off the prefix
|
|
{
|
|
char *sp = strchr(msg, ' ');
|
|
if (!sp)
|
|
{
|
|
IRC_Printf(irc, DEFAULTCONSOLE, "Ignoring bad message\n%s\n", msg);
|
|
memmove(irc->bufferedinmessage, nextmsg, irc->bufferedinammount - (msg-irc->bufferedinmessage));
|
|
irc->bufferedinammount-=nextmsg-irc->bufferedinmessage;
|
|
return IRC_CONTINUE;
|
|
}
|
|
|
|
if (sp-msg >= sizeof(prefix))
|
|
Q_strlcpy(prefix, msg+1, sizeof(prefix));
|
|
else
|
|
Q_strlcpy(prefix, msg+1, sp-msg);
|
|
|
|
msg = sp;
|
|
while(*msg == ' ')
|
|
msg++;
|
|
}
|
|
else
|
|
strcpy(prefix, irc->server);
|
|
|
|
if (!strncmp(var[1], "NOTICE AUTH ", 12))
|
|
{
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURGREEN "SERVER NOTICE: %s\n", var[3]+1);
|
|
}
|
|
else if (!strncmp(var[1], "PING ", 5))
|
|
{
|
|
IRC_AddClientMessage(irc, va("PONG %s", var[2]));
|
|
}
|
|
else if (!strncmp(var[2], "NOTICE ", 6))
|
|
{
|
|
char *exc = strchr(prefix, '!');
|
|
char *col = strchr(msg+6, ':');
|
|
char *end;
|
|
char *to = msg + 7;
|
|
char *etghack;
|
|
|
|
if (!strncmp(var[4]+1, "\1", 1))
|
|
{
|
|
char delimiters[] = "!";
|
|
char *username = strtok(var[1]+1, delimiters);
|
|
char *ctcpreplytype = strtok(var[4]+2, " ");
|
|
char *ctcpreply = var[5];
|
|
|
|
if (!strcmp(ctcpreplytype, "FTEICE"))
|
|
{
|
|
IRC_Printf(irc, username, "ICE from %s\n", username); //from client
|
|
IRC_ICE_Parse(irc, username, ctcpreply);
|
|
}
|
|
else
|
|
IRC_Printf(irc, DEFAULTCONSOLE,"<CTCP Reply> %s FROM %s: %s\n",ctcpreplytype,username,ctcpreply); // need to remove the last char on the end of ctcpreply
|
|
}
|
|
else if (exc && col)
|
|
{
|
|
*col = '\0';
|
|
col++;
|
|
|
|
while(*to <= ' ' && *to)
|
|
to++;
|
|
for (end = to + strlen(to)-1; end >= to && *end <= ' '; end--)
|
|
*end = '\0';
|
|
if (!strcmp(to, irc_nick.string))
|
|
to = prefix; //This was directed straight at us.
|
|
//So change the 'to', to the 'from'.
|
|
|
|
for (end = to; *end; end++)
|
|
{
|
|
if (*end >= 'A' && *end <= 'Z')
|
|
*end = *end + 'a' - 'A';
|
|
}
|
|
|
|
*exc = '\0';
|
|
if (!strncmp(col, "\001", 1))
|
|
{
|
|
end = strchr(col+1, '\001');
|
|
if (end)
|
|
*end = '\0';
|
|
if (!strncmp(col+1, "ACTION ", 7))
|
|
{
|
|
IRC_FilterMircColours(col+8);
|
|
IRC_Printf(irc, to, COLOURGREEN "***%s "COLORWHITE"%s\n", prefix, col+8); //from client
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IRC_FilterMircColours(col);
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURGREEN "NOTICE: -%s- %s\n", prefix, col); //from client
|
|
}
|
|
}
|
|
else
|
|
{
|
|
etghack = strtok(var[1],"\n");
|
|
|
|
if (!irc->connecting || IRC_WindowShown(irc, DEFAULTCONSOLE))
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURGREEN "SERVER NOTICE: <%s> %s\n", prefix, etghack);
|
|
|
|
// strcpy(servername,prefix);
|
|
|
|
while (1)
|
|
{
|
|
etghack = strtok(NULL, "\n");
|
|
|
|
if (etghack == NULL)
|
|
break;
|
|
|
|
magic_etghack(etghack);
|
|
|
|
if (atoi(subvar[2]) != 0)
|
|
numbered_command(atoi(subvar[2]), etghack, irc);
|
|
else
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURGREEN "SERVER NOTICE: <%s> %s\n", prefix, subvar[4]);
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
else if (!strncmp(var[2], "PRIVMSG ", 7)) //no autoresponses to notice please, and any autoresponses should be in the form of a notice
|
|
{
|
|
char *exc = strchr(prefix, '!');
|
|
char *col = strchr(msg+6, ':');
|
|
char *end;
|
|
char *to = msg + 7;
|
|
|
|
//message takes the form :FROM PRIVMSG TO :MESSAGE
|
|
|
|
if (drawfuncs)
|
|
drawfuncs->LocalSound ("misc/talk.wav", 256, 1);
|
|
|
|
if ((!strcasecmp(var[4]+1, "\1VERSION\1")) && (!strncmp(var[2], "PRIVMSG ", 7)))
|
|
{
|
|
char *username;
|
|
char delimiters[] = "!";
|
|
|
|
username = strtok(var[1]+1, delimiters);
|
|
|
|
IRC_AddClientMessage(irc, va("NOTICE %s :\1VERSION FTEQW-IRC-Plugin Release: %s", username, RELEASE));
|
|
}
|
|
else if ((!strcasecmp(var[4]+1, "\1TIME\1")) && (!strncmp(var[2], "PRIVMSG ", 7)))
|
|
{
|
|
char delimiters[] = "!";
|
|
char *username = strtok(var[1], delimiters);
|
|
time_t t;
|
|
const struct tm *tm;
|
|
char buffer[100];
|
|
|
|
time(&t);
|
|
tm=localtime(&t);
|
|
|
|
strftime (buffer, 100, "%a %b %d %H:%M:%S", tm);
|
|
|
|
IRC_AddClientMessage(irc, va("NOTICE %s :\1TIME %s\1", username, buffer));
|
|
}
|
|
else if (exc && col)
|
|
{
|
|
char link[256];
|
|
*col = '\0';
|
|
col++;
|
|
|
|
while(*to <= ' ' && *to)
|
|
to++;
|
|
for (end = to + strlen(to)-1; end >= to && *end <= ' '; end--)
|
|
*end = '\0';
|
|
if (!strcmp(to, irc->nick))
|
|
to = prefix; //This was directed straight at us.
|
|
//So change the 'to', to the 'from'.
|
|
|
|
for (end = to; *end; end++)
|
|
{
|
|
if (*end >= 'A' && *end <= 'Z')
|
|
*end = *end + 'a' - 'A';
|
|
}
|
|
|
|
*exc = '\0';
|
|
|
|
//a link to interact with the sender
|
|
if (Q_snprintfz(link, sizeof(link), "^["COLOURGREEN"%s\\act\\user\\who\\%s^]", prefix, prefix))
|
|
Q_snprintf(link, sizeof(link), "%s", prefix);
|
|
|
|
if (!strncmp(col, "\001", 1))
|
|
{
|
|
end = strchr(col+1, '\001');
|
|
if (end)
|
|
*end = '\0';
|
|
if (!strncmp(col+1, "ACTION ", 7))
|
|
{
|
|
IRC_FilterMircColours(col+8);
|
|
IRC_Printf(irc, to, "***%s %s\n", link, col+8); //from client
|
|
}
|
|
else if (!strncmp(col+1, "PING ", 5))
|
|
{
|
|
time_t currentseconds;
|
|
|
|
currentseconds = time (NULL);
|
|
|
|
IRC_Printf(irc, to, "CTCP Ping from %s\n", link); //from client
|
|
IRC_AddClientMessage(irc, va("NOTICE %s :\001PING %u\001\r\n", prefix, (unsigned int)currentseconds));
|
|
}
|
|
else if (!strncmp(col+1, "VERSION ", 8))
|
|
{
|
|
IRC_Printf(irc, to, "CTCP Version from %s\n", link); //from client
|
|
IRC_AddClientMessage(irc, va("NOTICE %s :\001VERSION "FULLENGINENAME" "RELEASE" \001\r\n", prefix));
|
|
}
|
|
else if (!strncmp(col+1, "FTEICE ", 7))
|
|
{
|
|
IRC_Printf(irc, to, "ICE from %s\n", link); //from client
|
|
IRC_ICE_Parse(irc, to, col+8);
|
|
}
|
|
else
|
|
{
|
|
if (end)//put it back on. might as well.
|
|
*end = '\001';
|
|
IRC_Printf(irc, to, "%s: %s\n", link, col); //from client
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IRC_FilterMircColours(col);
|
|
IRC_Printf(irc, to, "%s: %s\n", link, col); //from client
|
|
}
|
|
}
|
|
else IRC_Printf(irc, DEFAULTCONSOLE, COLOURGREEN "SERVER: <%s> %s\n", prefix, msg); //direct server message
|
|
}
|
|
else if (!strncmp(var[2], "MODE ", 5))
|
|
{
|
|
char *username = strtok(var[1]+1, "! ");
|
|
char *mode = strtok(var[4], " ");
|
|
char *target = strtok(var[5], " ");
|
|
char channel[100];
|
|
|
|
if (!strncmp(var[3], "#", 1))
|
|
{
|
|
strcpy(channel,strtok(var[3], " "));
|
|
}
|
|
else
|
|
{
|
|
strcpy(channel,DEFAULTCONSOLE);
|
|
}
|
|
|
|
if ((!strncmp(mode+1,"o", 1)) || (!strncmp(mode+1,"v",1))) // ops or voice
|
|
{
|
|
IRC_Printf(irc, channel,COLOURGREEN "%s sets mode %s on %s\n",username,mode,target);
|
|
}
|
|
else
|
|
{
|
|
if (IRC_WindowShown(irc, channel))
|
|
IRC_Printf(irc, channel, COLOURGREEN "%s sets mode %s\n",username,mode);
|
|
}
|
|
|
|
}
|
|
else if (!strncmp(var[2], "KICK ", 5))
|
|
{
|
|
char *username = strtok(var[1]+1, "!");
|
|
char *channel = strtok(var[3], " ");
|
|
char *target = strtok(var[4], " ");
|
|
char *reason = var[5]+1;
|
|
|
|
IRC_Printf(irc, channel,COLOURGREEN "%s was kicked from %s Reason: '%s' by %s\n",target,channel,reason,username);
|
|
}
|
|
else if (!strncmp(msg, "NICK ", 5))
|
|
{
|
|
char *exc = strchr(prefix, '!');
|
|
char *col = strchr(msg+5, ':');
|
|
if (exc && col)
|
|
{
|
|
*exc = '\0';
|
|
//fixme: print this in all channels as appropriate.
|
|
IRC_Printf(irc, DEFAULTCONSOLE, COLOURGREEN "%s changes name to %s\n", prefix, col+1);
|
|
if (confuncs)
|
|
{
|
|
char oldname[256];
|
|
char newname[256];
|
|
Q_snprintf(oldname, sizeof(oldname), irc->id, prefix);
|
|
Q_snprintf(newname, sizeof(newname), irc->id, col+1);
|
|
confuncs->RenameSub(oldname, newname); //if we were pming to them, rename accordingly.
|
|
}
|
|
}
|
|
else IRC_Printf(irc, DEFAULTCONSOLE, COLOURGREEN ":%s%s\n", prefix, msg+6);
|
|
}
|
|
else if (!strncmp(msg, "QUIT ", 5))
|
|
{
|
|
/*char *exc = strchr(prefix, '!');
|
|
char *col = strchr(msg+5, ':');
|
|
if (exc && col)
|
|
{
|
|
*exc = '\0';
|
|
IRC_Printf(irc, col+1, COLOURGREEN "%s joins channel %s\n", prefix, col+1);
|
|
}
|
|
else IRC_Printf(irc, DEFAULTCONSOLE, COLOURGREEN ":%s QUIT %s\n", prefix, msg+5);*/
|
|
}
|
|
else if (!strncmp(msg, "PART ", 5))
|
|
{
|
|
char *exc = strchr(prefix, '!');
|
|
COM_Parse(msg+5, token, sizeof(token));
|
|
if (exc)
|
|
{
|
|
*exc = '\0';
|
|
IRC_Printf(irc, token, "%s leaves channel %s\n", prefix, token);
|
|
}
|
|
else IRC_Printf(irc, DEFAULTCONSOLE, COLOURGREEN ":%sPART %s\n", prefix, msg+5);
|
|
}
|
|
else if (!strncmp(msg, "JOIN ", 5))
|
|
{
|
|
char *exc = strchr(prefix, '!');
|
|
char *col = strchr(msg+5, ':');
|
|
if (exc && col)
|
|
{
|
|
*exc = '\0';
|
|
IRC_Printf(irc, col+1, COLOURGREEN "%s joins channel %s\n", prefix, col+1);
|
|
}
|
|
else IRC_Printf(irc, DEFAULTCONSOLE, COLOURGREEN ":%s JOIN %s\n", prefix, msg+5);
|
|
}
|
|
else if (!strncmp(msg, "372 ", 4))
|
|
{
|
|
char *text = strstr(msg, ":-");
|
|
if (!*irc->autochannels || irc_motd.value)
|
|
{
|
|
if (text)
|
|
IRC_Printf(irc, DEFAULTCONSOLE, "%s\n", text+2);
|
|
else
|
|
IRC_Printf(irc, DEFAULTCONSOLE, "%s\n", msg);
|
|
}
|
|
}
|
|
else if (!strncmp(msg, "TOPIC ", 5))
|
|
{
|
|
char *topic = COM_Parse(msg+5, token, sizeof(token));
|
|
while (*topic == ' ')
|
|
topic++;
|
|
if (*topic++ == ':')
|
|
{
|
|
char *exc = strchr(prefix, '!');
|
|
if (exc)
|
|
*exc = 0;
|
|
IRC_Printf(irc, token, COLOURGREEN "%s changes topic to %s\n", prefix, topic);
|
|
}
|
|
else IRC_Printf(irc, DEFAULTCONSOLE, COLOURGREEN ":%s TOPIC %s\n", prefix, msg+5);
|
|
}
|
|
else if (!strncmp(msg, "331 ", 4) ||//no topic
|
|
!strncmp(msg, "332 ", 4)) //the topic
|
|
{
|
|
char *topic;
|
|
char *chan;
|
|
topic = COM_Parse(msg, token, sizeof(token));
|
|
topic = COM_Parse(topic, token, sizeof(token));
|
|
topic = COM_Parse(topic, token, sizeof(token));
|
|
while(*topic == ' ')
|
|
topic++;
|
|
if (*topic == ':')
|
|
{
|
|
topic++;
|
|
chan = token;
|
|
}
|
|
else
|
|
{
|
|
topic = "No topic";
|
|
chan = DEFAULTCONSOLE;
|
|
}
|
|
|
|
IRC_Printf(irc, chan, "Topic on channel %s is: "COLOURGREEN"%s\n", chan, topic);
|
|
}
|
|
else if (!strncmp(msg, "353 ", 4)) //the names of people on a channel
|
|
{
|
|
char *eq = strstr(msg, "="); // BAD SPIKE!! = is normal channel :(
|
|
char *eq2 = strstr(msg, "@"); // @ means the channel is +s (secret)
|
|
char *eq3 = strstr(msg, "*"); // * means the channel is +p (private) rather redundant...
|
|
char *channeltype = strtok(var[4], " ");
|
|
char *channel = strtok(var[5], " ");
|
|
char *str;
|
|
|
|
|
|
int secret = 0;
|
|
int privatechan = 0;
|
|
if ( !strcmp(channeltype,"=") )
|
|
{
|
|
char *end;
|
|
eq++;
|
|
str = strstr(eq, ":");
|
|
while(*eq == ' ')
|
|
eq++;
|
|
for (end = eq; *end>' '&&*end !=':'; end++)
|
|
;
|
|
*end = '\0';
|
|
str++;
|
|
}
|
|
//else if (eq2)
|
|
else if ( !strcmp(channeltype,"@") )
|
|
{
|
|
char *end;
|
|
|
|
secret = 1;
|
|
|
|
eq2++;
|
|
str = strstr(eq2, ":");
|
|
while(*eq2 == ' ')
|
|
eq2++;
|
|
for (end = eq2; *end>' '&&*end !=':'; end++)
|
|
;
|
|
*end = '\0';
|
|
str++;
|
|
}
|
|
else if ( !strcmp(channeltype,"*") )
|
|
{
|
|
char *end;
|
|
|
|
privatechan = 1;
|
|
|
|
eq3++;
|
|
str = strstr(eq3, ":");
|
|
while(*eq3 == ' ')
|
|
eq3++;
|
|
for (end = eq3; *end>' '&&*end !=':'; end++)
|
|
;
|
|
*end = '\0';
|
|
str++;
|
|
}
|
|
else
|
|
{
|
|
eq = "Corrupted_Message";
|
|
str = NULL;
|
|
}
|
|
IRC_Printf(irc, channel, "Users on channel %s:\n", channel);
|
|
while (str)
|
|
{
|
|
str = COM_Parse(str, token, sizeof(token));
|
|
if (*token == '@') //they're an operator
|
|
IRC_Printf(irc, channel, "^[@"COLOURGREEN"%s\\act\\user\\who\\%s\\tip\\Channel Operator^]\n", token+1, token+1);
|
|
else if (*token == '%') //they've got half-op
|
|
IRC_Printf(irc, channel, "^[%%"COLOURGREEN"%s\\act\\user\\who\\%s\\tip\\Channel Half-Operator^]\n", token+1, token+1);
|
|
else if (*token == '+') //they've got voice
|
|
IRC_Printf(irc, channel, "^[+"COLOURGREEN"%s\\act\\user\\who\\%s\\tip\\Voice^]\n", token+1, token+1);
|
|
else
|
|
IRC_Printf(irc, channel, " ^["COLOURGREEN"%s\\act\\user\\who\\%s^]\n", token, token);
|
|
}
|
|
if (secret == 1)
|
|
{
|
|
IRC_Printf(irc, channel, "%s is secret (+s)\n",channel);
|
|
}
|
|
else if (privatechan == 1)
|
|
{
|
|
IRC_Printf(irc, channel, "%s is private (+p)\n",channel);
|
|
}
|
|
|
|
}
|
|
// would be great to convert the above to work better
|
|
else if (atoi(var[2]) != 0)
|
|
{
|
|
// char *rawparameter = strtok(var[4], " ");
|
|
// char *rawmessage = var[5];
|
|
// char *wholerawmessage = var[4];
|
|
|
|
numbered_command(atoi(var[2]), msg, irc);
|
|
|
|
IRC_CvarUpdate();
|
|
|
|
if (irc_debug.value == 1) { IRC_Printf(irc, DEFAULTCONSOLE, "%s\n", msg); }
|
|
}
|
|
else
|
|
IRC_Printf(irc, DEFAULTCONSOLE, "%s\n", msg);
|
|
|
|
memmove(irc->bufferedinmessage, nextmsg, irc->bufferedinammount - (msg-irc->bufferedinmessage));
|
|
irc->bufferedinammount-=nextmsg-irc->bufferedinmessage;
|
|
return IRC_CONTINUE;
|
|
}
|
|
|
|
//functions above this line allow connections to multiple servers.
|
|
//it is just the control functions that only allow one server.
|
|
|
|
void IRC_Frame(double realtime, double gametime)
|
|
{
|
|
ircclient_t *ircclient;
|
|
if (reloadconfig)
|
|
{
|
|
reloadconfig = false;
|
|
IRC_ParseConfig();
|
|
}
|
|
for (ircclient = ircclients; ircclient; ircclient = ircclient->next)
|
|
{
|
|
int stat = IRC_CONTINUE;
|
|
if (!handleisvalid(ircclient->socket))
|
|
continue; //this connection isn't enabled.
|
|
while(stat == IRC_CONTINUE)
|
|
{
|
|
stat = IRC_ClientFrame(ircclient);
|
|
if (ircclient->bufferedoutammount)
|
|
{
|
|
int flushed = netfuncs->Send(ircclient->socket, ircclient->bufferedoutmessage, ircclient->bufferedoutammount); //FIXME: This needs rewriting to cope with errors+throttle.
|
|
if (flushed > 0)
|
|
{
|
|
memmove(ircclient->bufferedoutmessage, ircclient->bufferedoutmessage+flushed, ircclient->bufferedoutammount - flushed);
|
|
ircclient->bufferedoutammount -= flushed;
|
|
}
|
|
}
|
|
}
|
|
if (ircclient->quitting && !ircclient->bufferedoutammount)
|
|
stat = IRC_KILL;
|
|
if (stat == IRC_KILL)
|
|
{
|
|
netfuncs->Close(ircclient->socket);
|
|
ircclient->socket = invalid_handle;
|
|
IRC_Printf(ircclient, DEFAULTCONSOLE, "Disconnected from irc\n^[[Reconnect]\\act\\reconnect^]\n");
|
|
break; //lazy
|
|
}
|
|
else
|
|
IRC_ICE_Frame(ircclient);
|
|
}
|
|
}
|
|
|
|
void IRC_Command(ircclient_t *ircclient, char *dest, char *args)
|
|
{
|
|
char token[1024];
|
|
char *msg;
|
|
|
|
msg = COM_Parse(args, token, sizeof(token));
|
|
|
|
if (*token == '/')
|
|
{
|
|
if (!strcmp(token+1, "server"))
|
|
{ //selects the default server without connecting anywhere, for main console to use.
|
|
msg = COM_Parse(msg, token, sizeof(token));
|
|
|
|
ircclient = IRC_FindAccount(token);
|
|
if (!ircclient)
|
|
IRC_Printf(ircclient, dest, "No such connection\n");
|
|
else if (ircclients == ircclient)
|
|
IRC_Printf(ircclient, dest, "Connection is already the default.\n");
|
|
else
|
|
{
|
|
IRC_MakeDefault(ircclient);
|
|
IRC_Printf(ircclient, dest, "Connection is now default.\n");
|
|
}
|
|
}
|
|
else if (!strcmp(token+1, "open") || !strcmp(token+1, "connect"))
|
|
{
|
|
char server[256];
|
|
char channels[1024];
|
|
char nick[256];
|
|
char password[256];
|
|
|
|
msg = COM_Parse(msg, server, sizeof(server));
|
|
msg = COM_Parse(msg, channels, sizeof(channels));
|
|
msg = COM_Parse(msg, nick, sizeof(nick));
|
|
msg = COM_Parse(msg, password, sizeof(password));
|
|
|
|
//set up some defaults
|
|
if (!*nick)
|
|
Q_strlcpy(nick, irc_nick.string, sizeof(nick));
|
|
if (!*nick)
|
|
cvarfuncs->GetString("name", nick, sizeof(nick));
|
|
|
|
ircclient = IRC_FindAccount(server);
|
|
if (ircclient)
|
|
{
|
|
if (handleisvalid(ircclient->socket)) //don't need to do anything.
|
|
{
|
|
IRC_Printf(ircclient, dest, "IRC connection to %s already registered\n", server);
|
|
return; //silently ignore it if the account already exists
|
|
}
|
|
}
|
|
else
|
|
ircclient = IRC_Create(server, nick, irc_realname.string, irc_hostname.string, irc_username.string, password, channels);
|
|
if (ircclient)
|
|
{
|
|
IRC_MakeDefault(ircclient);
|
|
ircclient->persist |= !strcmp(token+1, "connect");
|
|
if (IRC_Establish(ircclient))
|
|
IRC_Printf(ircclient, dest, "Trying to connect\n");
|
|
else
|
|
IRC_Printf(ircclient, dest, "Unable to connect\n");
|
|
}
|
|
else
|
|
IRC_Printf(ircclient, dest, "Unable to open account\n");
|
|
|
|
IRC_WriteConfig();
|
|
}
|
|
else if (!strcmp(token+1, "help"))
|
|
{
|
|
IRC_Printf(ircclient, dest, "to connect to a server: /connect SERVER \"#chan #chan2,chan2password\" NICK SERVERPASSWORD\n");
|
|
IRC_Printf(ircclient, dest, "to disconnect from a server: /quit\n");
|
|
IRC_Printf(ircclient, dest, "to join a channel: /join\n");
|
|
IRC_Printf(ircclient, dest, "to leave a channel: /part\n");
|
|
IRC_Printf(ircclient, dest, "note that servers and channels will be remembered\n");
|
|
}
|
|
else if (!strcmp(token+1, "nick"))
|
|
{
|
|
msg = COM_Parse(msg, token, sizeof(token));
|
|
if (!ircclient) //not yet connected.
|
|
cvarfuncs->SetString(irc_nick.name, token);
|
|
else
|
|
{
|
|
if (!handleisvalid(ircclient->socket))
|
|
Q_strlcpy(ircclient->primarynick, token, sizeof(ircclient->primarynick));
|
|
ircclient->nicktries = 0;
|
|
IRC_SetNick(ircclient, token);
|
|
}
|
|
|
|
IRC_WriteConfig();
|
|
}
|
|
else if (!strcmp(token+1, "user"))
|
|
{
|
|
msg = COM_Parse(msg, token, sizeof(token));
|
|
cvarfuncs->SetString(irc_username.name, token);
|
|
if (ircclient)
|
|
IRC_SetUser(ircclient, token);
|
|
|
|
IRC_WriteConfig();
|
|
}
|
|
else if (!strcmp(token+1, "info") || !strcmp(token+1, "status"))
|
|
{
|
|
ircclient_t *e;
|
|
struct ircice_s *ice;
|
|
for (e = ircclients; e; e = e->next)
|
|
{
|
|
IRC_Printf(ircclient, dest, "SERVER: ^[%s\\type\\irc /server \"%s\"^]\n", e->server, e->server);
|
|
if (e->connecting && handleisvalid(e->socket))
|
|
IRC_Printf(ircclient, dest, "<CONNECTING>\n");
|
|
else if (handleisvalid(e->socket))
|
|
IRC_Printf(ircclient, dest, "<CONNECTED>\n");
|
|
else
|
|
IRC_Printf(ircclient, dest, "<DISCONNECTED>\n");
|
|
if (e->quitting)
|
|
IRC_Printf(ircclient, dest, "<QUITTING>\n");
|
|
switch(e->tlsmode)
|
|
{
|
|
default:
|
|
case TLS_OFF:
|
|
IRC_Printf(ircclient, dest, "TLS: insecure\n");
|
|
break;
|
|
case TLS_INITIAL:
|
|
IRC_Printf(ircclient, dest, "TLS: initial\n");
|
|
break;
|
|
case TLS_START:
|
|
case TLS_STARTING:
|
|
IRC_Printf(ircclient, dest, "TLS: upgrade\n");
|
|
break;
|
|
}
|
|
IRC_Printf(ircclient, dest, "nick: %s\n", e->nick);
|
|
IRC_Printf(ircclient, dest, "realname: %s\n", e->realname);
|
|
IRC_Printf(ircclient, dest, "hostname: %s\n", e->hostname);
|
|
IRC_Printf(ircclient, dest, "rejoin: %s\n", *e->autochannels?e->autochannels:"<no channels>");
|
|
IRC_Printf(ircclient, dest, "default dest: %s\n", e->defaultdest);
|
|
for (ice = e->ice; ice; ice = ice->next)
|
|
{
|
|
char *allowed=ice->allowed?" allowed":" not-allowed";
|
|
char *accepted=ice->accepted?" accepted":" not-accepted";
|
|
switch(ice->type)
|
|
{
|
|
default:
|
|
case ICEP_INVALID:
|
|
IRC_Printf(ircclient, dest, " <INVALID ICE>\n");
|
|
break;
|
|
case ICEP_QWSERVER:
|
|
IRC_Printf(ircclient, dest, " server: \"%s\"%s%s\n", ice->peer, allowed, accepted);
|
|
break;
|
|
case ICEP_QWCLIENT:
|
|
IRC_Printf(ircclient, dest, " client: \"%s\"%s%s\n", ice->peer, allowed, accepted);
|
|
break;
|
|
case ICEP_VOICE:
|
|
IRC_Printf(ircclient, dest, " voice: \"%s\"%s%s\n", ice->peer, allowed, accepted);
|
|
break;
|
|
case ICEP_VIDEO:
|
|
IRC_Printf(ircclient, dest, " voice: \"%s\"%s%s\n", ice->peer, allowed, accepted);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (!ircclient)
|
|
{
|
|
IRC_Printf(ircclient, dest, "Not connected, please connect to an irc server first.\n");
|
|
}
|
|
|
|
//ALL other commands require you to be connected.
|
|
else if (!strcmp(token+1, "list"))
|
|
{
|
|
IRC_AddClientMessage(ircclient, "LIST");
|
|
}
|
|
else if ( !strcmp(token+1, "join") || !strcmp(token+1, "j") )
|
|
{
|
|
char chan[256];
|
|
char pwd[256];
|
|
|
|
if (ircclient->tlsmode == TLS_STARTING || ircclient->connecting)
|
|
{
|
|
IRC_Printf(ircclient, dest, "Still connecting. Please wait.\n");
|
|
return;
|
|
}
|
|
|
|
msg = COM_Parse(msg, chan, sizeof(chan));
|
|
msg = COM_Parse(msg, pwd, sizeof(pwd));
|
|
|
|
IRC_JoinChannel(ircclient,chan,pwd);
|
|
IRC_WriteConfig();
|
|
}
|
|
else if (!strcmp(token+1, "part") || !strcmp(token+1, "leave")) // need to implement leave reason
|
|
{
|
|
msg = COM_Parse(msg, token, sizeof(token));
|
|
IRC_PartChannel(ircclient, *token?token:dest);
|
|
IRC_WriteConfig();
|
|
}
|
|
else if (!strcmp(token+1, "call"))
|
|
{
|
|
msg = COM_Parse(msg, token, sizeof(token));
|
|
if (ircclient->tlsmode == TLS_STARTING || ircclient->connecting)
|
|
{
|
|
IRC_Printf(ircclient, dest, "Still connecting. Please wait.\n");
|
|
return;
|
|
}
|
|
{
|
|
struct ircice_s *ice = IRC_ICE_Create(ircclient, *token?token:dest, ICEP_VOICE, true);
|
|
if (ice)
|
|
{
|
|
IRC_ICE_Update(ircclient, ice, '+');
|
|
IRC_Printf(ircclient, ice->peer, "<Calling %s>\n", ice->peer);
|
|
}
|
|
}
|
|
}
|
|
else if (!strcmp(token+1, "ginvite"))
|
|
{
|
|
msg = COM_Parse(msg, token, sizeof(token));
|
|
if (ircclient->tlsmode == TLS_STARTING || ircclient->connecting)
|
|
{
|
|
IRC_Printf(ircclient, dest, "Still connecting. Please wait.\n");
|
|
return;
|
|
}
|
|
{
|
|
struct ircice_s *ice = IRC_ICE_Create(ircclient, *token?token:dest, ICEP_QWSERVER, true);
|
|
if (ice)
|
|
{
|
|
IRC_ICE_Update(ircclient, ice, '+');
|
|
IRC_Printf(ircclient, ice->peer, "<inviting %s>\n", ice->peer);
|
|
}
|
|
}
|
|
}
|
|
else if (!strcmp(token+1, "gatecrash"))
|
|
{
|
|
msg = COM_Parse(msg, token, sizeof(token));
|
|
if (ircclient->tlsmode == TLS_STARTING || ircclient->connecting)
|
|
{
|
|
IRC_Printf(ircclient, dest, "Still connecting. Please wait.\n");
|
|
return;
|
|
}
|
|
{
|
|
struct ircice_s *ice = IRC_ICE_Create(ircclient, *token?token:dest, ICEP_QWCLIENT, true);
|
|
if (ice)
|
|
{
|
|
IRC_ICE_Update(ircclient, ice, '+');
|
|
IRC_Printf(ircclient, ice->peer, "<gatecrashing %s>\n", ice->peer);
|
|
}
|
|
}
|
|
}
|
|
else if (!strcmp(token+1, "msg"))
|
|
{
|
|
msg = COM_Parse(msg, token, sizeof(token));
|
|
if (!msg)
|
|
return;
|
|
if (ircclient->tlsmode == TLS_STARTING || ircclient->connecting)
|
|
{
|
|
IRC_Printf(ircclient, dest, "Still connecting. Please wait.\n");
|
|
return;
|
|
}
|
|
IRC_AddClientMessage(ircclient, va("PRIVMSG %s :%s", token, msg+1));
|
|
IRC_Printf(ircclient, token, "%s: %s\n", ircclient->nick, msg);
|
|
}
|
|
else if (!strcmp(token+1, "quote") || !strcmp(token+1, "raw"))
|
|
{
|
|
IRC_AddClientMessage(ircclient, va("%s", msg));
|
|
}
|
|
else if (!strcmp(token+1, "reconnect"))
|
|
{
|
|
if (IRC_Establish(ircclient))
|
|
IRC_Printf(ircclient, dest, "Trying to connect\n");
|
|
else
|
|
IRC_Printf(ircclient, dest, "Unable to connect\n");
|
|
}
|
|
else if (!strcmp(token+1, "quit") || !strcmp(token+1, "disconnect"))
|
|
{
|
|
msg = COM_Parse(msg, token, sizeof(token));
|
|
if (*token)
|
|
IRC_AddClientMessage(ircclient, va("QUIT :%s", token));
|
|
else
|
|
IRC_AddClientMessage(ircclient, va("QUIT :%s", irc_quitmessage.string));
|
|
ircclient->quitting = true;
|
|
|
|
IRC_WriteConfig();
|
|
}
|
|
else if (!strcmp(token+1, "whois"))
|
|
{
|
|
msg = COM_Parse(msg, token, sizeof(token));
|
|
IRC_AddClientMessage(ircclient, va("WHOIS :%s",token));
|
|
}
|
|
else if (!strcmp(token+1, "away"))
|
|
{
|
|
if ( strlen(msg) > 1 )
|
|
IRC_AddClientMessage(ircclient, va("AWAY :%s",msg+1));
|
|
else
|
|
IRC_AddClientMessage(ircclient, va("AWAY :"));
|
|
}
|
|
else if (!strcmp(token+1, "motd"))
|
|
{
|
|
IRC_AddClientMessage(ircclient, "MOTD");
|
|
}
|
|
else if (!strcmp(token+1, "ctcp"))
|
|
{
|
|
msg = COM_Parse(msg, token, sizeof(token));
|
|
IRC_AddClientMessage(ircclient, va("PRIVMSG %s :\1%s\1",token,msg+1));
|
|
}
|
|
else if (!strcmp(token+1, "dest"))
|
|
{
|
|
msg = COM_Parse(msg, token, sizeof(token));
|
|
Q_strlcpy(ircclient->defaultdest, token, sizeof(ircclient->defaultdest));
|
|
}
|
|
else if (!strcmp(token+1, "ping"))
|
|
{
|
|
if (!*dest)
|
|
IRC_Printf(ircclient, DEFAULTCONSOLE, "No channel joined. Try /join #<channel>\n");
|
|
else
|
|
IRC_AddClientMessage(ircclient, va("PRIVMSG %s :\001PING%s\001", dest, msg));
|
|
}
|
|
else if (!strcmp(token+1, "notice"))
|
|
{
|
|
msg = COM_Parse(msg, token, sizeof(token));
|
|
IRC_AddClientMessage(ircclient, va("NOTICE %s :%s",token, msg+1));
|
|
}
|
|
else if (!strcmp(token+1, "me"))
|
|
{
|
|
if (!*dest)
|
|
IRC_Printf(ircclient, DEFAULTCONSOLE, "No channel joined. Try /join #<channel>\n");
|
|
else
|
|
{
|
|
if(*msg <= ' ' && *msg)
|
|
msg++;
|
|
IRC_AddClientMessage(ircclient, va("PRIVMSG %s :\001ACTION %s\001", dest, msg));
|
|
IRC_Printf(ircclient, dest, "***^3%s^7 %s\n", ircclient->nick, msg);
|
|
}
|
|
}
|
|
else if (!strcmp(token+1, "topic"))
|
|
{
|
|
if (!*dest)
|
|
IRC_Printf(ircclient, DEFAULTCONSOLE, "No channel joined. Try /join #<channel>\n");
|
|
else
|
|
{
|
|
if(*msg <= ' ' && *msg)
|
|
msg++;
|
|
IRC_AddClientMessage(ircclient, va("TOPIC %s :%s", dest, msg));
|
|
}
|
|
}
|
|
else
|
|
IRC_Printf(ircclient, dest, "Command not recognised\n");
|
|
}
|
|
else
|
|
{
|
|
if (ircclient)
|
|
{
|
|
if (!handleisvalid(ircclient->socket))
|
|
IRC_Printf(ircclient, dest, "Connection was closed. use /reconnect\n");
|
|
else if (ircclient->tlsmode == TLS_STARTING || ircclient->connecting)
|
|
IRC_Printf(ircclient, dest, "Still connecting. Please wait.\n");
|
|
else if (!*dest)
|
|
{
|
|
IRC_Printf(ircclient, dest, "No channel joined. Try /join #<channel>\n");
|
|
}
|
|
else
|
|
{
|
|
msg = args;
|
|
while (*msg == ' ')
|
|
msg++;
|
|
if (!*msg)
|
|
return; //this is apparently an error. certainly wasteful.
|
|
IRC_AddClientMessage(ircclient, va("PRIVMSG %s :%s", dest, msg));
|
|
IRC_Printf(ircclient, dest, "^3%s^7: %s\n", ircclient->nick, msg);
|
|
}
|
|
}
|
|
else
|
|
IRC_Printf(ircclient, "Not connected\ntype \"%s /open IRCSERVER [#channel1[,#channel2[,...]]] [nick]\" to connect\n", COMMANDNAME);
|
|
}
|
|
}
|