/* try to identify at Nickserv */
void identify_needed(unsigned int force)
{
char *pwd;
pwd = get_nickserv_pass();
if (pwd == NULL)
return;
if (force == 0) {
if ((gnetwork->next_identify > 0) && (gnetwork->next_identify >= gdata.curtime))
return;
}
/* wait 1 sec before idetify again */
gnetwork->next_identify = gdata.curtime + 1;
if (gnetwork->auth_name != NULL) {
writeserver(WRITESERVER_NORMAL, "PRIVMSG %s :AUTH %s %s", /* NOTRANSLATE */
gnetwork->auth_name, save_nick(gnetwork->user_nick), pwd);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"AUTH send to %s on %s.", gnetwork->auth_name, gnetwork->name);
return;
}
if (gnetwork->login_name != NULL) {
writeserver(WRITESERVER_NORMAL, "PRIVMSG %s :LOGIN %s %s", /* NOTRANSLATE */
gnetwork->login_name, save_nick(gnetwork->user_nick), pwd);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"LOGIN send to %s on %s.", gnetwork->login_name, gnetwork->name);
return;
}
writeserver(WRITESERVER_NORMAL, "PRIVMSG %s :IDENTIFY %s", "nickserv", pwd); /* NOTRANSLATE */
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"IDENTIFY send to nickserv on %s.", gnetwork->name);
}
/* search the DDC transfer a user wants to resume */
unsigned int t_find_resume(const char *nick, const char *filename, const char *localport, const char *bytes, char *token)
{
char *sendnamestr;
transfer *guess;
transfer *tr;
off_t len;
guess = NULL;
for (tr = irlist_get_head(&gdata.trans);
tr;
tr = irlist_get_next(tr)) {
if ((tr->tr_status != TRANSFER_STATUS_LISTENING) && (tr->tr_status != TRANSFER_STATUS_RESUME))
continue;
if (strcasecmp(tr->caps_nick, nick))
continue;
/* the filename can be converted */
if (guess == NULL)
guess = tr;
if (strcasestr(tr->xpack->file, filename))
break;
if (tr->con.localport == (unsigned)atoi(localport))
break;
}
if (tr == NULL) {
if (guess != NULL) {
outerror(OUTERROR_TYPE_WARN,
"Guessed transfer that %s on %s tried to resume!",
nick, gnetwork->name);
outerror(OUTERROR_TYPE_WARN,
"resume trying %s, %s, %d",
nick, filename, atoi(localport));
tr = guess;
} else {
t_find_debug(nick, filename, localport);
return 1;
}
}
len = atoull(bytes);
if (len >= tr->xpack->st_size) {
notice(nick, "You can't resume the transfer at a point greater than the size of the file");
ioutput(OUT_S|OUT_L|OUT_D, COLOR_YELLOW,
"XDCC [%02i:%s on %s]: Resume attempted beyond end of file ( %" LLPRINTFMT "d >= %" LLPRINTFMT "d )",
tr->id, tr->nick, gnetwork->name, len,
tr->xpack->st_size);
return 1;
}
t_setresume(tr, bytes);
sendnamestr = getsendname(filename);
if ((tr->tr_status == TRANSFER_STATUS_RESUME) && (token != NULL)) {
privmsg_fast(nick, IRC_CTCP "DCC ACCEPT %s %s %s %s" IRC_CTCP, sendnamestr, localport, bytes, token); /* NOTRANSLATE */
} else {
privmsg_fast(nick, IRC_CTCP "DCC ACCEPT %s %s %s" IRC_CTCP, sendnamestr, localport, bytes); /* NOTRANSLATE */
}
mydelete(sendnamestr);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_YELLOW,
"XDCC [%02i:%s on %s]: Resumed at %" LLPRINTFMT "dK", tr->id,
tr->nick, gnetwork->name, tr->startresume/1024);
return 0;
}
int mod_load(char *name, Function * f2, struct global_t * g2) {
struct db_row_t row;
f = f2;
context();
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_DEBUG, "module %s loading", name);
g2->mysql_dbh = mysql_init(NULL);
mysql_options(g2->mysql_dbh, MYSQL_READ_DEFAULT_GROUP, g2->mysql_db);
if (!mysql_real_connect(g2->mysql_dbh, g2->mysql_host, g2->mysql_user, g2->mysql_pass, g2->mysql_db, 0, NULL, 0)) {
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_CRITICAL, "%s: failed to connect to database: %s", name, mysql_error(g2->mysql_dbh));
g2->mysql_connected = 0;
} else {
g2->mysql_connected = 1;
row = db_read("SELECT COUNT(nick) FROM rb.users");
if (row.num_fields >= 1)
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_INFO, "%s: total users: %d", name, (int) atoi(row.r[0]));
db_row_clean(row);
row = db_read("SELECT COUNT(crc) FROM rb.csvs");
if (row.num_fields >= 1)
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_INFO, "%s: total files: %d", name, (int) atoi(row.r[0]));
db_row_clean(row);
}
return (MODULE_HOOK_EVERY20SEC);
}
/* check that the given text is an IP address or hostname and store it as external DCC IP */
void update_natip(const char *var)
{
struct hostent *hp;
struct in_addr old;
struct in_addr in;
ir_uint32 oldip;
char *oldtxt;
updatecontext();
if (var == NULL)
return;
gnetwork->usenatip = 1;
if (gnetwork->myip.sa.sa_family != AF_INET)
return;
if (gnetwork->r_ourip != 0)
return;
bzero((char *)&in, sizeof(in));
if (inet_aton(var, &in) == 0) {
hp = gethostbyname(var);
if (hp == NULL) {
outerror(OUTERROR_TYPE_WARN_LOUD, "Invalid NAT Host, Ignoring: %s", hstrerror(h_errno));
return;
}
if ((unsigned)hp->h_length > sizeof(in) || hp->h_length < 0) {
outerror(OUTERROR_TYPE_WARN_LOUD, "Invalid DNS response, Ignoring: %s", hstrerror(h_errno));
return;
}
memcpy(&in, hp->h_addr_list[0], sizeof(in));
}
old.s_addr = htonl(gnetwork->ourip);
if (old.s_addr == in.s_addr)
return;
oldip = gnetwork->ourip;
gnetwork->ourip = ntohl(in.s_addr);
if (oldip != gnetwork->ourip) {
oldtxt = mystrdup(inet_ntoa(old));
ioutput(OUT_S|OUT_L|OUT_D, COLOR_YELLOW,
"DCC IP changed from %s to %s on %s", oldtxt, inet_ntoa(in), gnetwork->name);
mydelete(oldtxt);
update_getip_net(gnetwork->net, gnetwork->ourip);
}
if (gdata.debug > 0) ioutput(OUT_S|OUT_L, COLOR_YELLOW, "ip=%s\n", inet_ntoa(in));
/* check for 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 */
if (((gnetwork->ourip & 0xFF000000U) == 0x0A000000U) ||
((gnetwork->ourip & 0xFFF00000U) == 0xAC100000U) ||
((gnetwork->ourip & 0xFFFF0000U) == 0xC0A80000U)) {
outerror(OUTERROR_TYPE_WARN_LOUD, "usenatip of %s looks wrong, this is probably not what you want to do",
inet_ntoa(in));
}
}
static void ir_kqueue_update(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds)
{
int fd;
int max;
int reading;
int writing;
max = nfds * 3;
if (ir_kqueue_event_max > max) {
ir_kqueue_event_max = max;
ir_kqueue_set_buffer();
}
for (fd = 0; fd < nfds; ++fd) {
reading = FD_ISSET(fd, &ir_kqueue_readset);
writing = FD_ISSET(fd, &ir_kqueue_writeset);
if (reading) {
if (FD_ISSET(fd, readfds) == 0) {
++ir_kqueue_change_size;
EV_SET(&ir_kqueue_change_buffer[ir_kqueue_change_size - 1], fd, EVFILT_READ, EV_DELETE, 0, 0, 0);
FD_CLR(fd, &ir_kqueue_readset);
if ( gdata.debug > 3 )
ioutput(OUT_S|OUT_D, COLOR_YELLOW, "kqueue del read %d", fd); /* NOTRANSLATE */
}
}
if (writing) {
if (FD_ISSET(fd, writefds) == 0) {
++ir_kqueue_change_size;
EV_SET(&ir_kqueue_change_buffer[ir_kqueue_change_size - 1], fd, EVFILT_WRITE, EV_DELETE, 0, 0, 0);
FD_CLR(fd, &ir_kqueue_writeset);
if( gdata.debug > 3 )
ioutput(OUT_S|OUT_D, COLOR_YELLOW, "kqueue del write %d", fd); /* NOTRANSLATE */
}
}
if (reading == 0) {
if (FD_ISSET(fd, readfds)) {
++ir_kqueue_change_size;
EV_SET(&ir_kqueue_change_buffer[ir_kqueue_change_size - 1], fd, EVFILT_READ, EV_ADD | EV_ENABLE, NOTE_EOF, 0, 0);
FD_SET(fd, &ir_kqueue_readset);
if ( gdata.debug > 3 )
ioutput(OUT_S|OUT_D, COLOR_YELLOW, "kqueue add read %d", fd); /* NOTRANSLATE */
}
}
if (writing == 0) {
if (FD_ISSET(fd, writefds)) {
++ir_kqueue_change_size;
EV_SET(&ir_kqueue_change_buffer[ir_kqueue_change_size - 1], fd, EVFILT_WRITE, EV_ADD | EV_ENABLE, NOTE_EOF, 0, 0);
FD_SET(fd, &ir_kqueue_writeset);
if( gdata.debug > 3 )
ioutput(OUT_S|OUT_D, COLOR_YELLOW, "kqueue add write %d", fd); /* NOTRANSLATE */
}
}
}
FD_ZERO(readfds);
FD_ZERO(writefds);
FD_ZERO(exceptfds);
}
/* complete the connection to the IRC server */
static unsigned int connectirc2(res_addrinfo_t *remote)
{
int retval;
int family;
if (remote->ai_reset)
gnetwork->serv_resolv.next = 0;
family = remote->ai_addr.sa_family;
gnetwork->ircserver = socket(family, remote->ai_socktype, remote->ai_protocol);
if (gnetwork->ircserver < 0) {
outerror(OUTERROR_TYPE_WARN_LOUD, "Socket Error: %s", strerror(errno));
return 1;
}
if (gdata.debug > 0) {
char *msg;
msg = mymalloc(maxtextlength);
my_getnameinfo(msg, maxtextlength -1, &(remote->ai_addr));
ioutput(OUT_S, COLOR_YELLOW, "Connecting to %s", msg);
mydelete(msg);
}
if (bind_irc_vhost(family, gnetwork->ircserver) != 0) {
outerror(OUTERROR_TYPE_WARN_LOUD, "Couldn't Bind To Virtual Host");
event_close(gnetwork->ircserver);
return 1;
}
if (set_socket_nonblocking(gnetwork->ircserver, 1) < 0 )
outerror(OUTERROR_TYPE_WARN, "Couldn't Set Non-Blocking");
alarm(CTIMEOUT);
retval = connect(gnetwork->ircserver, &(remote->ai_addr), remote->ai_addrlen);
if ( (retval < 0) && !((errno == EINPROGRESS) || (errno == EAGAIN)) ) {
outerror(OUTERROR_TYPE_WARN_LOUD, "Connection to Server Failed: %s", strerror(errno));
alarm(0);
event_close(gnetwork->ircserver);
return 1;
}
alarm(0);
if (gdata.debug > 0) {
ioutput(OUT_S, COLOR_YELLOW, "ircserver socket = %d", gnetwork->ircserver);
}
gnetwork->lastservercontact=gdata.curtime;
/* good */
gnetwork->serverstatus = SERVERSTATUS_TRYING;
return 0;
}
int mod_load(char *name, Function *f2, struct global_t * g2) {
f = f2;
context();
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_DEBUG, "module %s loading", name);
return (MODULE_HOOK_IRCINPUT);
}
static unsigned int telnet_open_listen(unsigned int i)
{
char *vhost = NULL;
char *msg;
unsigned int rc;
ir_sockaddr_union_t listenaddr;
updatecontext();
vhost = irlist_get_nth(&gdata.telnet_vhost, i);
if (vhost == NULL)
return 1;
rc = open_listen(0, &listenaddr, &(telnet_listen[i]), gdata.telnet_port, 1, 0, vhost);
if (rc != 0)
return 1;
telnet_family[i] = listenaddr.sa.sa_family;
msg = mymalloc(maxtextlength);
my_getnameinfo(msg, maxtextlength -1, &listenaddr.sa);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_MAGENTA,
"Telnet SERVER waiting for connection on %s", msg);
mydelete(msg);
return 0;
}
/* check permissions and setup the upload transfer */
void upload_start(const char *nick, const char *hostname, const char *hostmask,
const char *filename, const char *remoteip, const char *remoteport, const char *bytes, char *token)
{
upload *ul;
char *uploaddir;
char *tempstr;
off_t len;
updatecontext();
len = atoull(bytes);
if (invalid_upload(nick, hostmask, len))
return;
uploaddir = get_uploaddir(hostmask);
if (uploaddir == NULL) {
error_upload_start(nick, hostmask, "no uploaddir", "No uploaddir defined.");
return;
}
if (disk_full(uploaddir) != 0) {
error_upload_start(nick, hostmask, "disk full", "not enough free space on disk");
return;
}
if (file_uploading(filename) != 0) {
error_upload_start(nick, hostmask, "upload running", "I'm already getting this file");
return;
}
if (max_uploads_reached() != 0) {
error_upload_start(nick, hostmask, "too many uploads", "I'm already getting too many files");
return;
}
ul = irlist_add(&gdata.uploads, sizeof(upload));
l_initvalues(ul);
ul->file = mystrdup(getfilename(filename));
ul->con.family = (strchr(remoteip, ':')) ? AF_INET6 : AF_INET;
ul->con.remoteaddr = mystrdup(remoteip);
ul->con.remoteport = atoi(remoteport);
ul->totalsize = len;
ul->nick = mystrdup(nick);
ul->hostname = mystrdup(hostname);
ul->uploaddir = mystrdup(uploaddir);
ul->net = gnetwork->net;
qupload_started(gnetwork->net, nick);
tempstr = getsendname(ul->file);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_YELLOW,
"DCC Send Accepted from %s on %s: %s (%" LLPRINTFMT "dkB)",
nick, gnetwork->name, tempstr,
(ul->totalsize / 1024));
mydelete(tempstr);
if (gdata.mirc_dcc64)
if (ul->totalsize > 0xFFFFFFFFL)
ul->mirc_dcc64 = 1;
if (ul->con.remoteport > 0U) {
l_establishcon(ul);
} else {
/* Passive DCC */
l_setup_passive(ul, token);
}
}
static void error_upload_start(const char *nick, const char *hostmask, const char *key, const char *msg)
{
notice(nick, "DCC Send Denied, %s", msg);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_MAGENTA,
"DCC Send Denied (%s) from %s on %s",
key, hostmask, gnetwork->name);
}
static int l_setup_listen(upload * const l)
{
char *tempstr;
char *msg;
unsigned int rc;
updatecontext();
rc = irc_open_listen(&(l->con));
if (rc != 0) {
l_closeconn(l, "Connection Lost", 0);
return 1;
}
msg = setup_dcc_local(&(l->con.local));
tempstr = getsendname(l->file);
privmsg_fast(l->nick, IRC_CTCP "DCC SEND %s %s %" LLPRINTFMT "d %u" IRC_CTCP, /* NOTRANSLATE */
tempstr, msg, l->totalsize, l->token);
mydelete(msg);
msg = mymalloc(maxtextlength);
my_getnameinfo(msg, maxtextlength -1, &(l->con.local.sa));
ioutput(OUT_S|OUT_L|OUT_D, COLOR_MAGENTA,
"DCC SEND sent to %s on %s, waiting for connection on %s",
l->nick, gnetwork->name, msg);
mydelete(tempstr);
mydelete(msg);
l->ul_status = UPLOAD_STATUS_LISTENING;
return 0;
}
/* handle message from irc server */
static void ir_parseline(char *line)
{
ir_parseline_t ipl;
unsigned int m;
updatecontext();
removenonprintable(line);
#ifdef USE_RUBY
if (do_myruby_server(line))
return;
#endif /* USE_RUBY */
/* we only support lines upto maxtextlength, truncate line */
line[maxtextlength-1] = '\0';
if (gdata.debug > 14)
ioutput(OUT_S|OUT_L, COLOR_CYAN, ">IRC>: %u, %s", gnetwork->net + 1, line);
bzero((char *)&ipl, sizeof(ipl));
ipl.line = line;
m = get_argv(ipl.part, line, MAX_IRCMSG_PARTS);
if (ipl.part[1] != NULL)
ir_parseline2(&ipl);
for (m = 0; m < MAX_IRCMSG_PARTS; ++m)
mydelete(ipl.part[m]);
}
/* send DCC command to start download */
void t_start_dcc_send(transfer *tr)
{
char *dccdata;
char *sendnamestr;
updatecontext();
sendnamestr = getsendname(tr->xpack->file);
dccdata = setup_dcc_local(&tr->con.local);
if (tr->passive_dcc) {
bzero((char *) &(tr->con.local), sizeof(tr->con.local));
privmsg_fast(tr->nick, IRC_CTCP "DCC SEND %s %s %" LLPRINTFMT "d %u" IRC_CTCP, /* NOTRANSLATE */
sendnamestr, dccdata,
tr->xpack->st_size,
tr->id);
} else {
privmsg_fast(tr->nick, IRC_CTCP "DCC SEND %s %s %" LLPRINTFMT "d" IRC_CTCP, /* NOTRANSLATE */
sendnamestr, dccdata,
tr->xpack->st_size);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_YELLOW,
"listen on port %d for %s (%s on %s)",
tr->con.localport, tr->nick, tr->hostname, gnetwork->name);
}
mydelete(dccdata);
mydelete(sendnamestr);
}
static void update_getip_net(unsigned int net, ir_uint32 ourip)
{
char *oldtxt;
gnetwork_t *backup;
struct in_addr old;
struct in_addr in;
unsigned int ss;
in.s_addr = htonl(ourip);
backup = gnetwork;
for (ss=0; ss<gdata.networks_online; ++ss) {
gnetwork = &(gdata.networks[ss]);
if (gnetwork->net == net)
continue;
if (gnetwork->getip_net != net)
continue;
if (gnetwork->ourip == ourip)
continue;
gnetwork->usenatip = 1;
old.s_addr = htonl(gnetwork->ourip);
oldtxt = mystrdup(inet_ntoa(old));
ioutput(OUT_S|OUT_L|OUT_D, COLOR_YELLOW,
"DCC IP changed from %s to %s on %s", oldtxt, inet_ntoa(in), gnetwork->name);
mydelete(oldtxt);
gnetwork->ourip = ourip;
}
gnetwork = backup;
}
static void t_find_debug(const char *nick, const char *filename, const char *remoteport)
{
transfer *tr;
outerror(OUTERROR_TYPE_WARN,
"Couldn't find transfer that %s on %s tried to resume!",
nick, gnetwork->name);
outerror(OUTERROR_TYPE_WARN,
"resume trying %s, %s, %d",
nick, filename, atoi(remoteport));
if (gdata.debug == 0)
return;
for (tr = irlist_get_head(&gdata.trans);
tr;
tr = irlist_get_next(tr)) {
ioutput(OUT_S, COLOR_NO_COLOR,
"transfer %u: %s on %s, %s, %d\n",
tr->tr_status,
tr->caps_nick,
gdata.networks[tr->net].name,
tr->xpack->file,
tr->con.localport);
}
}
/* process successful connection */
static void t_connected(transfer *tr)
{
int callval_i;
int connect_error;
SIGNEDSOCK int connect_error_len = sizeof(connect_error);
tr->con.connecttime = gdata.curtime;
FD_CLR(tr->con.clientsocket, &gdata.writeset);
callval_i = getsockopt(tr->con.clientsocket,
SOL_SOCKET, SO_ERROR,
&connect_error, &connect_error_len);
if (callval_i < 0) {
outerror(OUTERROR_TYPE_WARN,
"Couldn't determine upload connection status on %s: %s",
gnetwork->name, strerror(errno));
t_closeconn(tr, "Download Connection Failed status:", errno);
return;
}
if (connect_error) {
t_closeconn(tr, "Download Connection Failed", connect_error);
return;
}
ioutput(OUT_S|OUT_L|OUT_D, COLOR_MAGENTA,
"Download Connection Established on %s", gnetwork->name);
t_setup_send(tr);
return;
}
static void select_dump(const char *desc, int highests)
{
char buffer[maxtextlength];
size_t len;
int ii;
len = 0;
len += add_snprintf(buffer + len, maxtextlength - len, "select %s: [read", desc);
for (ii=0; ii<highests+1; ii++)
{
if (FD_ISSET(ii, &gdata.readset))
{
len += add_snprintf(buffer + len, maxtextlength - len, " %d", ii);
}
}
len += add_snprintf(buffer + len, maxtextlength - len, "] [write");
for (ii=0; ii<highests+1; ii++)
{
if (FD_ISSET(ii, &gdata.writeset))
{
len += add_snprintf(buffer + len, maxtextlength - len, " %d", ii);
}
}
len += add_snprintf(buffer + len, maxtextlength - len, "]");
ioutput(OUT_S, COLOR_CYAN, "%s", buffer);
}
int mod_unload(char *name, struct global_t * g2) {
context();
mysql_close(g2->mysql_dbh);
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_DEBUG, "module %s unloading", name);
return (T_OK);
}
void signal_alarm(int sig) {
signal(SIGALRM, signal_alarm);
sig = sig;
context();
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_INFO, "got alarm!");
return;
}
/* setup the curl lib */
void curl_startup(void)
{
CURLcode cs;
bzero((char *)&fetch_trans, sizeof(fetch_trans));
fetch_started = 0;
fetch_id = 0;
cs = curl_global_init(CURL_GLOBAL_ALL);
if (cs != 0) {
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"curl_global_init failed with %d", cs);
}
cm = curl_multi_init();
if (cm == NULL) {
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"curl_multi_init failed");
}
}
static void t_unlmited2(transfer * const tr, const char *hostmask)
{
tr->unlimited = verifyshell(&gdata.unlimitedhost, hostmask);
if (!tr->unlimited)
return;
tr->nomax = tr->unlimited;
ioutput(OUT_S|OUT_L|OUT_D, COLOR_YELLOW,
"unlimitedhost found: %s (%s on %s)",
tr->nick, hostmask, gnetwork->name);
}
static void irc_server_timeout(void)
{
int timeout;
timeout = irc_server_is_timeout();
if (timeout > 0) {
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Server Connection Timed Out (%u seconds) on %s", timeout, gnetwork->name);
close_server();
}
}
/* check ip for matching blacklist and whitelist */
unsigned int t_check_ip_access(transfer *const tr)
{
const char *msg;
if (irlist_size(&gdata.xdcc_allow) > 0) {
if (!verify_cidr(&gdata.xdcc_allow, &(tr->con.remote))) {
msg = "Sorry, downloads to your IP not allowed, ask owner.";
t_closeconn(tr, msg, 0);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR, "%s", msg);
return 1;
}
}
if (verify_cidr(&gdata.xdcc_deny, &(tr->con.remote))) {
msg = "Sorry, downloads to your IP denied, ask owner.";
t_closeconn(tr, msg, 0);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR, "%s", msg);
return 1;
}
return 0;
}
void setupdccchatconnected(dccchat_t *chat)
{
ioutput(OUT_S|OUT_L|OUT_D, COLOR_MAGENTA,
"DCC CHAT connection succeeded, authenticating");
chat->status = DCCCHAT_AUTHENTICATING;
chat->con.connecttime = gdata.curtime;
chat->con.lastcontact = gdata.curtime;
ir_boutput_init(&chat->boutput, chat->con.clientsocket, 0);
setup_chat_banner(chat);
}
void signal_shutdown(int sig) {
signal(SIGINT, signal_shutdown);
signal(SIGTERM, signal_shutdown);
sig = sig;
context();
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_INFO, "got signal shutdown (SIGINT/TERM) !");
g.serverstatus = SERVER_STATUS_EXIT;
return;
}
int mod_every20sec(struct global_t * g2) {
context();
if ( mysql_ping(g2->mysql_dbh) ) {
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "Failed to connect to database (%s)", mysql_error(g2->mysql_dbh));
g2->mysql_connected = 0;
} else
g2->mysql_connected = 1;
return (T_IGNORE);
}
/* check the welcome message from the server for an IP address or hostname to set external DCC IP */
static void update_server_welcome(char *line)
{
const char *tptr;
updatecontext();
#ifdef USE_UPNP
if (gdata.getipfromupnp) {
tptr = upnp_get_dccip();
if (tptr != NULL) {
ioutput(OUT_S|OUT_L, COLOR_NO_COLOR, "IP From UPnP = %s", tptr);
update_natip(tptr);
return;
}
}
#endif /* USE_UPNP */
if (gdata.getipfromserver) {
tptr = strchr(line, '@');
if (tptr != NULL) {
++tptr;
ioutput(OUT_S|OUT_L, COLOR_NO_COLOR, "IP From Server: %s", tptr);
update_natip(tptr);
return;
}
if (gnetwork->getip_net != gnetwork->net) {
/* copy IP from master */
gnetwork->usenatip = 1;
update_getip_net(gnetwork->getip_net, gdata.networks[gnetwork->getip_net].ourip);
return;
}
}
if (gnetwork->natip) {
update_natip(gnetwork->natip);
return;
}
if (gdata.usenatip) {
/* use global */
update_natip(gdata.usenatip);
}
}
void signal_user1(int sig) {
signal(SIGUSR1, signal_user1);
sig = sig;
context();
ioutput(OUTPUT_DEST_LOG | OUTPUT_DEST_NO | OUTPUT_TYPE_DEBUG, "changing servers");
server_write((char *) "QUIT :changing servers", SERVER_SEND_NOW);
FD_CLR(g.serversocket, &g.readset);
close(g.serversocket);
module_serverquit();
g.serverstatus = SERVER_STATUS_NOTCONNECTED;
return;
}
void setupdccchataccept(dccchat_t *chat)
{
SIGNEDSOCK int addrlen;
char *msg;
updatecontext();
addrlen = sizeof(struct sockaddr_in);
if ((chat->con.clientsocket = accept(chat->con.listensocket, &(chat->con.remote.sa), &addrlen)) < 0)
{
outerror(OUTERROR_TYPE_WARN,"Accept Error, Aborting: %s",strerror(errno));
event_close(chat->con.listensocket);
chat->con.clientsocket = FD_UNUSED;
chat->con.listensocket = FD_UNUSED;
return;
}
ir_listen_port_connected(chat->con.localport);
event_close(chat->con.listensocket);
chat->con.listensocket = FD_UNUSED;
ioutput(OUT_S|OUT_L|OUT_D, COLOR_MAGENTA,
"DCC CHAT connection received, authenticating");
if (set_socket_nonblocking(chat->con.clientsocket, 1) < 0 )
{
outerror(OUTERROR_TYPE_WARN,"Couldn't Set Non-Blocking");
}
if (is_in_badip(&(chat->con.remote))) {
shutdowndccchat(chat, 0);
return;
}
chat->status = DCCCHAT_AUTHENTICATING;
chat->con.connecttime = gdata.curtime;
chat->con.lastcontact = gdata.curtime;
ir_boutput_init(&chat->boutput, chat->con.clientsocket, 0);
msg = mymalloc(maxtextlength);
my_getnameinfo(msg, maxtextlength -1, &(chat->con.remote.sa));
chat->con.remoteaddr = mystrdup(msg);
mydelete(msg);
setup_chat_banner(chat);
}
void signal_user2(int sig) {
int i;
signal(SIGUSR2, signal_user2);
sig = sig;
context();
ioutput(OUTPUT_DEST_CORE | OUTPUT_TYPE_DEBUG, "-------------------------------------------");
ioutput(OUTPUT_DEST_LOG | OUTPUT_DEST_NO | OUTPUT_DEST_CORE | OUTPUT_TYPE_DEBUG, "context trace");
context_dump(OUTPUT_DEST_CORE);
ioutput(OUTPUT_DEST_CORE | OUTPUT_TYPE_DEBUG, "-------------------------------------------");
ioutput(OUTPUT_DEST_LOG | OUTPUT_DEST_NO | OUTPUT_DEST_CORE | OUTPUT_TYPE_DEBUG, "memory trace");
ioutput(OUTPUT_DEST_LOG | OUTPUT_DEST_CORE | OUTPUT_TYPE_DEBUG, "%i memory units allocated", g.meminfo_depth);
memory_dump(OUTPUT_DEST_CORE);
ioutput(OUTPUT_DEST_CORE | OUTPUT_TYPE_DEBUG, "-------------------------------------------");
ioutput(OUTPUT_DEST_LOG | OUTPUT_DEST_NO | OUTPUT_DEST_CORE | OUTPUT_TYPE_DEBUG, "timer queue dump");
for (i=0; i<TIMER_QUEUE_SIZE; i++)
ioutput(OUTPUT_DEST_CORE | OUTPUT_TYPE_DEBUG, "timer %d/%d value (%d)", i, TIMER_QUEUE_SIZE, g.timer_wait_queue[i]);
ioutput(OUTPUT_DEST_CORE | OUTPUT_TYPE_DEBUG, "-------------------------------------------");
module_dumpstatus();
return;
}
