/* user disconnected before her relay had finished connecting */
static void failed_pre_relay(int idx)
{
register int tidx = (-1), i;
Context;
for (i = 0; i < dcc_total; i++)
if ((dcc[i].type == &DCC_FORK_RELAY) &&
(dcc[i].u.relay->sock == dcc[idx].sock))
tidx = i;
if (tidx < 0) {
putlog(LOG_MISC, "*", "%s %d -> %d", BOT_CANTFINDRELAYUSER,
dcc[i].sock, dcc[i].u.relay->sock);
killsock(dcc[i].sock);
lostdcc(i);
return;
}
putlog(LOG_MISC, "*", "%s [%s]%s/%d", BOT_LOSTDCCUSER, dcc[idx].nick,
dcc[idx].host, dcc[idx].port);
putlog(LOG_MISC, "*", "(%s %s)", BOT_DROPPINGRELAY, dcc[tidx].nick);
if ((dcc[tidx].sock != STDOUT) || backgrd) {
if (idx > tidx) {
int t = tidx;
tidx = idx;
idx = t;
}
killsock(dcc[tidx].sock);
lostdcc(tidx);
} else {
fatal("Lost my terminal??!?!?!", 0);
}
killsock(dcc[idx].sock);
lostdcc(idx);
}
/* input from user before connect is ready */
static void pre_relay(int idx, char *buf, register int i)
{
register int tidx = (-1);
Context;
for (i = 0; i < dcc_total; i++)
if ((dcc[i].type == &DCC_FORK_RELAY) &&
(dcc[i].u.relay->sock == dcc[idx].sock))
tidx = i;
if (tidx < 0) {
putlog(LOG_MISC, "*", "%s %d -> %d", BOT_CANTFINDRELAYUSER,
dcc[i].sock, dcc[i].u.relay->sock);
killsock(dcc[i].sock);
lostdcc(i);
return;
}
Context;
if (!strcasecmp(buf, "*bye*")) {
/* disconnect */
struct chat_info *ci = dcc[idx].u.relay->chat;
dprintf(idx, "%s %s.\n", BOT_ABORTRELAY1, dcc[tidx].nick);
dprintf(idx, "%s %s.\n\n", BOT_ABORTRELAY2, botnetnick);
putlog(LOG_MISC, "*", "%s %s -> %s", BOT_ABORTRELAY3, dcc[idx].nick,
dcc[tidx].nick);
dcc[idx].status = dcc[idx].u.relay->old_status;
nfree(dcc[idx].u.relay);
dcc[idx].u.chat = ci;
dcc[idx].type = &DCC_CHAT;
killsock(dcc[tidx].sock);
lostdcc(tidx);
return;
}
Context;
}
static char *filesys_close()
{
int i;
p_tcl_bind_list H_ctcp;
Context;
putlog(LOG_MISC, "*", "Unloading filesystem, killing all filesystem connections..");
for (i = 0; i < dcc_total; i++)
if (dcc[i].type == &DCC_FILES) {
dprintf(i, DCC_BOOTED1);
dprintf(i,
"You have been booted from the filesystem, module unloaded.\n");
killsock(dcc[i].sock);
lostdcc(i);
} else if (dcc[i].type == &DCC_FILES_PASS) {
killsock(dcc[i].sock);
lostdcc(i);
}
rem_tcl_commands(mytcls);
rem_tcl_strings(mystrings);
rem_tcl_ints(myints);
rem_builtins(H_dcc, mydcc);
rem_builtins(H_load, myload);
rem_builtins(H_fil, myfiles);
rem_help_reference("filesys.help");
if ((H_ctcp = find_bind_table("ctcp")))
rem_builtins(H_ctcp, myctcp);
del_bind_table(H_fil);
del_entry_type(&USERENTRY_DCCDIR);
del_lang_section("filesys");
module_undepend(MODULE_NAME);
return NULL;
}
/* once a minute, send 'ping' to each bot -- no exceptions */
void check_botnet_pings()
{
int i;
Context;
for (i = 0; i < dcc_total; i++)
if (dcc[i].type == &DCC_BOT)
if (dcc[i].status & STAT_PINGED) {
char s[1024];
putlog(LOG_BOTS, "*", "%s: %s", BOT_PINGTIMEOUT, dcc[i].nick);
simple_sprintf(s, "%s: %s", BOT_PINGTIMEOUT, dcc[i].nick);
chatout("*** %s\n", s);
botnet_send_unlinked(i, dcc[i].nick, s);
killsock(dcc[i].sock);
lostdcc(i);
}
Context;
for (i = 0; i < dcc_total; i++)
if (dcc[i].type == &DCC_BOT) {
botnet_send_ping(i);
dcc[i].status |= STAT_PINGED;
}
Context;
for (i = 0; i < dcc_total; i++)
if ((dcc[i].type == &DCC_BOT) && (dcc[i].status & STAT_LEAF)) {
tand_t *bot, *via = findbot(dcc[i].nick);
for (bot = tandbot; bot; bot = bot->next) {
if ((via == bot->via) && (bot != via)) {
/* not leaflike behavior */
if (dcc[i].status & STAT_WARNED) {
char s[1024];
putlog(LOG_BOTS, "*", "%s %s (%s).", BOT_DISCONNECTED,
dcc[i].nick, BOT_BOTNOTLEAFLIKE);
dprintf(i, "bye\n");
simple_sprintf(s, "%s %s (%s)", BOT_DISCONNECTED, dcc[i].nick,
BOT_BOTNOTLEAFLIKE);
chatout("*** %s\n", s);
botnet_send_unlinked(i, dcc[i].nick, s);
killsock(dcc[i].sock);
lostdcc(i);
} else {
botnet_send_reject(i, botnetnick, NULL, bot->bot,
NULL, NULL);
dcc[i].status |= STAT_WARNED;
}
} else
dcc[i].status &= ~STAT_WARNED;
}
}
Context;
}
static void eof_dcc_relaying(int idx)
{
register int j, x = dcc[idx].u.relay->sock;
putlog(LOG_MISC, "*", "%s [%s]%s/%d", BOT_LOSTDCCUSER, dcc[idx].nick,
dcc[idx].host, dcc[idx].port);
killsock(dcc[idx].sock);
lostdcc(idx);
for (j = 0; (dcc[j].sock != x) || (dcc[j].type == &DCC_FORK_RELAY); j++);
putlog(LOG_MISC, "*", "(%s %s)", BOT_DROPPEDRELAY, dcc[j].nick);
killsock(dcc[j].sock);
lostdcc(j); /* drop connection to the bot */
}
static void timeout_server(int idx)
{
putlog(LOG_SERV, "*", "Timeout: connect to %s", dcc[idx].host);
disconnect_server(idx);
check_tcl_event("fail-server");
lostdcc(idx);
}
static int tcl_killdcc(ClientData cd, Tcl_Interp *irp,
int argc, char *argv[])
{
int idx;
BADARGS(2, 3, " idx ?reason?");
idx = findidx(atoi(argv[1]));
if (idx < 0) {
Tcl_AppendResult(irp, "invalid idx", NULL);
return TCL_ERROR;
}
if ((dcc[idx].sock == STDOUT) && !backgrd) /* Don't kill terminal socket */
return TCL_OK;
if (dcc[idx].type->flags & DCT_CHAT) { /* Make sure 'whom' info is updated */
chanout_but(idx, dcc[idx].u.chat->channel, "*** %s has left the %s%s%s\n",
dcc[idx].nick, dcc[idx].u.chat ? "channel" : "partyline",
argc == 3 ? ": " : "", argc == 3 ? argv[2] : "");
botnet_send_part_idx(idx, argc == 3 ? argv[2] : "");
if ((dcc[idx].u.chat->channel >= 0) &&
(dcc[idx].u.chat->channel < GLOBAL_CHANS))
check_tcl_chpt(botnetnick, dcc[idx].nick, dcc[idx].sock,
dcc[idx].u.chat->channel);
check_tcl_chof(dcc[idx].nick, dcc[idx].sock);
}
killsock(dcc[idx].sock);
killtransfer(idx);
lostdcc(idx);
return TCL_OK;
}
char *dns_start(Function *global_funcs)
{
int idx;
global = global_funcs;
module_register(MODULE_NAME, dns_table, 1, 0);
if (!module_depend(MODULE_NAME, "eggdrop", 106, 0)) {
module_undepend(MODULE_NAME);
return "This module requires Eggdrop 1.6.0 or later.";
}
idx = new_dcc(&DCC_DNS, 0);
if (idx < 0)
return "NO MORE DCC CONNECTIONS -- Can't create DNS socket.";
if (!init_dns_core()) {
lostdcc(idx);
return "DNS initialisation failed.";
}
dcc[idx].sock = resfd;
dcc[idx].timeval = now;
strcpy(dcc[idx].nick, "(dns)");
add_hook(HOOK_SECONDLY, (Function) dns_check_expires);
add_hook(HOOK_DNS_HOSTBYIP, (Function) dns_lookup);
add_hook(HOOK_DNS_IPBYHOST, (Function) dns_forward);
return NULL;
}
void eof_dcc_dnswait(int idx)
{
putlog(LOG_MISC, "*", "Lost connection while resolving hostname [%s/%d]",
iptostr(&dcc[idx].sockname.addr.sa), dcc[idx].port);
killsock(dcc[idx].sock);
lostdcc(idx);
}
/* Handle someone being booted from dcc chat.
*/
void do_boot(int idx, char *by, char *reason)
{
int files = (dcc[idx].type != &DCC_CHAT);
dprintf(idx, DCC_BOOTED1);
dprintf(idx, DCC_BOOTED2, files ? "file section" : "bot",
by, reason[0] ? ": " : ".", reason);
/* If it's a partyliner (chatterer :) */
/* Horrible assumption that DCT_CHAT using structure uses same format
* as DCC_CHAT */
if ((dcc[idx].type->flags & DCT_CHAT) && (dcc[idx].u.chat->channel >= 0)) {
char x[1024];
egg_snprintf(x, sizeof x, DCC_BOOTED3, by, dcc[idx].nick,
reason[0] ? ": " : "", reason);
chanout_but(idx, dcc[idx].u.chat->channel, "*** %s.\n", x);
if (dcc[idx].u.chat->channel < GLOBAL_CHANS)
botnet_send_part_idx(idx, x);
}
check_tcl_chof(dcc[idx].nick, dcc[idx].sock);
if ((dcc[idx].sock != STDOUT) || backgrd) {
killsock(dcc[idx].sock);
lostdcc(idx);
/* Entry must remain in the table so it can be logged by the caller */
} else {
dprintf(DP_STDOUT, "\n### SIMULATION RESET\n\n");
dcc_chatter(idx);
}
return;
}
static void eof_dcc_relay(int idx)
{
register int j;
struct chat_info *ci;
for (j = 0; dcc[j].sock != dcc[idx].u.relay->sock; j++);
dcc[j].status = dcc[j].u.relay->old_status;
/* in case echo was off, turn it back on: */
if (dcc[j].status & STAT_TELNET)
dprintf(j, "\377\374\001\n");
putlog(LOG_MISC, "*", "%s: %s -> %s", BOT_ENDRELAY1, dcc[j].nick,
dcc[idx].nick);
dprintf(j, "\n\n*** %s %s\n", BOT_ENDRELAY2, botnetnick);
ci = dcc[j].u.relay->chat;
nfree(dcc[j].u.relay);
dcc[j].u.chat = ci;
dcc[j].type = &DCC_CHAT;
if (dcc[j].u.chat->channel >= 0) {
chanout_but(-1, dcc[j].u.chat->channel, "*** %s %s.\n",
dcc[j].nick, BOT_PARTYREJOINED);
Context;
if (dcc[j].u.chat->channel < 100000)
botnet_send_join_idx(j, -1);
}
check_tcl_chon(dcc[j].nick, dcc[j].sock);
check_tcl_chjn(botnetnick, dcc[j].nick, dcc[j].u.chat->channel,
geticon(j), dcc[j].sock, dcc[j].host);
killsock(dcc[idx].sock);
lostdcc(idx);
}
static void tout_dcc_files_pass(int i)
{
dprintf(i, "Timeout.\n");
putlog(LOG_MISC, "*", "Password timeout on dcc chat: [%s]%s", dcc[i].nick,
dcc[i].host);
killsock(dcc[i].sock);
lostdcc(i);
}
static void server_resolve_failure(int servidx)
{
serv = -1;
resolvserv = 0;
putlog(LOG_SERV, "*", "%s %s (%s)", IRC_FAILEDCONNECT, dcc[servidx].host,
IRC_DNSFAILED);
lostdcc(servidx);
}
static void eof_dcc_files(int idx)
{
dcc[idx].u.file->chat->con_flags = 0;
putlog(LOG_MISC, "*", "Lost dcc connection to %s (%s/%d)", dcc[idx].nick,
dcc[idx].host, dcc[idx].port);
killsock(dcc[idx].sock);
lostdcc(idx);
}
void zapfbot(int idx)
{
char s[1024];
simple_sprintf(s, "%s: %s", BOT_BOTDROPPED, dcc[idx].nick);
chatout("*** %s\n", s);
botnet_send_unlinked(idx, dcc[idx].nick, s);
killsock(dcc[idx].sock);
lostdcc(idx);
}
static void server_resolve_success(int servidx)
{
char pass[121];
resolvserv = 0;
strcpy(pass, dcc[servidx].u.dns->cbuf);
changeover_dcc(servidx, &SERVER_SOCKET, 0);
dcc[servidx].sock = getsock(dcc[servidx].sockname.family, 0);
setsnport(dcc[servidx].sockname, dcc[servidx].port);
serv = open_telnet_raw(dcc[servidx].sock, &dcc[servidx].sockname);
if (serv < 0) {
putlog(LOG_SERV, "*", "%s %s (%s)", IRC_FAILEDCONNECT, dcc[servidx].host,
strerror(errno));
lostdcc(servidx);
return;
}
#ifdef TLS
if (dcc[servidx].ssl && ssl_handshake(serv, TLS_CONNECT, tls_vfyserver,
LOG_SERV, dcc[servidx].host, NULL)) {
putlog(LOG_SERV, "*", "%s %s (%s)", IRC_FAILEDCONNECT, dcc[servidx].host,
"TLS negotiation failure");
lostdcc(servidx);
return;
}
#endif
/* Queue standard login */
dcc[servidx].timeval = now;
SERVER_SOCKET.timeout_val = &server_timeout;
/* Another server may have truncated it, so use the original */
strcpy(botname, origbotname);
/* Start alternate nicks from the beginning */
altnick_char = 0;
if (pass[0])
dprintf(DP_MODE, "PASS %s\n", pass);
dprintf(DP_MODE, "NICK %s\n", botname);
rmspace(botrealname);
if (botrealname[0] == 0)
strcpy(botrealname, "/msg LamestBot hello");
dprintf(DP_MODE, "USER %s . . :%s\n", botuser, botrealname);
/* Wait for async result now. */
}
/* Close the current server connection.
*/
static void nuke_server(char *reason)
{
if (serv >= 0) {
int servidx = findanyidx(serv);
if (reason && (servidx > 0))
dprintf(servidx, "QUIT :%s\n", reason);
disconnect_server(servidx);
lostdcc(servidx);
}
}
static void eof_dns_socket(int idx)
{
putlog(LOG_MISC, "*", "DNS Error: socket closed.");
killsock(dcc[idx].sock);
/* Try to reopen socket */
if (init_dns_network()) {
putlog(LOG_MISC, "*", "DNS socket successfully reopened!");
dcc[idx].sock = resfd;
dcc[idx].timeval = now;
} else
lostdcc(idx);
}
static void dcc_files(int idx, char *buf, int i)
{
Context;
if (buf[0] &&
detect_dcc_flood(&dcc[idx].timeval, dcc[idx].u.file->chat, idx))
return;
dcc[idx].timeval = now;
strcpy(buf, check_tcl_filt(idx, buf));
if (!buf[0])
return;
touch_laston(dcc[idx].user, "filearea", now);
if (buf[0] == ',') {
for (i = 0; i < dcc_total; i++) {
if ((dcc[i].type->flags & DCT_MASTER) && dcc[idx].user &&
(dcc[idx].user->flags & USER_MASTER) &&
((dcc[i].type == &DCC_FILES) ||
(dcc[i].u.chat->channel >= 0)) &&
((i != idx) || (dcc[idx].status & STAT_ECHO)))
dprintf(i, "-%s- %s\n", dcc[idx].nick, &buf[1]);
}
} else if (got_files_cmd(idx, buf)) {
dprintf(idx, "*** Ja mata!\n");
flush_lines(idx, dcc[idx].u.file->chat);
putlog(LOG_FILES, "*", "DCC user [%s]%s left file system", dcc[idx].nick,
dcc[idx].host);
set_user(&USERENTRY_DCCDIR, dcc[idx].user, dcc[idx].u.file->dir);
if (dcc[idx].status & STAT_CHAT) {
struct chat_info *ci;
dprintf(idx, "Returning you to command mode...\n");
ci = dcc[idx].u.file->chat;
nfree(dcc[idx].u.file);
dcc[idx].u.chat = ci;
dcc[idx].status &= (~STAT_CHAT);
dcc[idx].type = &DCC_CHAT;
if (dcc[idx].u.chat->channel >= 0) {
chanout_but(-1, dcc[idx].u.chat->channel,
"*** %s has returned.\n", dcc[idx].nick);
if (dcc[idx].u.chat->channel < 100000)
botnet_send_join_idx(idx, -1);
}
} else {
dprintf(idx, "Dropping connection now.\n");
putlog(LOG_FILES, "*", "Left files: [%s]%s/%d", dcc[idx].nick,
dcc[idx].host, dcc[idx].port);
killsock(dcc[idx].sock);
lostdcc(idx);
}
}
if (dcc[idx].status & STAT_PAGE)
flush_lines(idx, dcc[idx].u.file->chat);
}
/* part <bot> <nick> <sock> [etc..]
*/
static void bot_part(int idx, char *par)
{
char *bot = NULL, *nick = NULL, *etc = NULL;
struct userrec *u = NULL;
int sock, partyidx;
int silent = 0;
bot = newsplit(&par);
if (bot[0] == '!') {
silent = 1;
bot++;
}
nick = newsplit(&par);
etc = newsplit(&par);
sock = base64_to_int(etc);
u = get_user_by_handle(userlist, nick);
if (u) {
simple_snprintf(TBUF, sizeof(TBUF), "@%s", bot);
touch_laston(u, TBUF, now);
}
if ((partyidx = getparty(bot, sock)) != -1) {
if (!silent) {
register int chan = party[partyidx].chan;
if (par[0])
chanout_but(-1, chan, "*** (%s) %s %s %s (%s).\n", conf.bot->hub ? bot : "[botnet]", nick,
"has left the",
chan ? "channel" : "party line", par);
else
chanout_but(-1, chan, "*** (%s) %s %s %s.\n", conf.bot->hub ? bot : "[botnet]", nick,
"has left the",
chan ? "channel" : "party line");
}
botnet_send_part_party(idx, partyidx, par, silent);
remparty(bot, sock);
}
/* check if we have a remote idx for them */
int i = 0;
for (i = 0; i < dcc_total; i++) {
/* This will potentially close all simul-idxs with matching nick, even though they may be connected multiple times
but, it won't matter as a new will just be made as needed. */
if (dcc[i].type && dcc[i].simul >= 0 && !strcasecmp(dcc[i].nick, nick)) {
dcc[i].simul = -1;
lostdcc(i);
}
}
}
static void dcc_files_pass(int idx, char *buf, int x)
{
struct userrec *u = get_user_by_handle(userlist, dcc[idx].nick);
if (!x)
return;
if (u_pass_match(u, buf)) {
if (too_many_filers()) {
dprintf(idx, "Too many people are in the file system right now.\n");
dprintf(idx, "Please try again later.\n");
putlog(LOG_MISC, "*", "File area full: DCC chat [%s]%s", dcc[idx].nick,
dcc[idx].host);
killsock(dcc[idx].sock);
lostdcc(idx);
return;
}
dcc[idx].type = &DCC_FILES;
if (dcc[idx].status & STAT_TELNET)
dprintf(idx, "\377\374\001\n"); /* turn echo back on */
putlog(LOG_FILES, "*", "File system: [%s]%s/%d", dcc[idx].nick,
dcc[idx].host, dcc[idx].port);
if (!welcome_to_files(idx)) {
putlog(LOG_FILES, "*", "File system broken.");
killsock(dcc[idx].sock);
lostdcc(idx);
} else {
struct userrec *u = get_user_by_handle(userlist, dcc[idx].nick);
touch_laston(u, "filearea", now);
}
return;
}
dprintf(idx, "Negative on that, Houston.\n");
putlog(LOG_MISC, "*", "Bad password: DCC chat [%s]%s", dcc[idx].nick,
dcc[idx].host);
killsock(dcc[idx].sock);
lostdcc(idx);
}
static void failed_tandem_relay(int idx)
{
int uidx = (-1), i;
Context;
for (i = 0; i < dcc_total; i++)
if ((dcc[i].type == &DCC_PRE_RELAY) &&
(dcc[i].u.relay->sock == dcc[idx].sock))
uidx = i;
if (uidx < 0) {
putlog(LOG_MISC, "*", "%s %d -> %d", BOT_CANTFINDRELAYUSER,
dcc[idx].sock, dcc[idx].u.relay->sock);
killsock(dcc[idx].sock);
lostdcc(idx);
return;
}
if (dcc[idx].port >= dcc[idx].u.relay->port + 3) {
struct chat_info *ci = dcc[uidx].u.relay->chat;
dprintf(uidx, "%s %s.\n", BOT_CANTLINKTO, dcc[idx].nick);
dcc[uidx].status = dcc[uidx].u.relay->old_status;
nfree(dcc[uidx].u.relay);
dcc[uidx].u.chat = ci;
dcc[uidx].type = &DCC_CHAT;
killsock(dcc[idx].sock);
lostdcc(idx);
return;
}
killsock(dcc[idx].sock);
dcc[idx].sock = getsock(SOCK_STRONGCONN);
dcc[uidx].u.relay->sock = dcc[idx].sock;
dcc[idx].port++;
dcc[idx].timeval = now;
if (open_telnet_raw(dcc[idx].sock, dcc[idx].host, dcc[idx].port) < 0)
failed_tandem_relay(idx);
}
static void
dns_reinit(int idx)
{
sdprintf("Re-opening dns socket...");
killsock(dcc[idx].sock);
lostdcc(idx);
dns_idx = -1;
dns_sock = -1;
dns_ip = NULL;
if (!get_dns_idx())
sdprintf("Successfully reopened dns socket");
else
sdprintf("Failed to reopen dns socket");
}
static void bot_linked(int idx, char *par)
{
char s[1024];
int bots, users;
bots = bots_in_subtree(findbot(dcc[idx].nick));
users = users_in_subtree(findbot(dcc[idx].nick));
putlog(LOG_BOTS, "*", "%s", BOT_OLDBOT);
simple_sprintf(s, "%s %s (%s) (lost %d bot%s and %d user%s",
MISC_DISCONNECTED, dcc[idx].nick, MISC_OUTDATED,
bots, (bots != 1) ? "s" : "", users, (users != 1) ? "s" : "");
chatout("*** %s\n", s);
botnet_send_unlinked(idx, dcc[idx].nick, s);
killsock(dcc[idx].sock);
lostdcc(idx);
}
static void bot_bye(int idx, char *par)
{
char s[1024];
int users, bots;
bots = bots_in_subtree(findbot(dcc[idx].nick));
users = users_in_subtree(findbot(dcc[idx].nick));
simple_sprintf(s, "%s %s. %s (lost %d bot%s and %d user%s)",
BOT_DISCONNECTED, dcc[idx].nick, par[0] ?
par : "No reason", bots, (bots != 1) ?
"s" : "", users, (users != 1) ? "s" : "");
putlog(LOG_BOTS, "*", "%s", s);
chatout("*** %s\n", s);
botnet_send_unlinked(idx, dcc[idx].nick, s);
dprintf(idx, "*bye\n");
killsock(dcc[idx].sock);
lostdcc(idx);
}
static void bot_bye(int idx, char *par)
{
char s[1024] = "";
int users, bots;
bots = bots_in_subtree(findbot(dcc[idx].nick));
users = users_in_subtree(findbot(dcc[idx].nick));
simple_snprintf(s, sizeof(s), "%s %s. %s (lost %d bot%s and %d user%s)",
"Disconnected from:",
(conf.bot->hub || (conf.bot->localhub && bot_aggressive_to(dcc[idx].user))) ? dcc[idx].nick : "botnet",
par[0] ? par : "No reason", bots, (bots != 1) ?
"s" : "", users, (users != 1) ? "s" : "");
putlog(LOG_BOTS, "*", "%s", s);
chatout("*** %s\n", s);
botnet_send_unlinked(idx, dcc[idx].nick, s);
dprintf(idx, "*bye\n");
killsock(dcc[idx].sock);
lostdcc(idx);
}
static char *dns_close()
{
int i;
del_hook(HOOK_DNS_HOSTBYIP, (Function) dns_lookup);
del_hook(HOOK_DNS_IPBYHOST, (Function) dns_forward);
del_hook(HOOK_SECONDLY, (Function) dns_check_expires);
for (i = 0; i < dcc_total; i++) {
if (dcc[i].type == &DCC_DNS && dcc[i].sock == resfd) {
killsock(dcc[i].sock);
lostdcc(i);
break;
}
}
dns_free_cache();
module_undepend(MODULE_NAME);
return NULL;
}
void egg_dns_send(char *query, int len)
{
if (dns_idx >= 0 && dcc[dns_idx].sock == -1) {
lostdcc(dns_idx);
dns_idx = -1;
}
if (dns_idx < 0) {
if (get_dns_idx()) {
sdprintf("get_dns_idx() failed in egg_dns_send");
return;
}
}
if (!dns_handler.timeout_val) {
dns_handler.timeout_val = &async_server_timeout;
sdprintf("SETTING TIMEOUT to %d", async_server_timeout);
dcc[dns_idx].timeval = now;
}
write(dcc[dns_idx].sock, query, len);
// sockbuf_write(dns_idx, query, len);
}
static void cont_tandem_relay(int idx, char *buf, register int i)
{
register int uidx = (-1);
struct relay_info *ri;
Context;
for (i = 0; i < dcc_total; i++)
if ((dcc[i].type == &DCC_PRE_RELAY) &&
(dcc[i].u.relay->sock == dcc[idx].sock))
uidx = i;
if (uidx < 0) {
putlog(LOG_MISC, "*", "%s %d -> %d", BOT_CANTFINDRELAYUSER,
dcc[i].sock, dcc[i].u.relay->sock);
killsock(dcc[i].sock);
lostdcc(i);
return;
}
dcc[idx].type = &DCC_RELAY;
dcc[idx].u.relay->sock = dcc[uidx].sock;
dcc[uidx].u.relay->sock = dcc[idx].sock;
dprintf(uidx, "%s %s ...\n", BOT_RELAYSUCCESS, dcc[idx].nick);
dprintf(uidx, "%s\n\n", BOT_BYEINFO2);
putlog(LOG_MISC, "*", "%s %s -> %s", BOT_RELAYLINK,
dcc[uidx].nick, dcc[idx].nick);
ri = dcc[uidx].u.relay; /* YEAH */
dcc[uidx].type = &DCC_CHAT;
dcc[uidx].u.chat = ri->chat;
if (dcc[uidx].u.chat->channel >= 0) {
chanout_but(-1, dcc[uidx].u.chat->channel, "*** %s %s\n",
dcc[uidx].nick, BOT_PARTYLEFT);
if (dcc[uidx].u.chat->channel < 100000)
botnet_send_part_idx(uidx, NULL);
check_tcl_chpt(botnetnick, dcc[uidx].nick, dcc[uidx].sock,
dcc[uidx].u.chat->channel);
}
check_tcl_chof(dcc[uidx].nick, dcc[uidx].sock);
dcc[uidx].type = &DCC_RELAYING;
dcc[uidx].u.relay = ri;
}
static void bot_thisbot(int idx, char *par)
{
if (strcasecmp(par, dcc[idx].nick)) {
char s[1024] = "";
putlog(LOG_BOTS, "*", "Wrong bot--wanted %s, got %s", dcc[idx].nick, par);
dprintf(idx, "bye imposter\n");
simple_snprintf(s, sizeof(s), "Disconnected %s (imposter)", dcc[idx].nick);
chatout("*** %s\n", s);
botnet_send_unlinked(idx, dcc[idx].nick, s);
unvia(idx, findbot(dcc[idx].nick));
killsock(dcc[idx].sock);
lostdcc(idx);
return;
}
/* Set capitalization the way they want it */
noshare = 1;
change_handle(dcc[idx].user, par);
noshare = 0;
strlcpy(dcc[idx].nick, par, sizeof(dcc[idx].nick));
}