/* dcc shtuff */

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include "eggdrop.h"

#define STDOUT   1

/* dcc list */
struct dcc_t dcc[MAXDCC];
/* total dcc's */
int dcc_total=0;
/* root dcc directory */
char dccdir[121]="";
/* directory to put incoming dcc's into */
char dccin[121]="";
/* if non-zero, accept telnets at this port */
int telnet_port=0;
/* file where the motd for dcc chat is stored */
char motdfile[121]="motd";

extern int serv;
extern char botname[];
extern char version[];
unsigned long getmyip();


/* show motd to dcc chatter */
void show_motd(z)
int z;
{
  FILE *vv; char s[81];
  vv=fopen(motdfile,"r"); if (vv!=NULL) {
    tprintf(z,"\n");
    while (!feof(vv)) {
      fgets(s,80,vv); if (!feof(vv)) tprintf(z,"%s",s);
    }
    fclose(vv);
    tprintf(z,"\n");
  }
}

void tell_who(z)
int z;
{
  int i,j; char s[121];
  for (j=0; dcc[j].sock!=z; j++);
  tprintf(z,"Party line members:  (* = master)\n");
  for (i=0; i<dcc_total; i++) if (dcc[i].type==DCC_CHAT) {
    sprintf(s,"  %c%-10s %s",dcc[i].status&STAT_MASTER?'*':' ',dcc[i].nick,
	    dcc[i].host);
    if (dcc[j].status&STAT_MASTER) {
      if (dcc[i].status&STAT_CONSOLE) strcat(s," (con)");
      if (dcc[i].status&STAT_TALK) strcat(s," (talk)");
      if (dcc[i].status&STAT_BLIND) strcat(s," (BLIND)");
    }
    tprintf(z,"%s\n",s);
  }
}

void dcc_chatter(z)
int z;
{
  int i,j;
  for (j=0; dcc[j].sock!=z; j++);
  tprintf(z,"Connected to %s, running %s\n",botname,version);
  tprintf(z,"You can send me commands this way.  Try '.help' or '.quit'.\n");
  show_motd(z);
  tell_who(z);
  tprintf(z,"Commands start with '.'\n");
  tprintf(z,"Everything else goes out to the party line.\n\n");
  for (i=0; i<dcc_total; i++) if (dcc[i].type==DCC_CHAT)
    tprintf(dcc[i].sock,"*** %s (%s) joined the party line.\n",dcc[j].nick,
	    dcc[j].host);
  tell_notes(z,dcc[j].nick);
}

/* remove entry from dcc list */
void lostdcc(n)
int n;
{
  int i;
  dcc_total--;
  for (i=n; i<dcc_total; i++) {
    strcpy(dcc[i].param,dcc[i+1].param);
    strcpy(dcc[i].nick,dcc[i+1].nick);
    strcpy(dcc[i].host,dcc[i+1].host);
    dcc[i].sock=dcc[i+1].sock;
    dcc[i].addr=dcc[i+1].addr;
    dcc[i].port=dcc[i+1].port;
    dcc[i].type=dcc[i+1].type;
    dcc[i].status=dcc[i+1].status;
    dcc[i].used=dcc[i+1].used;
    dcc[i].msgs_per_sec=dcc[i+1].msgs_per_sec;
  }
}

/* show list of current dcc's to a dcc-chatter */
void tell_dcc(z)
int z;
{
  int i; time_t now; char s[121];
  now=time(NULL);
  for (i=0; i<dcc_total; i++) {
    if (dcc[i].type==DCC_CHAT) {
      sprintf(s,"DCC CHAT: [%s]%s/%u",dcc[i].nick,dcc[i].host,dcc[i].port);
      if (dcc[i].status&STAT_CONSOLE) strcat(s," (con)");
      if (dcc[i].status&STAT_TALK) strcat(s," (talk)");
      if (dcc[i].status&STAT_BLIND) strcat(s," (BLIND)");
      tprintf(z,"%s\n",s);
    }
    if (dcc[i].type==DCC_CHAT_PASS)
      tprintf(z,"DCC CHAT: [%s]%s/%u (password)\n",dcc[i].nick,dcc[i].host,
	      dcc[i].port);
    if (dcc[i].type==DCC_SEND)
      tprintf(z,"DCC SEND: %s!%s/%u (%lu of %lu)\n",dcc[i].nick,dcc[i].host,
              dcc[i].port,dcc[i].used,dcc[i].status);
    if (dcc[i].type==DCC_GET_PENDING)
      tprintf(z,"DCC GET: %s!%s/%u (waited %lus so far)\n",dcc[i].nick,
	      dcc[i].host,dcc[i].port,now-dcc[i].used);
    if (dcc[i].type==DCC_GET)
      tprintf(z,"DCC GET: %s!%s/%u (%lu of %lu)\n",dcc[i].nick,dcc[i].host,
	      dcc[i].port,dcc[i].used,dcc[i].status);
    if (dcc[i].type==DCC_TELNET)
      tprintf(z,"Listening on telnet port %d\n",dcc[i].port);
    if (dcc[i].type==DCC_TELNET_ID)
      tprintf(z,"TELNET: [???]%s/%u\n",dcc[i].host,dcc[i].port);
    if (dcc[i].type==DCC_FILES)
      tprintf(z,"DCC CHAT: [%s]%s/%u  (files)\n",dcc[i].nick,dcc[i].host,
	      dcc[i].port);
    if (dcc[i].type==DCC_EDIT)
      tprintf(z,"DCC CHAT: [%s]%s/%u  (edit)\n",dcc[i].nick,dcc[i].host,
	      dcc[i].port);
  }
}

/* received a ctcp-dcc */
void gotdcc(nick,from,msg)
char *nick,*from,*msg;
{
  char code[81],param[81],s[256],s1[81],prt[81]; int z,i;
  split(code,msg); if (code[0]==0) { strcpy(code,msg); msg[0]=0; }
  /* currently, nothing but chat */
  if ((strcasecmp(code,"chat")!=0) && (strcasecmp(code,"send")!=0)) return;
  /* dcc chat or send! */
  split(param,msg); split(s,msg); split(prt,msg);
  if (prt[0]==0) { strcpy(prt,msg); msg[0]=0; }
  z=open_telnet_dcc(s,prt);
  if (z<0) {
    neterror(s);
    if (z==-2) strcpy(s,"Can't find hostname lookup");
    mprintf(serv,"NOTICE %s :Failed to connect (%s)\n",nick,s);
    console("DCC connection failed: %s %s (%s!%s)",code,param,nick,from);
    console("    (%s)",s);
    return;
  }
  if (dcc_total==MAXDCC) {
    mprintf(serv,"NOTICE %s :Sorry, too many DCC connections.\n",nick);
    console("DCC connections full: %s %s (%s!%s)",code,param,nick,from);
    close(z); return;
  }
  /* only bot-masters or bot-ops can do chat! */
  sprintf(s1,"%s!%s",nick,from);
  if ((!match_master(s1)) && (!match_op(s1)) && (strcasecmp(code,"chat")==0)) {
    mprintf(serv,"NOTICE %s :No access.\n",nick);
    console("Refused DCC chat (no access): %s!%s",nick,from);
    close(z); return;
  }
  if ((!match_master(s1)) && (!match_op(s1)) && (strcasecmp(code,"send")==0) &&
      (!match_xfer(s1))) {
    mprintf(serv,"NOTICE %s :No file transfer access.\n",nick);
    console("Refused DCC SEND %s (no access): %s!%s",param,nick,from);
    close(z); return;
  }
  if ((dccin[0]==0) && (strcasecmp(code,"send")==0)) {
    mprintf(serv,"NOTICE %s :DCC file transfers not supported.\n",nick);
    console("Refused dcc send %s from %s!%s",param,nick,from);
    close(z); return;
  }
  if ((strchr(param,'/')!=NULL) && (strcasecmp(code,"send")==0)) {
    mprintf(serv,"NOTICE %s :Filename cannot have '/' in it...\n",nick);
    console("Refused dcc send %s from %s!%s",param,nick,from);
    close(z); return;
  }
  if ((param[0]=='.') && (strcasecmp(code,"send")==0)) param[0]='_';
  dcc[dcc_total].addr=atol(s);
  dcc[dcc_total].port=atoi(prt);
  dcc[dcc_total].sock=z;
  if (strcasecmp(code,"chat")==0) dcc[dcc_total].type=DCC_CHAT;
  else if (strcasecmp(code,"send")==0) dcc[dcc_total].type=DCC_SEND;
  dcc[dcc_total].status=0;
  dcc[dcc_total].msgs_per_sec=0;
  if (dcc[dcc_total].type==DCC_SEND) dcc[dcc_total].status=atol(msg);
  dcc[dcc_total].used=0;
  sprintf(s,"%s!%s",nick,from);
  if (strcasecmp(code,"chat")==0) {
    get_handle_by_host(dcc[dcc_total].nick,s);
    if (match_master(s)) {
      dcc[dcc_total].status|=STAT_MASTER;
      dcc[dcc_total].status|=STAT_CONSOLE;
    }
    if (strcasecmp(param,"talk")==0) {
      dcc[dcc_total].status|=STAT_TALK;
      tprintf(z,"/// OK\n");
    }
  }
  else strcpy(dcc[dcc_total].nick,nick);
  strcpy(dcc[dcc_total].host,from);
  strcpy(dcc[dcc_total].param,param);
  console("DCC connection: %s %s (%s!%s)",code,param,nick,from);
  dcc_total++;
  if (dcc[dcc_total-1].type==DCC_CHAT) {
    if (pass_match_by_host("nopass",s)) {
      /* no password set */
      tprintf(z,"( YOU HAVE NO PASSWORD SET )\n");
      dcc_chatter(z);
    }
    else {
      tprintf(z,"Enter your password.\n");
      dcc[dcc_total-1].type=DCC_CHAT_PASS;
      dcc[dcc_total-1].used=time(NULL);
    }
  }
  else if (dcc[dcc_total-1].type==DCC_SEND) {
    FILE *vv;
    sprintf(s,"%s%s",dccin,param);
    vv=fopen(s,"r"); if (vv!=NULL) {
      fclose(vv);
      mprintf(serv,"NOTICE %s :That file already exists.\n",nick);
      close(z); lostdcc(dcc_total-1);
    }
    vv=fopen(s,"w"); if (vv==NULL) {
      mprintf(serv,"NOTICE %s :Can't create that file.\n",nick);
      close(z); lostdcc(dcc_total-1);
    }
    fclose(vv);
  }
}

int dcc_send(idx,z,filename)
int idx,z; char *filename;
{
  int zz,port=0,i; char *p,nfn[121]; unsigned long host; struct stat ss;
  if (dcc_total==MAXDCC) {
    tprintf(z,"Sorry, too many DCC connections.\n");
    console("DCC connections full: GET %s [%s]",filename,dcc[idx].nick);
    return 0;
  }
  zz=open_listen(&port);
  if (zz==-1) {
    tprintf(z,"Unable to listen at a socket.\n");
    console("DCC socket error: GET %s [%s]",filename,dcc[idx].nick);
    return 0;
  }
  p=strrchr(filename,'/'); strcpy(nfn,p+1);
  host=getmyip();
  stat(filename,&ss);
  tprintf(z,"Sending DCC to '%s'...\n",dcc[idx].nick);
  mprintf(serv,"PRIVMSG %s :%cDCC SEND %s %lu %d %lu%c\n",dcc[idx].nick,1,nfn,
	  host,port,ss.st_size,1);
  if (dcc[dcc_total].status&STAT_TALK)
    tprintf(z,"/// GET %s\n",nfn);
  else
    tprintf(z,"Type '/DCC GET %s %s' to receive.\n",botname,nfn);
  i=dcc_total;
  strcpy(dcc[i].param,filename);
  strcpy(dcc[i].nick,dcc[idx].nick);
  strcpy(dcc[i].host,dcc[idx].host);
  dcc[i].sock=zz; dcc[i].port=port;
  dcc[i].type=DCC_GET_PENDING;
  dcc[i].used=time(NULL);
  dcc[i].status=ss.st_size;
  dcc_total++;
  return 1;
}

int do_dcc_send(idx,z,dir,filename)
int idx,z; char *dir,*filename;
{
  char s[121]; FILE *f;
  if (dccdir[0]==0) {
    tprintf(z,"DCC file transfers not supported.\n");
    console("Refused dcc get %s from [%s]",filename,dcc[idx].nick);
    return 0;
  }
  if (strchr(filename,'/')!=NULL) {
    tprintf(z,"Filename cannot have '/' in it...\n");
    console("Refused dcc get %s from [%s]",filename,dcc[idx].nick);
    return 0;
  }
  sprintf(s,"%s%s/%s",dccdir,dir,filename);
  f=fopen(s,"r"); if (f==NULL) {
    tprintf(z,"No such file.\n");
    console("Refused dcc get %s from [%s]",filename,dcc[idx].nick);
    return 0;
  }
  fclose(f);
  return dcc_send(idx,z,s);
}  

int detect_dcc_flood(idx)
int idx;
{
  int i; time_t t;
  t=time(NULL);
  if (dcc[idx].used!=t) { dcc[idx].used=t; dcc[idx].msgs_per_sec=0; }
  else {
    dcc[idx].msgs_per_sec++;
    if (dcc[idx].msgs_per_sec > 3) {
      /* FLOOD */
      tprintf(dcc[idx].sock,"*** FLOOD: Goodbye.\n");
      for (i=0; i<dcc_total; i++) if ((dcc[i].type==DCC_CHAT) && (i!=idx))
	tprintf(dcc[i].sock,"*** %s forcibly removed from the party %s\n",
		dcc[idx].nick,"line for flooding.");
      if (dcc[idx].sock!=STDOUT) {
	close(dcc[idx].sock); lostdcc(idx);
      }
      else {
	tprintf(STDOUT,"\n### SIMULATION RESET ###\n\n");
	dcc_chatter(STDOUT);
      }
      return 1;  /* <- flood */
    }
  }
  return 0;
}

/* I/O calls here when activity is found on a dcc socket */
void dcc_activity(z,buf,len)
int z,len; char *buf;
{
  int idx,i,j; FILE *f; char s[121],s1[81],*bf; unsigned long netint,cmp,l;
  static char cntbuf[5]; static int cnt=0;
  for (idx=0; (dcc[idx].sock!=z) && (idx<dcc_total); idx++);
  if (idx>=dcc_total) {
    console("*** Receiving data from closed socket (flushing)");
    return;
  }
  if (dcc[idx].type==DCC_CHAT_PASS) {
    if (pass_match_by_handle(buf,dcc[idx].nick)) {
      dcc[idx].type=DCC_CHAT;
      dcc_chatter(z);
    }
    else {
      tprintf(z,"Authentification failed.\n");
      console("Bad password: DCC chat [%s]%s",dcc[idx].nick,dcc[idx].host);
      close(z); lostdcc(idx);
    }
  }
  else if (dcc[idx].type==DCC_EDIT) {
    cmd_edit(idx,z,buf);
  }
  else if (dcc[idx].type==DCC_CHAT) {
    if (!detect_dcc_flood(idx)) {
      if (dcc[idx].status&STAT_ECHO) tprintf(z,"%s\n",buf);
      if (buf[0]=='.') {
	if (got_dcc_cmd(idx,z,&buf[1])) {
	  tprintf(z,"Thanks!  Bye!\n");
	  console("DCC connection closed (%s!%s)",dcc[idx].nick,dcc[idx].host);
	  for (i=0; i<dcc_total; i++) if (dcc[i].type==DCC_CHAT)
	    tprintf(dcc[i].sock,"*** %s left the party line.\n",dcc[idx].nick);
	  if (dcc[idx].status&STAT_TALK) tprintf(z,"/// KILL\n");
	  if (dcc[idx].sock!=STDOUT) {
	    close(dcc[idx].sock); lostdcc(idx);
	  }
	  else {
	    tprintf(STDOUT,"\n### SIMULATION RESET\n\n");
	    dcc_chatter(STDOUT);
	  }
	}
      }
      else if (buf[0]=='/') got_dcc_cmd(idx,z,buf);
      else if (buf[0]==',') {
	for (i=0; i<dcc_total; i++) if (dcc[i].status&STAT_MASTER)
	  if (dcc[i].type==DCC_CHAT)
	    tprintf(dcc[i].sock,"-%s- %s\n",dcc[idx].nick,&buf[1]);
      }
      else {
	for (i=0; i<dcc_total; i++)
	  if ((dcc[i].type==DCC_CHAT) && (!(dcc[i].status&STAT_BLIND)))
	    tprintf(dcc[i].sock,"<%s> %s\n",dcc[idx].nick,buf);
      }
    }
  }
  else if (dcc[idx].type==DCC_FILES) {
    if (!detect_dcc_flood(idx)) {
      if (dcc[idx].status&STAT_ECHO) tprintf(z,"%s\n",buf);
      if (got_files_cmd(idx,z,buf)) {
	tprintf(z,"Thanks!  Bye!\n");
	console("DCC user [%s]%s left file system",dcc[idx].nick,
		dcc[idx].host);
	set_handle_dccdir(dcc[idx].nick,dcc[idx].param);
	if (dcc[idx].status&STAT_CHAT) {
	  tprintf(z,"Returning you to command mode...\n");
	  if (dcc[idx].status&STAT_TALK) {
	    tprintf(z,"/// PROMPT \n");
	    tprintf(z,"/// ECHO OFF\n");
	  }
	  for (i=0; i<dcc_total; i++) if (dcc[i].type==DCC_CHAT)
	    tprintf(dcc[i].sock,"*** %s (%s) joineed the party line\n",
		    dcc[idx].nick,dcc[idx].host);
	  dcc[idx].status&=(~STAT_CHAT); dcc[idx].type=DCC_CHAT;
	}
	else {
	  tprintf(z,"Dropping connection now.\n");
	  if (dcc[idx].status&STAT_TALK) tprintf(z,"/// KILL\n");
	  close(dcc[idx].sock); lostdcc(idx);
	}
      }
    }
  }
  else if (dcc[idx].type==DCC_SEND) {
    sprintf(s,"%s%s",dccin,dcc[idx].param);
    f=fopen(s,"a");
    if (f==NULL) {
      mprintf(serv,"NOTICE %s :Disk error.\n",dcc[idx].nick);
      console("Disk error: dropping dcc send %s from %s!%s",dcc[idx].
	      param,dcc[idx].nick,dcc[idx].host);
      close(dcc[idx].sock); lostdcc(idx);
      sprintf(s,"rm -f %s%s",dccin,dcc[idx].param);
      system(s);
    }
    else {
      fwrite(buf,len,1,f);
      dcc[idx].used+=len;
      netint=htonl(dcc[idx].used);
      write(dcc[idx].sock,&netint,4);
      fclose(f);
    }
  }
  else if (dcc[idx].type==DCC_GET_PENDING) {
    i=answer(dcc[idx].sock,s); close(dcc[idx].sock);
    dcc[idx].sock=i;
    if (dcc[idx].sock==-1) {
      neterror(s);
      mprintf(serv,"NOTICE %s :Bad connection (%s)\n",dcc[idx].nick,
	      s);
      console("DCC bad connection: GET %s (%s!%s)",dcc[idx].param,
	      dcc[idx].nick,dcc[idx].host);
      lostdcc(idx);
    }
    else {
      f=fopen(dcc[idx].param,"r");
      if (f==NULL) { close(dcc[idx].sock); lostdcc(idx); }
      else {
        if (dcc[idx].status<512) dcc[idx].used=dcc[idx].status;
	else dcc[idx].used=512;
        dcc[idx].type=DCC_GET;
        bf=(char *)nmalloc(dcc[idx].used+1);
        fread(bf,dcc[idx].used,1,f);
        write(dcc[idx].sock,bf,dcc[idx].used);
	nfree(bf);
      }
    }
  }
  else if (dcc[idx].type==DCC_GET) {
    if (cnt) {
      memcpy(&cntbuf[cnt],buf,len); memcpy(buf,cntbuf,len+cnt);
      len+=cnt; cnt=0;
    }
    if (len<4) {
      /* not a full answer */
      cnt=len; memcpy(cntbuf,buf,len);
    }
    else {
      cmp=ntohl(*(unsigned long *)(buf));
      if (cmp==dcc[idx].used) {
	f=fopen(dcc[idx].param,"r");
	if (f==NULL) { close(dcc[idx].sock); lostdcc(idx); }
	else if (dcc[idx].used==dcc[idx].status) {
	  close(dcc[idx].sock);
	  console("Finished dcc send %s to %s!%s",dcc[idx].param,dcc[idx].nick,
		  dcc[idx].host);
	  lostdcc(idx);
	  /* was successful */
	}
	else {
	  fseek(f,dcc[idx].used,0);
	  l=512;
	  if (dcc[idx].used+512 > dcc[idx].status)
	    l=dcc[idx].status-dcc[idx].used;
	  bf=(char *)nmalloc(l+1);
	  fread(bf,l,1,f);
	  write(dcc[idx].sock,bf,l);
	  nfree(bf);
	  dcc[idx].used+=l;
	}
      }
    }
  }
  else if (dcc[idx].type==DCC_TELNET) {
    i=dcc_total;
    if (i+1>MAXDCC) {
      j=answer(dcc[idx].sock,s);
      if (j!=-1) {
	tprintf(j,"Sorry, too many connections already.\n");
	close(j);
      }
    }
    else {
      dcc[i].sock=answer(dcc[idx].sock,s);
      if (dcc[i].sock!=-1) {
	dcc[i].addr=0L;
	dcc[i].port=dcc[idx].port;
	sprintf(dcc[i].host,"telnet from %s",s);
	dcc[i].param[0]=0;
	dcc[i].type=DCC_TELNET_ID;
	dcc[i].used=time(NULL);
	dcc[i].status=STAT_CR;
	tprintf(dcc[i].sock,"\n\n%s  (%s)\n\n",botname,version);
	tprintf(dcc[i].sock,"Identify yourself (nickname).\n");
	dcc_total++;
	console("TELNET connection: %s",s);
      }
      else {
	neterror(s1);
	console("Failed TELNET connection %s (%s)",s,s1);
	close(dcc[idx].sock);  /* start over listening - might help? */
	dcc[idx].sock=open_listen(&telnet_port);
      }
    }
  }
  else if (dcc[idx].type==DCC_TELNET_ID) {
    if ((!match_attr_handle(buf,USER_MASTER)) &&
	(!match_attr_handle(buf,USER_OP))) {
      tprintf(dcc[idx].sock,"You don't have access.\n");
      console("Refused telnet from %s (invalid handle: %s)",dcc[idx].host,buf);
      close(dcc[idx].sock); lostdcc(idx);
    }
    else if (pass_match_by_handle("nopass",buf)) {
      tprintf(dcc[idx].sock,"Can't telnet until you have a password set.\n");
      console("Refused telnet from [%s]%s (no password)",buf,dcc[idx].host);
      close(dcc[idx].sock); lostdcc(idx);
    }
    else {
      dcc[idx].type=DCC_CHAT_PASS;
      if (match_attr_handle(buf,USER_MASTER)) dcc[idx].status|=STAT_MASTER;
      strcpy(dcc[idx].nick,buf);
      tprintf(dcc[idx].sock,"\nEnter your password.\n");
      console("Telnet -> DCC chat: [%s]%s",dcc[idx].nick,dcc[idx].host);
    }
  }
}

/* eof from dcc goes here from I/O... */
void eof_dcc(z)
int z;
{
  int idx,i; char s[121];
  for (idx=0; dcc[idx].sock!=z; idx++);
  if ((dcc[idx].type==DCC_CHAT) || (dcc[idx].type==DCC_CHAT_PASS) ||
      (dcc[idx].type==DCC_EDIT)) {
    dcc[idx].status&=~STAT_CONSOLE;   /* don't try to send them this: */
    console("Lost dcc connection to %s!%s/%d",dcc[idx].nick,dcc[idx].host,
	    dcc[idx].port);
    if ((dcc[idx].type==DCC_CHAT) || (dcc[idx].type==DCC_EDIT))
      for (i=0; i<dcc_total; i++) if (i!=idx)
	tprintf(dcc[i].sock,"*** %s lost dcc link.\n",dcc[idx].nick);
    if (dcc[idx].type==DCC_EDIT) leave_edit(idx,z);
    lostdcc(idx);
  }
  else if (dcc[idx].type==DCC_TELNET_ID) {
    console("Lost telnet connection to %s/%d",dcc[idx].host,dcc[idx].port);
    lostdcc(idx);
  }
  else if (dcc[idx].type==DCC_SEND) {
    if (dcc[idx].status==dcc[idx].used) {
      int ok=0,j;
      /* success */
      console("Completed dcc send %s from %s!%s",dcc[idx].param,
	      dcc[idx].nick,dcc[idx].host);
      uploaded(dcc[idx].param,dcc[idx].nick);
      for (j=0; j<dcc_total; j++)
	if (((dcc[j].type==DCC_CHAT) || (dcc[j].type==DCC_FILES)) &&
	    (strcasecmp(dcc[j].nick,dcc[idx].nick)==0)) {
	  ok=1;
	  tprintf(dcc[j].sock,"Thanks for the file!\n");
	}
      if (!ok) mprintf(serv,"PRIVMSG %s :Thanks for the file!\n",
		       dcc[idx].nick);
      lostdcc(idx);
    }
    else {
      /* failure */
      console("Lost dcc send %s from %s!%s (%lu/%lu)",dcc[idx].param,
	      dcc[idx].nick,dcc[idx].host,dcc[idx].used,dcc[idx].status);
      sprintf(s,"rm -f %s%s",dccin,dcc[idx].param);
      system(s);
      lostdcc(idx);
    }
  }
  else if ((dcc[idx].type==DCC_GET_PENDING) || (dcc[idx].type==DCC_GET)) {
    console("Lost dcc get %s from %s!%s",dcc[idx].param,dcc[idx].nick,
	    dcc[idx].host);
    lostdcc(idx);
  }
}

void check_expired_dcc()
{
  int i; time_t now; char xx[121],*p;
  now=time(NULL);
  for (i=0; i<dcc_total; i++) {
    if (dcc[i].type==DCC_GET_PENDING) {
      if (now-dcc[i].used > 300) {
	strcpy(xx,dcc[i].param); p=strrchr(xx,'/');
	mprintf(serv,"NOTICE %s :Timeout on dcc send %s.\n",dcc[i].nick,p+1);
	console("DCC timeout: GET %s (%s!%s)",dcc[i].param,dcc[i].nick,
		dcc[i].host);
	close(dcc[i].sock);
	lostdcc(i); i--;
      }
    }
    else if (dcc[i].type==DCC_CHAT_PASS) {
      if (now-dcc[i].used > 180) {
	tprintf(dcc[i].sock,"Timeout.\n");
	console("Password timeout on dcc chat: [%s]%s",dcc[i].nick,
		dcc[i].host);
	close(dcc[i].sock); lostdcc(i); i--;
      }
    }
    else if (dcc[i].type==DCC_TELNET_ID) {
      if (now-dcc[i].used > 180) {
	tprintf(dcc[i].sock,"Timeout.\n");
	console("Ident timeout on telnet: %s",dcc[i].host);
	close(dcc[i].sock); lostdcc(i); i--;
      }
    }
  }
}