/*
   NET.C
     net functions especially for bots

   Robey Pointer, robey@acolyte.slip.netcom.com
*/

#if HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#if HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
#include <netinet/in.h>
#ifndef LINUX    /* linux gets wacko if you include both */
#include <netinet/tcp.h>
#endif           /* but virtually every other OS NEEDS both */
#include <varargs.h>
#include <errno.h>
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <fcntl.h>

/* almost every module needs some sort of time thingy, so... */
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif

#if !HAVE_GETDTABLESIZE
#ifdef FD_SETSIZE
#define getdtablesize() FD_SETSIZE
#else
#define getdtablesize() 64
#endif
#endif

#define STDOUT 1
#define STDIN 0
#define EFORKKILLED 2323

void fatal();

/* context support */
extern int cx_line; extern char cx_file[];
#define context { strcpy(cx_file,__FILE__); cx_line=__LINE__; }

/* this is used by mtgets to store up data from various sockets until a \n
   is received -- set this relatively high so it won't have to throw away
   any data -- making this greater than or equal to the number of open sockets
   you expect to have at any given time is the smart way to go */
#define TABLESIZE 50

/* static buffer */
extern char SBUF[];

/* FreeBSD's atol() is supposed to be fixed now, but since I went to all
   that trouble, might as well keep it.  */
#undef atol
#define atol my_atol
unsigned long my_atol(x)
char *x;
{
  unsigned long l=0;
  while ((*x>='0') && (*x<='9')) l=(l*10)+(*x++)-'0';
  return l;
}

/* i read somewhere that memcpy() is broken on some machines */
/* it's easy to replace, so i'm not gonna take any chances, because it's */
/* pretty important that it work correctly here */
void my_memcpy(dest,src,len)
char *dest,*src; int len;
{
  while (len--) *dest++=*src++;
}

/* bzero() is bsd-only, so here's one for non-bsd systems */
void my_bzero(dest,len)
char *dest; int len;
{
  while (len--) *dest++=0;
}

/* puts full hostname in s */
void getmyhostname(s)
char *s;
{
  struct hostent *hp; char *p;
  p=getenv("HOSTNAME"); if (p!=NULL) {
    strcpy(s,p); if (strchr(s,'.')!=NULL) return;
  }
  gethostname(s,80);
  if (strchr(s,'.')!=NULL) return;
  hp=gethostbyname(s);
  if (hp==NULL)
    fatal("Hostname self-lookup failed.",0);
  strcpy(s,hp->h_name);
  if (strchr(s,'.')!=NULL) return;
  if (hp->h_aliases[0] == NULL)
    fatal("Can't determine your hostname!",0);
  strcpy(s,hp->h_aliases[0]);
  if (strchr(s,'.')==NULL)
    fatal("Can't determine your hostname!",0);
}

/* get my ip number */
unsigned long getmyip()
{
  struct hostent *hp; char s[121]; unsigned long ip; struct in_addr *in;
  gethostname(s,120);
  hp=gethostbyname(s);
  if (hp==NULL) fatal("Hostname self-lookup failed.",0);
  in=(struct in_addr *)(hp->h_addr_list[0]);
  ip=(unsigned long)(in->s_addr);
  ip=htonl(ip);
  return ip;
}

void neterror(s)
char *s;
{
  switch(errno) {
  case EADDRINUSE:
    strcpy(s,"Address already in use"); break;
  case EADDRNOTAVAIL:
    strcpy(s,"Address invalid on remote machine"); break;
  case EAFNOSUPPORT:
    strcpy(s,"Address family not supported"); break;
  case EALREADY:
    strcpy(s,"Socket already in use"); break;
  case EBADF:
    strcpy(s,"Socket descriptor is bad"); break;
  case ECONNREFUSED:
    strcpy(s,"Connection refused"); break;
  case EFAULT:
    strcpy(s,"Namespace segment violation"); break;
  case EINPROGRESS:
    strcpy(s,"Operation in progress"); break;
  case EINTR:
    strcpy(s,"Timeout"); break;
  case EINVAL:
    strcpy(s,"Invalid namespace"); break;
  case EISCONN:
    strcpy(s,"Socket already connected"); break;
  case ENETUNREACH:
    strcpy(s,"Network unreachable"); break;
  case ENOTSOCK:
    strcpy(s,"File descriptor, not a socket"); break;
  case ETIMEDOUT:
    strcpy(s,"Connection timed out"); break;
  case ENOTCONN:
    strcpy(s,"Socket is not connected"); break;
  case EHOSTUNREACH:
    strcpy(s,"Host is unreachable"); break;
#ifdef ECONNRESET
  case ECONNRESET:
    strcpy(s,"Connection reset by peer"); break;
#endif
#ifdef EACCES
  case EACCES:
    strcpy(s,"Permission denied"); break;
#endif
  /* only used by forked processes that are killed */
  case EFORKKILLED:
    strcpy(s,"Killed"); break;
  case 0:
    strcpy(s,"Error 0"); break;
  default:
    sprintf(s,"Unforseen error %d",errno); break;
  }
}  

/* connects to socket & returns file descriptor */
/* returns <0 if connection refused: */
/*   -1  connection refused */
/*   -2  can't resolve hostname */
int open_telnet_raw(sock,server,port)
int sock; char *server; int port;
{
  int number,i; struct sockaddr_in name; struct hostent *hp;
  my_bzero((char *)&name,sizeof(struct sockaddr_in));
  name.sin_family=AF_INET;
  name.sin_port=htons(port);
  number=1; i=strlen(server)-1;
  while ((server[i]!='.') && (i!=0)) {
    if ((server[i]<'0') || (server[i]>'9')) number=0;
    i--;
  }
  if (number) {
    unsigned char *p,*p1; unsigned long a;
    p1=(unsigned char *)&a; p1[0]=atoi(server);
    p=(unsigned char *)strchr(server,'.');
    if (p!=NULL) p1[1]=atoi((char *)(p+1));
    if (p!=NULL) {
      p=(unsigned char *)strchr((char *)(p+1),'.');
      if (p!=NULL) p1[2]=atoi((char *)(p+1));
    }
    if (p!=NULL) {
      p=(unsigned char *)strchr((char *)(p+1),'.');
      if (p!=NULL) p1[3]=atoi((char *)(p+1));
    }
    if (p!=NULL) name.sin_addr.s_addr=htonl(a);
    else { close(sock); return -2; }
  }
  else {
    hp=gethostbyname(server);
    if (hp==NULL) { close(sock); return -2; }
    my_memcpy((char *)&name.sin_addr,hp->h_addr,hp->h_length);
    name.sin_family=hp->h_addrtype;
  }
  if (connect(sock,(struct sockaddr *)&name,sizeof(struct sockaddr_in)) <0) {
    close(sock); return -1;
  }
  /* make it a non-blocking socket (whee) */
  fcntl(sock,F_SETFL,O_NONBLOCK);
  return sock;
}

int getsock()
{
  int sock; int parm;
  /* struct timeval tv; */
  sock=socket(AF_INET,SOCK_STREAM,0);
  if (sock<0) fatal("Can't open a socket at all.",0);
  /* keepalive (ie, ping), NO linger (block on write to dead socket), */
  /* don't allow block on write to living socket if >10ms */
  parm=1; setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,(void *)&parm,sizeof(int));
  parm=0; setsockopt(sock,SOL_SOCKET,SO_LINGER,(void *)&parm,sizeof(int));
/*  tv.tv_sec=0; tv.tv_usec=10000; */
  parm=1; setsockopt(sock,SOL_SOCKET,TCP_NODELAY,(void *)&parm,sizeof(int));
  return sock;
}

int open_telnet(server,port)
char *server; int port;
{
  return open_telnet_raw(getsock(),server,port);
}

/* returns a socket number for a listening socket that will accept any */
/* connection -- port # is returned in port */
int open_listen(port)
int *port;
{
  int sock,addrlen; struct sockaddr_in name;
  sock=getsock();
  my_bzero((char *)&name,sizeof(struct sockaddr_in));
  name.sin_family=AF_INET;
  name.sin_port=htons(*port);   /* 0 = just assign us a port */
  name.sin_addr.s_addr=INADDR_ANY;
  if (bind(sock,(struct sockaddr *)&name,sizeof(name))<0) {
    close(sock); return -1;
  }
  /* what port are we on? */
  addrlen=sizeof(name);
  if (getsockname(sock,(struct sockaddr *)&name,&addrlen)<0) {
    close(sock); return -1;
  }
  *port=ntohs(name.sin_port);
  if (listen(sock,1)<0) { close(sock); return -1; }
  return sock;
}

/* given network-style IP address, return hostname */
/* hostname will be "##.##.##.##" format if there was an error */
char *hostnamefromip(ip)
unsigned long ip;
{
  struct hostent *hp; unsigned long addr=ip;
  unsigned char *p; static char s[121];
  hp=gethostbyaddr((char *)&addr,sizeof(addr),AF_INET);
  if (hp==NULL) {
    p=(unsigned char *)&addr;
    sprintf(s,"%u.%u.%u.%u",p[0],p[1],p[2],p[3]);
    return s;
  }
  strcpy(s,hp->h_name); return s;
}

/* short routine to answer a connect received on a socket made previously */
/* by open_listen ... returns hostname of the caller & the new socket */
/* does NOT dispose of old "public" socket! */
int answer(sock,caller,ip)
int sock; char *caller; unsigned long *ip;
{
  int new_sock,addrlen; struct sockaddr_in from;
  addrlen=sizeof(struct sockaddr);
  new_sock=accept(sock,(struct sockaddr *)&from,&addrlen);
  if (new_sock<0) return -1;
  *ip=from.sin_addr.s_addr;
  strcpy(caller,hostnamefromip(*ip));
  *ip=ntohl(*ip);
  /* no blocking on the new socket */
  fcntl(new_sock,F_SETFL,O_NONBLOCK);
  return new_sock;
}

/* like open_telnet, but uses server & port specifications of dcc */
int open_telnet_dcc(sock,server,port)
int sock; char *server,*port;
{
  int p; unsigned long addr; char sv[121]; unsigned char *c;
  if (port!=NULL) p=atoi(port); else p=2000;
  if (server!=NULL) addr=atol(server); else addr=0L;
  if (addr<(1<<24)) return -3;  /* fake address */
  c=(unsigned char *)&addr;
  sprintf(sv,"%u.%u.%u.%u",c[0],c[1],c[2],c[3]);
  /* strcpy(sv,hostnamefromip(addr)); */
  return open_telnet_raw(sock,sv,p);
}


#define SOCK_BINARY   1
#define SOCK_LISTEN   2

/* mtread: uh... see mtgets for info.  this is just part of that. */
int mtread(socks,sockl,flagl,s,len)
int socks,sockl[],flagl[]; char *s; int *len;
{
  fd_set fd; int i,j,x; struct timeval t;
  i=getdtablesize();
#ifdef FD_SETSIZE
  if (i>FD_SETSIZE) i=FD_SETSIZE;    /* fixes YET ANOTHER freebsd bug!!! */
#endif
  t.tv_sec=1; t.tv_usec=0; FD_ZERO(&fd); 
  for (j=0; j<socks; j++) FD_SET(sockl[j],&fd);
  x=select(i,&fd,NULL,NULL,&t); 
  if (x>0) {
    for (j=0; j<socks; j++) {
      if (FD_ISSET(sockl[j],&fd)) {
	if (flagl[j]==SOCK_LISTEN) {
	  /* listening socket -- don't read, just return activity */
	  s[0]=0; *len=0; return sockl[j];
	}
	i=read(sockl[j],s,511);
	if (i<=0) {   /* eof */
	  *len=sockl[j];
	  if (*len==0) *len=1;
	  return -1;
	}
	s[i]=0; *len=i;
	if (sockl[j]==0) return 1; else return sockl[j];
      }
    }
  }
  else if (x==-1) return -2;   /* socket error */
  else {
    s[0]=0; *len = 0;
  }
  return 0;
}

/* tread: useless and now gone */

/* mtgets: a strange and complex function with five parameters:
     socks - number of items in sockl
     sockl - array of integers, these are the sockets to attempt reading from
     flagl - array of integers, these are the flags for each socket
     s     - (char *) where mtgets puts the string
     len   - (int *) 
   attempts to read from all the sockets listed up to one second.  if after
     one second, no complete data has been received from any of the sockets,
     s will be empty, len will be 0, and mtgets will return 0.
   if there is returnable data received from any socket in the sockl array,
     the data will be in s (null-terminated if ascii), the length will be
     returned in len, and the socket number (positive) will be returned.
   if an EOF is detected from any of the sockets, that socket number will be
     put in len, and -1 will be returned.
   mtgets will only return data from a socket when it gets an entire line
     terminated with a '\n', unless the socket has a flag set in flagl[].
     if the socket is marked SOCK_BINARY, then it will return data as soon
     as it comes in, without processing it.  if the socket is marked with
     SOCK_LISTEN, it will return with a null string when activity occurs
     at all (without attempting to read).
   YOU MUST initialize the function first by calling it like so:
     mtgets(0,NULL,NULL,NULL,NULL);

   * the maximum length of the string returned is 512 (including null)
   * mtgets stores pent-up data in static buffers that it mallocs as it
     needs them (does not waste memory) -- see the #define at the top of
     this file to set the number of buffers available
*/

static char *bf[TABLESIZE];
static int bfs[TABLESIZE];
static char *tput[TABLESIZE];

int mtgets(socks,sockl,flagl,s,len)
int socks,sockl[],flagl[]; char *s; int *len;
{
  char xx[514],*p,*px; int ret,i,j;
  if (socks==0) {
    /* initialize socket buffer table */
    for (i=0; i<TABLESIZE; i++) { bf[i]=NULL; bfs[i]=0; tput[i]=NULL; }
    return 0;
  }

  context;  
  /* wipe the pent-up buffers for sockets that are no longer being
     requested */
  for (i=0; i<TABLESIZE; i++) if (bf[i]!=NULL) {
    int ok=0;
    for (j=0; (j<socks) && (!ok); j++) if (bfs[i]==sockl[j]) ok=1;
    if (!ok) {
      free(bf[i]); bf[i]=NULL; bfs[i]=0;
    }
  }

  context;
  /* check for stored-up data waiting to be processed */
  for (i=0; i<TABLESIZE; i++) if (bf[i]!=NULL) {
    p=strchr(bf[i],'\n'); if (p!=NULL) {
      j=bfs[i]; *p=0;
      if (strlen(bf[i])>510) bf[i][510]=0;
      strcpy(s,bf[i]); 
      px=(char *)malloc(strlen(p+1)+1); strcpy(px,p+1);
      free(bf[i]);
      if (px[0]) bf[i]=px;
      else { bf[i]=NULL; bfs[i]=0; free(px); }
      if (s[strlen(s)-1]=='\r') s[strlen(s)-1]=0;
      *len = strlen(s);       /* <-- oh that looks so cute robey! :) */
      return j;
    }
  }

  /* no pent-up data of any worth -- down to business */
  context; *len=0;
  ret=mtread(socks,sockl,flagl,xx,len);
  if (ret<=0) { s[0]=0; return ret; }
  for (i=0; i<socks; i++) if ((sockl[i]==ret) && (flagl[i])) {
    /* don't wait for '\n' : SOCK_BINARY or SOCK_LISTEN */
    if (flagl[i]==SOCK_BINARY) my_memcpy(s,xx,*len);
    return ret;
  }

  context;
  /* might be necessary to prepend stored-up data! */
  for (i=0; i<TABLESIZE; i++) if (bfs[i]==ret) {
    p=bf[i]; bf[i]=(char *)malloc(strlen(p)+strlen(xx)+1);
    strcpy(bf[i],p); strcat(bf[i],xx); free(p);
    if (strlen(bf[i])<512) {
      strcpy(xx,bf[i]); bfs[i]=0; free(bf[i]); bf[i]=NULL;
    }
    else {
      p=bf[i]; bf[i]=(char *)malloc(strlen(p)-509);
      strcpy(bf[i],p+510); *(p+510)=0; strcpy(xx,p); free(p);
/*      strcat(xx,"\n");    force a linefeed after 510 chars -- geez! */
/* NO!! could be \n in the new stuff */
    }
  }

  context;
  /* look for EOL marker; if it's there, i have something to show */
  p=strchr(xx,'\n');
  if (p!=NULL) {
    *p=0; strcpy(s,xx); strcpy(xx,p+1);
    if (s[strlen(s)-1]=='\r') s[strlen(s)-1]=0;
  }
  else {
    s[0]=0;
    if (strlen(xx)>=510) {
      /* string is too long, so just insert fake \n */
      strcpy(s,xx); xx[0]=0;
    }
  }

  context;
  /* anything left that needs to be saved? */
  if (!xx[0]) { if (s[0]) return ret; else return 0; }

  context;
  /* prepend old data back */
  for (i=0; i<TABLESIZE; i++) if ((bfs[i]==ret) && (bf[i]!=NULL)) {
    p=bf[i]; bf[i]=(char *)malloc(strlen(p)+strlen(xx)+1);
    strcpy(bf[i],xx); strcat(bf[i],p); free(p);
    if (s[0]) return ret; else return 0;
  }

  context;
  /* still here, so gotta find an empty one */
  for (i=0; i<TABLESIZE; i++) {
    if (bf[i]==NULL) {
      bfs[i]=ret; bf[i]=(char *)malloc(strlen(xx)+1);
      strcpy(bf[i],xx);
      if (s[0]) return ret; else return 0;
    }
  }

  context;
  /* still here?!  then we gotta throw away this perfectly good data!! */
  fprintf(stderr,"[NET.C] No mtgets table space! Throwing away data!\n");
  fprintf(stdout,"[NET.C] No mtgets table space! Throwing away data!\n");
  if (s[0]) return ret; else return 0;
  /* you know, i think stdout and stderr are closed by this point. */
  /* oh well. */
}

/* dump something to a socket */
void tputs(z,s)
int z; char *s;
{
  int i; char *p;
  if (z<0) return;   /* um... HELLO?!  sanity check please! */
  if (fcntl(z,F_GETFD,0)==-1) return;  /* bad socket */
  if (tput[z]!=NULL) {
    /* already queueing: just add it */
    p=(char *)malloc(strlen(tput[z])+strlen(s)+1);
    strcpy(p,tput[z]); strcat(p,s); free(tput[z]);
    tput[z]=p; return;
  }
  else {
    i=write(z,s,strlen(s));
    if (i==(-1)) i=0;
    if (i<strlen(s)) {
      /* socket is full, queue it */
      tput[z]=(char *)malloc(strlen(s)-i+1);
      strcpy(tput[z],&s[i]);
    }
  }
}

/* tputs might queue data for sockets, let's dump as much of it as */
/* possible */
void dequeue_sockets()
{
  int i; char *p;
  for (i=0; i<TABLESIZE; i++) if (tput[i]!=NULL) {
    /* trick tputs into doing the work */
    /* it checks for closed sockets and everything :) */
    p=tput[i]; tput[i]=NULL;
    tputs(i,p); free(p);
  }
}

/* like fprintf, but instead of preceding the format string with a FILE
   pointer, precede with a socket number */
/* please stop using this one except for server output.  dcc output
   should now use dprintf(idx,"format",[params]);   */
void tprintf(va_alist)
va_dcl
{
  char *format; int sock; va_list va; static char SBUF2[768];
  va_start(va);
  sock=va_arg(va,int); format=va_arg(va,char *);
  vsprintf(SBUF2,format,va);
  if (strlen(SBUF2)>510) SBUF2[510]=0;   /* server can only take so much */
  tputs(sock,SBUF2);
  va_end(va);
}

void io_memory(in,out)
unsigned int *in,*out;
{
  int i;
  *in=*out=0;
  for (i=0; i<TABLESIZE; i++) {
    if (tput[i]!=NULL) *out+=strlen(tput[i]+1);
    if (bf[i]!=NULL) *in+=strlen(bf[i]+1);
  }
}