philippelh/bitchx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Seeding from the 1.2 tree.

Browse Source
This commit is contained in:
Dan Mashal
2013-01-01 03:00:55 -08:00
parent d8c87c4ded
commit 87b806a563
1424 changed files with 260320 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

869
dll/aim/toc/toc.c Normal file
View File

@@ -0,0 +1,869 @@
/*
* gaim
*
* Copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*
*/
/*
* Heavily modified by Nadeem Riaz (nads@bleh.org)
* for use in libtoc
*/
#include <netdb.h>
#include <unistd.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <sys/socket.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "toc.h"
/* descriptor for talking to TOC */
static int toc_fd;
static int seqno;
static unsigned int peer_ver=0;
int state;
/* static int inpa=-1; */
int permdeny = PERMIT_PERMITALL;
int toc_login(char *username, char *password)
{
char *config;
struct in_addr *sin;
char buf[80];
char buf2[2048];
toc_debug_printf("looking up host! %s", aim_host);
sin = (struct in_addr *)get_address(aim_host);
if (!sin) {
set_state(STATE_OFFLINE);
toc_msg_printf(TOC_CONNECT_MSGS,"Unable to lookup %s", aim_host);
return -1;
}
snprintf(toc_addy, sizeof(toc_addy), "%s", inet_ntoa(*sin));
snprintf(buf, sizeof(buf), "Connecting to %s", inet_ntoa(*sin));
toc_msg_printf(TOC_CONNECT_MSGS,"%s",buf);
toc_fd = connect_address(sin->s_addr, aim_port);
if (toc_fd < 0) {
set_state(STATE_OFFLINE);
toc_msg_printf(TOC_CONNECT_MSGS,"Connect to %s failed", inet_ntoa(*sin));
return -1;
}
free(sin);
toc_msg_printf(TOC_CONNECT_MSGS,"Signon: %s",username);
if (toc_signon(username, password) < 0) {
set_state(STATE_OFFLINE);
toc_msg_printf(TOC_CONNECT_MSGS,"Disconnected.");
return -1;
}
toc_msg_printf(TOC_CONNECT_MSGS,"Waiting for reply...");
if (toc_wait_signon() < 0) {
set_state(STATE_OFFLINE);
toc_msg_printf(TOC_CONNECT_MSGS,"Authentication Failed");
return -1;
}
snprintf(aim_username, sizeof(aim_username), "%s", username);
snprintf(aim_password, sizeof(aim_password), "%s", password);
save_prefs();
toc_msg_printf(TOC_CONNECT_MSGS,"Retrieving config...");
if ((config=toc_wait_config()) == NULL) {
toc_msg_printf(TOC_CONNECT_MSGS,"No Configuration\n");
set_state(STATE_OFFLINE);
return -1;
}
init_lists();
/* gtk_widget_hide(mainwindow);
show_buddy_list(); */
parse_toc_buddy_list(config);
/* refresh_buddy_window(); */
snprintf(buf2, sizeof(buf2), "toc_init_done");
sflap_send(buf2, -1, TYPE_DATA);
serv_finish_login();
return 0;
}
void toc_close()
{
seqno = 0;
state = STATE_OFFLINE;
toc_remove_input_stream(toc_fd);
close(toc_fd);
toc_fd=-1;
}
int toc_signon(char *username, char *password)
{
char buf[BUF_LONG];
int res;
struct signon so;
toc_debug_printf("State = %d\n", state);
strncpy(aim_username, username, sizeof(aim_username));
if ((res = write(toc_fd, FLAPON, strlen(FLAPON))) < 0)
return res;
/* Wait for signon packet */
state = STATE_FLAPON;
if ((res = wait_reply(buf, sizeof(buf)) < 0))
return res;
if (state != STATE_SIGNON_REQUEST) {
toc_debug_printf( "State should be %d, but is %d instead\n", STATE_SIGNON_REQUEST, state);
return -1;
}
/* Compose a response */
snprintf(so.username, sizeof(so.username), "%s", username);
so.ver = ntohl(1);
so.tag = ntohs(1);
so.namelen = htons(strlen(so.username));
sflap_send((char *)&so, ntohs(so.namelen) + 8, TYPE_SIGNON);
snprintf(buf, sizeof(buf),
"toc_signon %s %d %s %s %s \"%s\"",
login_host, login_port, normalize(username), roast_password(password), LANGUAGE, REVISION);
toc_debug_printf("Send: %s\n", buf);
return sflap_send(buf, -1, TYPE_DATA);
}
int toc_wait_signon()
{
/* Wait for the SIGNON to be approved */
char buf[BUF_LEN];
int res;
res = wait_reply(buf, sizeof(buf));
if (res < 0)
return res;
if (state != STATE_SIGNON_ACK) {
toc_debug_printf("State should be %d, but is %d instead\n",STATE_SIGNON_ACK, state);
return -1;
}
return 0;
}
int wait_reply(char *buffer, int buflen)
{
int res=6;
struct sflap_hdr *hdr=(struct sflap_hdr *)buffer;
char *c;
while((res = read(toc_fd, buffer, 1))) {
if (res < 0)
return res;
if (buffer[0] == '*')
break;
}
res = read(toc_fd, buffer+1, sizeof(struct sflap_hdr) - 1);
if (res < 0)
return res;
res += 1;
toc_debug_printf( "Rcv: %s %s\n",print_header(buffer), "");
while (res < (sizeof(struct sflap_hdr) + ntohs(hdr->len))) {
res += read(toc_fd, buffer + res, (ntohs(hdr->len) + sizeof(struct sflap_hdr)) - res);
/* while(gtk_events_pending())
gtk_main_iteration(); */
}
if (res >= sizeof(struct sflap_hdr))
buffer[res]='\0';
else
return res - sizeof(struct sflap_hdr);
switch(hdr->type) {
case TYPE_SIGNON:
memcpy(&peer_ver, buffer + sizeof(struct sflap_hdr), 4);
peer_ver = ntohl(peer_ver);
seqno = ntohs(hdr->seqno);
state = STATE_SIGNON_REQUEST;
break;
case TYPE_DATA:
if (!strncasecmp(buffer + sizeof(struct sflap_hdr), "SIGN_ON:", strlen("SIGN_ON:")))
state = STATE_SIGNON_ACK;
else if (!strncasecmp(buffer + sizeof(struct sflap_hdr), "CONFIG:", strlen("CONFIG:"))) {
state = STATE_CONFIG;
} else if (state != STATE_ONLINE && !strncasecmp(buffer + sizeof(struct sflap_hdr), "ERROR:", strlen("ERROR:"))) {
c = strtok(buffer + sizeof(struct sflap_hdr) + strlen("ERROR:"), ":");
translate_toc_error_code(c);
toc_debug_printf("ERROR CODE: %s\n",c);
}
toc_debug_printf("Data: %s\n",buffer + sizeof(struct sflap_hdr));
break;
default:
toc_debug_printf("Unknown/unimplemented packet type %d\n",hdr->type);
}
return res;
}
int sflap_send(char *buf, int olen, int type)
{
int len;
int slen=0;
struct sflap_hdr hdr;
char obuf[MSG_LEN];
/* One _last_ 2048 check here! This shouldn't ever
* get hit though, hopefully. If it gets hit on an IM
* It'll lose the last " and the message won't go through,
* but this'll stop a segfault. */
if (strlen(buf) > (MSG_LEN - sizeof(hdr))) {
buf[MSG_LEN - sizeof(hdr) - 3] = '"';
buf[MSG_LEN - sizeof(hdr) - 2] = '\0';
}
toc_debug_printf("%s [Len %d]\n", buf, strlen(buf));
if (olen < 0)
len = escape_message(buf);
else
len = olen;
hdr.ast = '*';
hdr.type = type;
hdr.seqno = htons(seqno++ & 0xffff);
hdr.len = htons(len + (type == TYPE_SIGNON ? 0 : 1));
toc_debug_printf("Escaped message is '%s'\n",buf);
memcpy(obuf, &hdr, sizeof(hdr));
slen += sizeof(hdr);
memcpy(&obuf[slen], buf, len);
slen += len;
if (type != TYPE_SIGNON) {
obuf[slen]='\0';
slen += 1;
}
/* print_buffer(obuf, slen); */
return write(toc_fd, obuf, slen);
}
unsigned char *roast_password(char *pass)
{
/* Trivial "encryption" */
static char rp[256];
static char *roast = ROAST;
int pos=2;
int x;
strcpy(rp, "0x");
for (x=0;(x<150) && pass[x]; x++)
pos+=sprintf(&rp[pos],"%02x", pass[x] ^ roast[x % strlen(roast)]);
rp[pos]='\0';
return rp;
}
char *print_header(void *hdr_v)
{
static char s[80];
struct sflap_hdr *hdr = (struct sflap_hdr *)hdr_v;
snprintf(s,sizeof(s), "[ ast: %c, type: %d, seqno: %d, len: %d ]",
hdr->ast, hdr->type, ntohs(hdr->seqno), ntohs(hdr->len));
return s;
}
int toc_callback(int fd)
{
char *buf;
char *c;
char **args = NULL;
char *dup,*raw;
char *l;
int numargs =0;
buf = malloc(BUF_LONG);
if (wait_reply(buf, BUF_LONG) < 0) {
toc_signoff();
toc_debug_printf("need to do proper sign off on this\n");
toc_msg_printf(TOC_CONNECT_MSGS,"Connection Closed");
return -1;
}
dup = strdup(buf+sizeof(struct sflap_hdr));
raw = rindex(dup,':');
c=strtok(buf+sizeof(struct sflap_hdr),":"); /* Ditch the first part */
if (!strcasecmp(c,"UPDATE_BUDDY")) {
char *uc, *t;
int logged, evil, idle, type = 0;
time_t signon;
time_t time_idle;
numargs = 7;
args = (char **) malloc(sizeof(char *)*numargs);
use_handler(TOC_RAW_HANDLE,TOC_UPDATE_BUDDY,raw);
c = strtok(NULL,":"); /* c is name */
args[0] = strdup(c);
l = strtok(NULL,":"); /* l is T/F logged status */
args[1] = strdup(l);
t = strtok(NULL, ":");
args[2] = strdup(t);
sscanf(t, "%d", &evil);
t = strtok(NULL, ":");
args[3] = strdup(t);
sscanf(t, "%ld", &signon);
t = strtok(NULL, ":");
args[4] = strdup(t);
sscanf(t, "%d", &idle);
uc = strtok(NULL, ":");
args[5] = strdup(uc);
if (!strncasecmp(l,"T",1))
logged = 1;
else
logged = 0;
if (uc[0] == 'A')
type |= UC_AOL;
switch(uc[1]) {
case 'A':
type |= UC_ADMIN;
break;
case 'U':
type |= UC_UNCONFIRMED;
break;
case 'O':
type |= UC_NORMAL;
break;
default:
break;
}
switch(uc[2]) {
case 'U':
type |= UC_UNAVAILABLE;
break;
default:
break;
}
if (idle) {
time(&time_idle);
time_idle -= idle*60;
} else
time_idle = 0;
serv_got_update(c, logged, evil, signon, time_idle, type);
args[6] = NULL;
use_handler(TOC_HANDLE,TOC_UPDATE_BUDDY,args);
} else if (!strcasecmp(c, "ERROR")) {
use_handler(TOC_RAW_HANDLE,TOC_ERROR,raw);
c = strtok(NULL,":");
translate_toc_error_code(c);
args = (char **) malloc(sizeof(char *)*1 + 1);
numargs = 1;
args[0] = strdup(c);
use_handler(TOC_HANDLE,TOC_ERROR,args);
toc_debug_printf("ERROR: %s",c);
} else if (!strcasecmp(c, "NICK")) {
use_handler(TOC_RAW_HANDLE,TOC_NICK,raw);
c = strtok(NULL,":");
snprintf(aim_username, sizeof(aim_username), "%s", c);
numargs = 2;
args = (char **) malloc(sizeof(char *)*numargs);
args[0] = strdup(c);
args[1] = NULL;
use_handler(TOC_HANDLE,TOC_NICK,args);
} else if (!strcasecmp(c, "IM_IN")) {
char *away, *message;
int a = 0;
use_handler(TOC_RAW_HANDLE,TOC_IM_IN,raw);
c = strtok(NULL,":");
away = strtok(NULL,":");
message = away;
while(*message && (*message != ':'))
message++;
message++;
if (!strncasecmp(away, "T", 1))
a = 1;
if ( serv_got_im(c, message,a) > 0 ) {
numargs = 3;
args = (char **) malloc(sizeof(char *)*numargs);
args[0] = strdup(c);
args[1] = strdup(message);
args[2] = NULL;
use_handler(TOC_HANDLE,TOC_IM_IN,args);
}
} else if (!strcasecmp(c, "GOTO_URL")) {
char *name;
char *url;
char tmp[256];
use_handler(TOC_RAW_HANDLE,TOC_GOTO_URL,raw);
name = strtok(NULL, ":");
url = strtok(NULL, ":");
snprintf(tmp, sizeof(tmp), "http://%s:%d/%s", toc_addy, aim_port, url);
/* fprintf(stdout, "Name: %s\n%s\n", name, url);
printf("%s", grab_url(tmp));*/
numargs = 2;
args = (char **) malloc(sizeof(char *)*numargs);
args[0] = strdup(tmp);
args[1] = NULL;
use_handler(TOC_HANDLE,TOC_GOTO_URL,args);
/* statusprintf("GOTO_URL: %s","tmp"); */
} else if (!strcasecmp(c, "EVILED")) {
int lev;
char *name = NULL;
char *levc;
use_handler(TOC_RAW_HANDLE,TOC_EVILED,raw);
levc = strtok(NULL, ":");
sscanf(levc, "%d", &lev);
name = strtok(NULL, ":");
toc_debug_printf("evil: %s | %d\n", name, lev);
numargs = 3;
my_evil = lev;
args = (char **) malloc(sizeof(char *)*numargs);
if ( name != NULL )
args[0] = strdup(name);
else
args[0] = NULL;
args[1] = strdup(levc);
args[2] = NULL;
use_handler(TOC_HANDLE,TOC_EVILED,args);
} else if (!strcasecmp(c, "CHAT_JOIN")) {
char *name,*idc;
int id;
use_handler(TOC_RAW_HANDLE,TOC_CHAT_JOIN,raw);
idc = strtok(NULL, ":");
sscanf(idc, "%d", &id);
name = strtok(NULL, ":");
serv_got_joined_chat(id, name);
numargs = 3;
args = (char **) malloc(sizeof(char *)*numargs);
args[0] = strdup(idc);
args[1] = strdup(name);
args[2] = NULL;
use_handler(TOC_HANDLE,TOC_CHAT_JOIN,args);
} else if (!strcasecmp(c, "DIR_STATUS")) {
char *status;
use_handler(TOC_RAW_HANDLE,TOC_DIR_STATUS,raw);
status = strtok(NULL,":");
numargs = 2;
args = (char **) malloc(sizeof(char *)*numargs);
args[0] = strdup(status);
args[1] = NULL;
use_handler(TOC_HANDLE,TOC_DIR_STATUS,args);
} else if (!strcasecmp(c, "CHAT_UPDATE_BUDDY")) {
int id;
char *in,*idc;
char *buddy;
LLE t;
struct buddy_chat *b = NULL;
use_handler(TOC_RAW_HANDLE,TOC_CHAT_UPDATE_BUDDY,raw);
idc = strtok(NULL, ":");
sscanf(idc, "%d", &id);
in = strtok(NULL, ":");
for ( TLL(buddy_chats,t) ) {
b = (struct buddy_chat *)t->data;
if (id == b->id)
break;
b = NULL;
}
if (!b)
return -2;
if (!strcasecmp(in, "T")) {
while((buddy = strtok(NULL, ":")) != NULL) {
/*
* Fuxin aim causes a problem here
*/
AddToLL(b->in_room, buddy,NULL);
if ( b->init_chat ) {
args = (char **) malloc(sizeof(char *)*3);
args[0] = strdup(b->name);
args[1] = strdup(buddy);
args[2] = NULL;
use_handler(TOC_HANDLE,TOC_BUDDY_JOIN_CHAT,args);
free(args[0]); free(args[1]); free(args); args = NULL;
}
}
/*
* init_chat is so that the user doenst get flooded
* with user joined chat when he first joins a chat
*/
b->init_chat = 1;
} else {
while((buddy = strtok(NULL, ":")) != NULL) {
RemoveFromLLByKey(b->in_room, buddy);
/*
* Since we might get multiple leave/joins at once
* we allocate & deallocate here
*/
args = (char **) malloc(sizeof(char *)*3);
args[0] = strdup(b->name);
args[1] = strdup(buddy);
args[2] = NULL;
use_handler(TOC_HANDLE,TOC_BUDDY_LEFT_CHAT,args);
free(args[0]); free(args[1]); free(args); args = NULL;
}
}
} else if (!strcasecmp(c, "CHAT_LEFT")) {
char *idc;
int id;
use_handler(TOC_RAW_HANDLE,TOC_CHAT_LEFT,raw);
idc = strtok(NULL, ":");
sscanf(idc, "%d", &id);
serv_got_chat_left(id);
numargs = 2;
args = (char **) malloc(sizeof(char *)*numargs);
args[0] = strdup(idc);
args[1] = NULL;
use_handler(TOC_HANDLE,TOC_CHAT_LEFT,args);
} else if (!strcasecmp(c, "CHAT_IN")) {
int id, w;
char *m,*idc;
char *who, *whisper, *chan;
struct buddy_chat *b;
use_handler(TOC_RAW_HANDLE,TOC_CHAT_IN,raw);
idc = strtok(NULL, ":");
sscanf(idc, "%d", &id);
who = strtok(NULL, ":");
whisper = strtok(NULL, ":");
m = whisper;
while(*m && (*m != ':')) m++;
m++;
if (!strcasecmp(whisper, "T"))
w = 1;
else
w = 0;
/* serv_got_chat_in(id, who, w, m); */
b = buddy_chat_getbyid(id);
if ( ! b ) {
chan = (char *) malloc(50);
strcpy(chan,"ERROR Couldn't lookup chan!");
} else {
chan = (char *) malloc(strlen(b->name)+1);
strcpy(chan,b->name);
}
numargs = 6;
args = (char **) malloc(sizeof(char *)*numargs);
args[0] = strdup(idc);
args[1] = strdup(who);
args[2] = strdup(whisper);
args[3] = strdup(m);
/* Added arg to make things simple */
args[4] = chan;
args[5] = NULL;
use_handler(TOC_HANDLE,TOC_CHAT_IN,args);
} else if (!strcasecmp(c, "CHAT_INVITE")) {
char *name;
char *who;
char *message,*idc;
int id, *pid;
use_handler(TOC_RAW_HANDLE,TOC_CHAT_INVITE,raw);
name = strtok(NULL, ":");
idc = strtok(NULL, ":");
sscanf(idc, "%d", &id);
who = strtok(NULL, ":");
message = strtok(NULL, ":");
/* serv_got_chat_invite(name, id, who, message); */
pid = (int *) malloc(sizeof(int));
*pid = id;
AddToLL(invited_chats,name,pid);
numargs = 5;
args = (char **) malloc(sizeof(char *)*numargs);
args[0] = strdup(name);
args[1] = strdup(idc);
args[2] = strdup(who);
args[3] = strdup(message);
args[4] = NULL;
use_handler(TOC_HANDLE,TOC_CHAT_INVITE,args);
} else {
toc_debug_printf("don't know what to do with %s\n", c);
}
free(dup);
free(buf);
if ( args != NULL ) {
int x;
/* toc_debug_printf("\nGOING TO FREE!: numargs = %d",numargs); */
for (x=0;x< numargs; x++)
if ( args[x] != NULL ) {
/* toc_debug_printf("freeing %d",x); */
free(args[x]);
}
/* toc_debug_printf(""); */
free(args);
}
return 1;
}
char *toc_wait_config()
{
/* Waits for configuration packet, returning the contents of the packet */
static char buf[BUF_LEN];
int res;
res = wait_reply(buf, sizeof(buf));
if (res < 0)
return NULL;
if (state != STATE_CONFIG) {
toc_debug_printf("State should be %d, but is %d instead\n",STATE_CONFIG, state);
return NULL;
}
/* At this point, it's time to setup automatic handling of incoming packets */
state = STATE_ONLINE;
// inpa = gdk_input_add(toc_fd, GDK_INPUT_READ | GDK_INPUT_EXCEPTION, toc_callback, NULL);
toc_add_input_stream(toc_fd,&toc_callback);
return buf;
}
void parse_toc_buddy_list(char *config)
{
char *c;
char current[256];
char *name;
LL bud = CreateLL();
/* skip "CONFIG:" (if it exists)*/
c = strncmp(config + sizeof(struct sflap_hdr),"CONFIG:",strlen("CONFIG:"))?
strtok(config, "\n"):
strtok(config + sizeof(struct sflap_hdr)+strlen("CONFIG:"), "\n");
do {
if (c == NULL)
break;
if (*c == 'g') {
strncpy(current,c+2, sizeof(current));
add_group(current);
} else if (*c == 'b') {
add_buddy(current, c+2);
AddToLL(bud, c+2, NULL);
} else if (*c == 'p') {
name = malloc(strlen(c+2) + 2);
snprintf(name, strlen(c+2) + 1, "%s", c+2);
AddToLL(permit, name, NULL);
} else if (*c == 'd') {
name = malloc(strlen(c+2) + 2);
snprintf(name, strlen(c+2) + 1, "%s", c+2);
AddToLL(deny, name,NULL);
} else if (*c == 'm') {
sscanf(c + strlen(c) - 1, "%d", &permdeny);
if (permdeny == 0)
permdeny = PERMIT_PERMITALL;
}
} while ((c=strtok(NULL,"\n")));
serv_add_buddies(bud);
FreeLL(bud);
serv_set_permit_deny();
}
int toc_signoff() {
/* Leaking memory like a MOFO */
FreeLL(groups);
FreeLL(buddy_chats);
FreeLL(invited_chats);
FreeLL(permit);
FreeLL(deny);
deny = groups = permit = buddy_chats = invited_chats = NULL;
toc_debug_printf("LEAKING MEMORY LIKE A BITCH in toc_signoff!");
serv_close();
toc_msg_printf(TOC_CONNECT_MSGS,"%s signed off",aim_username);
return 1;
}
void toc_build_config(char *s, int len)
{
struct group *g;
struct buddy *b;
LLE t,t1;
LL mem;
int pos=0;
toc_debug_printf("FIX this permdeny hack shit!");
if (!permdeny)
permdeny = PERMIT_PERMITALL;
pos += snprintf(&s[pos], len - pos, "m %d\n", permdeny);
/* Create Buddy List */
for ( TLL(groups,t) ) {
g = (struct group *)t->data;
pos += snprintf(&s[pos], len - pos, "g %s\n", g->name);
mem = g->members;
for ( TLL(mem,t1) ) {
b = (struct buddy *)t1->data;
pos += snprintf(&s[pos], len - pos, "b %s\n", b->name);
}
}
/* Create Permit and Deny Lists */;
for ( TLL(permit,t) ) {
toc_debug_printf("permit: added %s\n",(char *)t->key);
pos += snprintf(&s[pos], len - pos, "p %s\n", (char *)t->key);
}
for ( TLL(deny,t) ) {
toc_debug_printf("deny: added %s\n",(char *)t->key);
pos += snprintf(&s[pos], len - pos, "d %s\n", (char *)t->key);
}
}
void translate_toc_error_code(char *c) {
int no = atoi(c);
char *w = strtok(NULL, ":");
char buf[256];
switch ( no ) {
case 901:
snprintf(buf, sizeof(buf), "%s not currently logged in.", w);
break;
case 902:
snprintf(buf, sizeof(buf), "Warning of %s not allowed.", w);
break;
case 903:
snprintf(buf, sizeof(buf), "A message has been dropped, you are exceeding the server speed limit.");
break;
case 950:
snprintf(buf, sizeof(buf), "Chat in %s is not available.", w);
break;
case 960:
snprintf(buf, sizeof(buf), "You are sending messages too fast to %s.", w);
break;
case 961:
snprintf(buf, sizeof(buf), "You missed an IM from %s because it was too big.", w);
break;
case 962:
snprintf(buf, sizeof(buf), "You missed an IM from %s because it was sent too fast.", w);
break;
case 970:
snprintf(buf, sizeof(buf), "Failure.");
break;
case 971:
snprintf(buf, sizeof(buf), "Too many matches.");
break;
case 972:
snprintf(buf, sizeof(buf), "Need more qualifiers.");
break;
case 973:
snprintf(buf, sizeof(buf), "Dir service temporarily unavailable.");
break;
case 974:
snprintf(buf, sizeof(buf), "Email lookup restricted.");
break;
case 975:
snprintf(buf, sizeof(buf), "Keyword ignored.");
break;
case 976:
snprintf(buf, sizeof(buf), "No keywords.");
break;
case 977:
snprintf(buf, sizeof(buf), "User has no directory information.");
/* snprintf(buf, sizeof(buf), "Language not supported."); */
break;
case 978:
snprintf(buf, sizeof(buf), "Country not supported.");
break;
case 979:
snprintf(buf, sizeof(buf), "Failure unknown: %s.", w);
break;
case 980:
snprintf(buf, sizeof(buf), "Incorrect nickname or password.");
break;
case 981:
snprintf(buf, sizeof(buf), "The service is temporarily unavailable.");
break;
case 982:
snprintf(buf, sizeof(buf), "Your warning level is currently too high to log in.");
break;
case 983:
snprintf(buf, sizeof(buf), "You have been connecting and disconnecting too frequently. Wait ten minutes and try again. If you continue to try, you will need to wait even longer.");
break;
case 989:
snprintf(buf, sizeof(buf), "An unknown signon error has occurred: %s.", w);
break;
default:
snprintf(buf, sizeof(buf), "An unknown error, %d, has occured. Info: %s", no, w);
}
toc_msg_printf(TOC_TRANSLATED_ERROR,buf);
return;
}