/* show running transfers */
void dinoex_dcl(const userinput *const u)
{
fetch_curl_t *ft;
fetch_queue_t *fq;
double dl_total;
double dl_size;
int progress;
updatecontext();
for (ft = irlist_get_head(&fetch_trans); ft; ft = irlist_get_next(ft)) {
dl_size = 0.0;
curl_easy_getinfo(ft->curlhandle, CURLINFO_SIZE_DOWNLOAD, &dl_size);
dl_total = 0.0;
curl_easy_getinfo(ft->curlhandle, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &dl_total);
progress = 0;
progress = ((dl_size + 50) * 100) / max2(dl_total, 1);
a_respond(u, " %2i fetch %-32s Receiving %d%%", ft->id, ft->name, progress);
}
updatecontext();
progress = 0;
for (fq = irlist_get_head(&gdata.fetch_queue); fq; fq = irlist_get_next(fq)) {
a_respond(u, " %2i fetch %-32s Waiting", ++progress, fq->name);
}
}
/* show running transfers in detail */
void dinoex_dcld(const userinput *const u)
{
fetch_curl_t *ft;
fetch_queue_t *fq;
char *effective_url;
double dl_total;
double dl_size;
double dl_speed;
double dl_time;
int progress;
int started;
int left;
updatecontext();
for (ft = irlist_get_head(&fetch_trans); ft; ft = irlist_get_next(ft)) {
dl_size = 0.0;
curl_easy_getinfo(ft->curlhandle, CURLINFO_SIZE_DOWNLOAD, &dl_size);
dl_total = 0.0;
curl_easy_getinfo(ft->curlhandle, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &dl_total);
dl_speed = 0.0;
curl_easy_getinfo(ft->curlhandle, CURLINFO_SPEED_DOWNLOAD, &dl_speed);
dl_time = 0.0;
curl_easy_getinfo(ft->curlhandle, CURLINFO_TOTAL_TIME, &dl_time);
effective_url = NULL;
curl_easy_getinfo(ft->curlhandle, CURLINFO_EFFECTIVE_URL, &effective_url);
started = min2(359999, gdata.curtime - ft->starttime);
left = min2(359999, (dl_total - dl_size) /
((int)(max2(dl_speed, 1))));
progress = ((dl_size + 50) * 100) / max2(dl_total, 1);
a_respond(u, " %2i fetch %-32s Receiving %d%%", ft->id, ft->name, progress);
a_respond(u, " %s", effective_url ? effective_url : ft->url);
a_respond(u, " ^- %5.1fK/s %6" LLPRINTFMT "dK/%6" LLPRINTFMT "dK %2i%c%02i%c/%2i%c%02i%c",
(float)(dl_speed/1024),
(ir_int64)(dl_size/1024),
(ir_int64)(dl_total/1024),
started < 3600 ? started/60 : started/60/60 ,
started < 3600 ? 'm' : 'h',
started < 3600 ? started%60 : (started/60)%60 ,
started < 3600 ? 's' : 'm',
left < 3600 ? left/60 : left/60/60 ,
left < 3600 ? 'm' : 'h',
left < 3600 ? left%60 : (left/60)%60 ,
left < 3600 ? 's' : 'm');
}
updatecontext();
progress = 0;
for (fq = irlist_get_head(&gdata.fetch_queue); fq; fq = irlist_get_next(fq)) {
a_respond(u, " %2i fetch %-32s Waiting", ++progress, fq->name);
a_respond(u, " %s", fq->url);
}
}
/* check a new transfer */
static void t_check_new_connection(transfer *const tr)
{
t_establishcon(tr);
#ifdef USE_GEOIP
updatecontext();
geoip_new_connection(tr);
#endif /* USE_GEOIP */
updatecontext();
t_check_duplicateip(tr);
}
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);
}
}
/* check if this host is allowed to send */
static int verify_uploadhost(const char *hostmask)
{
tupload_t *tu;
qupload_t *qu;
updatecontext();
if ( verifyupload_group(hostmask) != NULL )
return 0;
if ( verifyshell(&gdata.uploadhost, hostmask) != 0 )
return 0;
for (tu = irlist_get_head(&gdata.tuploadhost);
tu;
tu = irlist_get_next(tu)) {
if (tu->u_time <= gdata.curtime)
continue;
if (fnmatch(tu->u_host, hostmask, FNM_CASEFOLD) == 0)
return 0;
}
for (qu = irlist_get_head(&gdata.quploadhost);
qu;
qu = irlist_get_next(qu)) {
if (gnetwork->net != qu->q_net)
continue;
if (fnmatch(qu->q_host, hostmask, FNM_CASEFOLD) == 0)
return 0;
}
return 1;
}
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;
}
/* verify a password against the stored hash */
unsigned int verifypass2(const char *masterpass, const char *testpass)
{
#ifndef NO_CRYPT
char *pwout;
#endif /* NO_CRYPT */
updatecontext();
if (!masterpass || !testpass)
return 0;
#ifndef NO_CRYPT
if ((strlen(masterpass) < 13U) ||
(strlen(testpass) < 5U) ||
(strlen(testpass) > 59U))
return 0;
pwout = crypt(testpass, masterpass);
if (strcmp(pwout, masterpass)) return 0;
#else /* NO_CRYPT */
if (!masterpass || !testpass)
return 0;
if (strcmp(testpass, masterpass)) return 0;
#endif /* NO_CRYPT */
/* allow */
return 1;
}
/* check the given passwort matches hostmask and groups */
unsigned int dcc_host_password(dccchat_t *chat, char *passwd)
{
group_admin_t *ga;
updatecontext();
if ( verifyshell(&gdata.adminhost, chat->hostmask) ) {
if ( verifypass2(gdata.adminpass, passwd) ) {
chat->level = gdata.adminlevel;
return 1;
}
return 2;
}
if ( verifyshell(&gdata.hadminhost, chat->hostmask) ) {
if ( verifypass2(gdata.hadminpass, passwd) ) {
chat->level = gdata.hadminlevel;
return 1;
}
return 2;
}
if ((ga = verifypass_group(chat->hostmask, passwd))) {
chat->level = ga->g_level;
chat->groups = mystrdup(ga->g_groups);
return 1;
}
return 0;
}
static void load_script(const char *name)
{
struct stat st;
int rc;
updatecontext();
if (!name)
return;
if (stat(name, &st) < 0) {
myruby_loaded = -1;
outerror(OUTERROR_TYPE_WARN_LOUD,
"cannot access '%s', ignoring: %s",
name, strerror(errno));
return;
}
ruby_script(name);
myruby_time = st.st_mtime;
rb_load_protect(rb_str_new(name, strlen(name)), 0, &rc);
if (rc != 0) {
outerror(OUTERROR_TYPE_WARN_LOUD,
"ruby_exec failed with %d: %s",
rc, strerror(errno));
myruby_loaded = 1;
return;
}
myruby_loaded = 1;
oIrofferEvent = rb_class_new_instance(0, NULL, cIrofferEvent);
rb_define_variable("objIrofferEvent", &oIrofferEvent); /* NOTRANSLATE */
}
/* cancel a running fetch command */
unsigned int fetch_cancel(unsigned int num)
{
fetch_curl_t *ft;
CURLMcode cms;
updatecontext();
ft = irlist_get_head(&fetch_trans);
while (ft) {
if (num > 0) {
if (ft->id != num) {
ft = irlist_get_next(ft);
continue;
}
}
a_respond(&(ft->u), "fetch '%s' canceled", ft->name);
cms = curl_multi_remove_handle(cm, ft->curlhandle);
if ( cms != 0 ) {
outerror(OUTERROR_TYPE_WARN_LOUD, "curl_multi_remove_handle() = %d", cms);
}
--fetch_started;
ft = clean_fetch(ft);
start_qupload();
return 0;
}
return 1;
}
static void my_get_upnp_data(const struct sockaddr *sa)
{
#if !defined(NO_GETADDRINFO)
char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
socklen_t salen;
salen = (sa->sa_family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
if (getnameinfo(sa, salen, hbuf, sizeof(hbuf), sbuf,
sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) {
outerror(OUTERROR_TYPE_WARN_LOUD, "Invalid IP: %s", "upnp_router");
return;
}
#else /* NO_GETADDRINFO */
const struct sockaddr_in *remoteaddr = (const struct sockaddr_in *)sa;
ir_uint32 to_ip;
char hbuf[maxtextlengthshort], sbuf[maxtextlengthshort];
to_ip = ntohl(remoteaddr->sin_addr.s_addr);
snprintf(hbuf, sizeof(hbuf), IPV4_PRINT_FMT,
IPV4_PRINT_DATA(to_ip));
snprintf(sbuf, sizeof(sbuf), "%d", ntohs(remoteaddr->sin_port)); /* NOTRANSLATE */
#endif /* NO_GETADDRINFO */
if (sa->sa_family != AF_INET)
return;
updatecontext();
upnp_add_redir(hbuf, sbuf);
}
/* set all options for a transfer connection */
void ir_setsockopt(int clientsocket)
{
#if !defined(CANT_SET_TOS)
int tempc;
#endif
int nodelay = 1;
int rc;
updatecontext();
if (gdata.tcp_buffer_size > 0) {
ir_setsockopt2(clientsocket, SO_SNDBUF, "SO_SNDBUF", gdata.tcp_buffer_size); /* NOTRANSLATE */
ir_setsockopt2(clientsocket, SO_RCVBUF, "SO_RCVBUF", gdata.tcp_buffer_size); /* NOTRANSLATE */
}
#if !defined(CANT_SET_TOS)
/* Set TOS socket option to max throughput */
tempc = 0x8; /* IPTOS_THROUGHPUT */
setsockopt(clientsocket, IPPROTO_IP, IP_TOS, &tempc, sizeof(int));
#endif
if (gdata.tcp_nodelay != 0) {
rc = setsockopt(clientsocket, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));
if (rc < 0)
outerror(OUTERROR_TYPE_WARN, "Couldn't Set TCP_NODELAY");
}
if (set_socket_nonblocking(clientsocket, 1) < 0 )
outerror(OUTERROR_TYPE_WARN, "Couldn't Set Non-Blocking");
}
/* call a ruby script as CGI via HTTP */
unsigned int http_ruby_script(const char *name, const char *output)
{
struct stat st;
char *tempstr;
int rc;
updatecontext();
if (!name)
return 1;
if (stat(name, &st) < 0) {
outerror(OUTERROR_TYPE_WARN_LOUD,
"cannot access '%s', ignoring: %s",
name, strerror(errno));
return 1;
}
ruby_script(name);
tempstr = mymalloc(maxtextlength);
snprintf(tempstr, maxtextlength, "$stdout = File.new(\"%s\", \"w+\")", output); /* NOTRANSLATE */
rb_eval_string_protect(tempstr, &rc);
mydelete(tempstr);
rb_load_protect(rb_str_new(name, strlen(name)), 0, &rc);
if (rc != 0) {
outerror(OUTERROR_TYPE_WARN_LOUD,
"ruby_exec failed with %d: %s",
rc, strerror(errno));
iroffer_ruby_errro(rc);
}
rb_eval_string_protect("$stdout.close", &rc); /* NOTRANSLATE */
if (rc != 0)
return 1;
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);
}
/* 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));
}
}
/* from curl tool_cb_hdr.c, Copyright (C) 1998 - 2011, Daniel Stenberg */
static size_t fetch_header_cb(void *ptr, size_t size, size_t nmemb, void *userdata)
{
const size_t cb = size * nmemb;
const size_t failure = (cb) ? 0 : 1;
fetch_curl_t *ft = userdata;
char *temp;
char *work;
char *end;
size_t len;
updatecontext();
if (ft == NULL)
return cb; /* ignore */
#ifdef DEBUG
if(size * nmemb > (size_t)CURL_MAX_HTTP_HEADER) {
outerror(OUTERROR_TYPE_WARN_LOUD, "Header data = %ld exceeds single call write limit!", size);
return failure;
}
#endif
temp = mystrdup(ptr);
len = cb;
if (temp[len - 1] == '\n') {
--(len);
if (temp[len - 1] == '\r') {
--(len);
}
}
temp[len] = 0;
if ((gdata.debug > 0) && (cb > 2)) {
a_respond(&(ft->u), "FETCH header '%s'", temp);
}
if (cb >= 20) {
if (strncasecmp("Content-disposition:", temp, 20) == 0) { /* NOTRANSLATE */
/* look for the 'filename=' parameter
(encoded filenames (*=) are not supported) */
work = strstr(temp + 20, "filename="); /* NOTRANSLATE */
if (work != NULL) {
work += 9;
/* stop at first ; */
end = strchr(work, ';');
if (end != NULL)
*end = 0;
ft->contentname = mystrdup(work);
clean_quotes(ft->contentname);
a_respond(&(ft->u), "FETCH filename '%s'", ft->contentname);
}
}
}
mydelete(temp);
return cb;
}
/* check if a file is already in transfer */
unsigned int fetch_is_running(const char *file)
{
fetch_curl_t *ft;
updatecontext();
for (ft = irlist_get_head(&fetch_trans); ft; ft = irlist_get_next(ft)) {
if (strcmp(ft->name, file) == 0)
return 1;
}
return 0;
}
void t_initvalues (transfer * const t) {
updatecontext();
t->tr_status = TRANSFER_STATUS_UNUSED;
t->con.listensocket = FD_UNUSED;
t->con.clientsocket = FD_UNUSED;
t->con.lastcontact = gdata.curtime;
t->id = 200;
t->overlimit = 0;
}
void writestatus(dccchat_t *chat) {
char *tempstr;
updatecontext();
tempstr = mymalloc(maxtextlength);
getstatusline(tempstr,maxtextlength);
writedccchat(chat,0,"%s\n",tempstr);
mydelete(tempstr);
}
/* open file on disk for upload */
int l_setup_file(upload * const l, struct stat *stp)
{
char *fullfile;
int retval;
updatecontext();
if (l->uploaddir == NULL) {
l_closeconn(l, "No uploaddir defined.", 0);
return 1;
}
/* local file already exists? */
fullfile = mystrjoin(l->uploaddir, l->file, '/');
l->filedescriptor = open(fullfile,
O_WRONLY | O_CREAT | O_EXCL | ADDED_OPEN_FLAGS,
CREAT_PERMISSIONS );
if ((l->filedescriptor < 0) && (errno == EEXIST)) {
retval = stat(fullfile, stp);
if (retval < 0) {
outerror(OUTERROR_TYPE_WARN_LOUD, "Cant Stat Upload File '%s': %s",
fullfile, strerror(errno));
l_closeconn(l, "File Error, File couldn't be opened for writing", errno);
mydelete(fullfile);
return 1;
}
if (!S_ISREG(stp->st_mode) || (stp->st_size >= l->totalsize)) {
l_closeconn(l, "File Error, That filename already exists", 0);
mydelete(fullfile);
return 1;
}
l->filedescriptor = open(fullfile, O_WRONLY | O_APPEND | ADDED_OPEN_FLAGS);
if (l->filedescriptor >= 0) {
l->resumesize = l->bytesgot = stp->st_size;
if (l->resumed <= 0) {
close(l->filedescriptor);
mydelete(fullfile);
return 2; /* RESUME */
}
}
}
if (l->filedescriptor < 0) {
outerror(OUTERROR_TYPE_WARN_LOUD, "Cant Access Upload File '%s': %s",
fullfile, strerror(errno));
l_closeconn(l, "File Error, File couldn't be opened for writing", errno);
mydelete(fullfile);
return 1;
}
mydelete(fullfile);
return 0;
}
/* match a given file against a list of patterns */
unsigned int verifyshell(irlist_t *list, const char *file)
{
char *pattern;
updatecontext();
pattern = (char *)irlist_get_head(list);
while (pattern) {
if (fnmatch(pattern, file, FNM_CASEFOLD) == 0)
return 1;
pattern = (char *)irlist_get_next(pattern);
}
return 0;
}
void t_setuplisten (transfer * const t)
{
int rc;
updatecontext();
rc = irc_open_listen(&(t->con));
if (rc != 0)
{
t_closeconn(t,"Connection Error, Try Again",errno);
return;
}
t->tr_status = TRANSFER_STATUS_LISTENING;
}
/* check if a file is writeable */
unsigned int is_file_writeable(const char *f)
{
int fd;
updatecontext();
if (!f) return 0;
fd = open(f, O_WRONLY | O_EXCL | O_APPEND | ADDED_OPEN_FLAGS);
if (fd < 0)
return 0;
close(fd);
return 1;
}
/* search for a custom uploaddir of a group admin */
static char *verifyupload_group(const char *hostmask)
{
group_admin_t *ga;
updatecontext();
for (ga = irlist_get_head(&gdata.group_admin);
ga;
ga = irlist_get_next(ga)) {
if (fnmatch(ga->g_host, hostmask, FNM_CASEFOLD) == 0)
return ga->g_uploaddir;
}
return NULL;
}
/* remove temp uploadhosts */
void clean_uploadhost(void)
{
tupload_t *tu;
updatecontext();
for (tu = irlist_get_head(&gdata.tuploadhost);
tu; ) {
if (tu->u_time >= gdata.curtime) {
tu = irlist_get_next(tu);
continue;
}
mydelete(tu->u_host);
tu = irlist_delete(&gdata.tuploadhost, tu);
}
}
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);
}
/* start a transfer later */
static void fetch_later(const userinput *const u, const char *uploaddir, char *name, char *url)
{
fetch_queue_t *fq;
updatecontext();
fq = irlist_add(&gdata.fetch_queue, sizeof(fetch_queue_t));
fq->u.method = u->method;
if (u->snick != NULL) {
fq->u.snick = mystrdup(u->snick);
}
fq->u.fd = u->fd;
fq->u.chat = u->chat;
fq->net = gnetwork->net;
fq->name = mystrdup(name);
fq->url = mystrdup(url);
fq->uploaddir = mystrdup(uploaddir);
}
/* convert hostmask to fnmatch pattern */
char *hostmask_to_fnmatch(const char *str)
{
char *base;
char *dest;
const char *src;
size_t maxlen;
updatecontext();
if (!str) return NULL;
maxlen = 0;
for (src=str; *src; ++src, ++maxlen) {
if (*src == '#') {
maxlen += 10;
continue;
}
if ( (*src == '[') || (*src == ']') )
++maxlen;
}
base = (char *)mymalloc(maxlen + 1);
for (src=str, dest=base; *src; ++src) {
if (*src == '#') {
*(dest++) = '[';
*(dest++) = '0';
*(dest++) = '-';
*(dest++) = '9';
*(dest++) = ']';
*(dest++) = '[';
*(dest++) = '0';
*(dest++) = '-';
*(dest++) = '9';
*(dest++) = ']';
*(dest++) = '*';
continue;
}
if ( (*src == '[') || (*src == ']') ) {
*(dest++) = '\\';
}
*(dest++) = *src;
}
*dest = 0;
return base;
}
