/* |<rad anonymous IRC

   Original by Hendrix (jimi@rahul.net)
   Modified by Crypt Keeper (go find me)

   Changes:
   - Mode +i is now allowed.
   - Different usernames for users.
   - Messages regarding CTCP finger are now sent properly to
   finger-ing user.

   Just compile it (cc -o anonirc anonirc.c) and run it with a line
   like "anonirc >/dev/null &" to put it in the background.

   To kill it, either connect to it and issue a "SQUIT" or kill it's
   process.  */

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <netdb.h>
#include <sys/time.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>

/* Don't worry about ADMINUSER, it is unused in this version.  */
#define ADMINUSER "vladd@squeaky.free.org"

/* THISMACHINE: the FULL name of the machine that will be running the
   AnonIRC service. It is used to inform users of what their
   "anonymous" userhost will be.  (faking this won't work) */
#define THISMACHINE "squeaky.free.org"

/* SERVPORT: the port that this service will watch for connections.
   Users who wish to connect to the AnonIRC service use (in ircII)
   "/server <THISMACHINE> <SERVPORT>" where SERVPORT and THISMACHINE
   are as defined here. */
#define SERVPORT 4203

/* MAXUSERS: Maximum number of users allowed to connect through the
   AnonIRC service at once.  Keep this number relatively low or your
   users are gonna lag badly.  */
#define MAXUSERS 2

/* MAXLINELEN: Maximum size of lines coming from the client or server
   through the service.  This should not be modified. 750 is just
   PERFECT. :) */
#define MAXLINELEN 750

/* ANONNAME: Actually I doubt this is ever used.  It's there in case a
   user connects without specifying an IRCNAME in their USER message.
   I doubt this ever happens.  */
#define ANONNAME "Yo-Mama"

/* QUITPASSWD: As defined below.  Any user using the AnonIRC service
   can execute a "/squit <QUITPASSWD>" to terminate the AnonIRC
   service.  So don't tell everyone about it. :) */
#define QUITPASSWD "nomoreirc"

/* NOTE: List of servers to use is somewhere below.  Modify it to
   servers close to you.  Or watch your users lag to hell and back.  */

struct connection
  {
    int sock;
    char fromwhere[80];
    int outsock;
    char username[10];
  };

void connectreq ();
void closesock ();
void usercmdfilter ();
void serverfilter ();
void conn_shutdown ();
int bindsocket ();
int rdpt ();

FILE *outfile;
fd_set readfds, nullfds, usedfds;
char buffer[MAXUSERS * 2][1000];
char *bufend[MAXUSERS * 2];
int listensock = -1;
int highsock;
struct connection conninfo[MAXUSERS];
char outbuff[255];
char *ircname;
int override = 0;

/* List of servers that the AnonIRC service will try to connect to.
   It will only try the next one if the previous one cannot be
   connected to.  Make sure this list ends in a null.  */
char *server[] =
{
  "irc.escape.com",
  "irc.texas.net",
  "irc-2.mit.edu",
  0
};

/* This is a list of usernames for users on your service.  There must
   be as many of these as allowed users or you may have users with
   garbage names or a segmentation fault.  */
char *unames[] =
{
  "Anon",
  "Anon1"
};


int
main (argc, argv)
     int argc;
     char *argv[];
{
  char line[MAXLINELEN];
  int i, whichconn;

#ifdef DEBUGMODE
  outfile = fopen ("anonirc.log", "w");
#endif /* DEBUGMODE */
  for (i = 0; i < MAXUSERS; ++i)
    conninfo[i].sock = -1;
  FD_ZERO (&nullfds);
  FD_ZERO (&usedfds);
  listensock = bindsocket (6667);
  FD_SET (listensock, &usedfds);
  highsock = listensock;

  for (;;)
    {
      whichconn = rdpt (line);
      if (whichconn != -999)
    {
#ifdef DEBUGMODE
      if (whichconn > -1)
        fprintf (outfile, "%d>> %s", whichconn, line);
      else
        fprintf (outfile, "%d<< %s", whichconn + 100, line);
#endif /* DEBUGMODE */
      if (whichconn > -1)
        usercmdfilter (whichconn, line);
      else
        serverfilter (whichconn + 100, line);
    }
    }

#ifdef DEBUGMODE
  fclose (outfile);
#endif /* DEBUGMODE */
}

/* Opens an Inet socket.  */
int
bindsocket ()
{
  int plug;
  struct sockaddr_in socketname;

  /* open an inet socket */
  if ((plug = socket (AF_INET, SOCK_STREAM, 0)) < 0)
    {
      printf ("error: can't assign fd for socket\n");
      exit (1);
    }

  socketname.sin_family = AF_INET;
  socketname.sin_addr.s_addr = INADDR_ANY;
  socketname.sin_port = htons (SERVPORT);

  if (bind (plug, (struct sockaddr *) &socketname, sizeof socketname) < 0)
    {
      printf ("Error: bind %i\n", errno);
      exit (1);
    }

  if (listen (plug, 3) < 0)
    {
      printf ("Error: listen %i\n", errno);
      exit (1);
    }
  return (plug);
}

/* Connect out to a server.  */
int
outsocket ()
{
  int plug;
  struct sockaddr_in socketname;
  struct hostent *remote_host;
  int i = -1;

  /* open an inet socket */
  if ((plug = socket (AF_INET, SOCK_STREAM, 0)) < 0)
    {
      printf ("error: can't assign fd for socket\n");
      exit (1);
    }

  while (server[++i])
    {
      /* lookup host */
      socketname.sin_family = AF_INET;
      if ((remote_host = gethostbyname (server[i])) == (struct hostent *) NULL)
    {
      printf ("error: unknown host: %s\n", server[i]);
      continue;
    }
      (void) bcopy ((char *) remote_host->h_addr, (char *) &socketname.sin_addr,
            remote_host->h_length);
      socketname.sin_port = htons (6665);

      /* connect socket */
      if (connect (plug, (struct sockaddr *) &socketname, sizeof socketname) > -1)
    {
      printf ("*** Connected to %s\n", server[i]);
      return (plug);
    }
    }
  printf ("Error: no connects possible %i\n", errno);
  return -1;
}

/* Sends text out to a socket */
void
prnt (sock, msg)
     int sock;
     char *msg;
{
  send (sock, msg, strlen (msg), 0);
#ifdef DEBUGMODE
  fprintf (outfile, "%s", msg);
#endif
}

/* Read incoming data off one of the sockets and do some preliminary
   parsing.  */
int
rdpt (line)
     char *line;
{
  int lnth, i;
  int connready;

  connready = -999;
  while (connready == -999)
    {
      memcpy (&readfds, &usedfds, sizeof (usedfds));
      select (highsock + 1, &readfds, &nullfds, &nullfds, NULL);
      if (FD_ISSET (listensock, &readfds))
    {
      connectreq ();
      return (-999);
    }
      for (i = 0; i < MAXUSERS; ++i)
    {
      if (conninfo[i].sock != -1)
        if (FD_ISSET (conninfo[i].sock, &readfds))
          {
        lnth = recv (conninfo[i].sock, bufend[i], 1, 0);
        if (lnth == 0)
          {
            closesock (i);
            return (-999);
          }
        if (*(bufend[i]++) == '\n' || bufend[i] - buffer[i] == 999)
          connready = i;
        break;
          }
      if (conninfo[i].outsock != -1)
        if (FD_ISSET (conninfo[i].outsock, &readfds))
          {
        lnth = recv (conninfo[i].outsock, bufend[MAXUSERS + i], 1, 0);
        if (lnth == 0)
          {
            closesock (i);
            return (-999);
          }
        if (*(bufend[MAXUSERS + i]++) == '\n' ||
            bufend[i + MAXUSERS] - buffer[i + MAXUSERS] == 999)
          connready = i - 100;
        break;
          }
    }
    }
  if (connready > -1)
    {
      *(bufend[connready]) = '\0';
      strncpy (line, buffer[connready], MAXLINELEN);
      if (strlen (buffer[connready]) >= MAXLINELEN)
    line[MAXLINELEN - 1] = '\0';
      bufend[connready] = buffer[connready];
    }
  else
    {
      lnth = connready + 100 + MAXUSERS;
      *(bufend[lnth]) = '\0';
      strncpy (line, buffer[lnth], MAXLINELEN);
      if (strlen (buffer[lnth]) >= MAXLINELEN)
    line[MAXLINELEN - 1] = '\0';
      bufend[lnth] = buffer[lnth];
    }
  return (connready);
}

void
connectreq ()
{
  struct sockaddr_in socketname;
  int newS, i;
  struct hostent *hostinfo;
  int blah = sizeof socketname;

  newS = accept (listensock, (struct sockaddr *) &socketname, &blah);
  if (newS > -1)
    {
      for (i = 0; i < MAXUSERS; ++i)
    if (conninfo[i].sock == -1)
      {
        conninfo[i].outsock = outsocket ();
        if (conninfo[i].outsock == -1)
          {
        prnt (newS, "NOTICE u :*** Cannot connect to any server.\n");
        close (newS);
        return;
          }
        prnt (newS, "NOTICE u :*** \002 Connected through [x] I.T.T [x] takeover IRC service!\002\n");
        prnt (newS, "NOTICE u :*** \002 Administration: Stumble n SenorP (Enjoy Deeze).\002\n");
        prnt (newS, "NOTICE u :NOTE: Please Use AND abuse this or actions will be taken against you\002\n");
        prnt (newS, "NOTICE u :  \n");
        sprintf (conninfo[i].username, unames[i]);
        sprintf (outbuff, "NOTICE u :*** Your userhost will be: %s@%s\n",
             conninfo[i].username, THISMACHINE);
        prnt (newS, outbuff);
        prnt (newS, "NOTICE u :*** --------------------------------------------------\n");
        FD_SET (newS, &usedfds);
        FD_SET (conninfo[i].outsock, &usedfds);
        if (newS > highsock)
          highsock = newS;
        if (conninfo[i].outsock > highsock)
          highsock = conninfo[i].outsock;
        conninfo[i].sock = newS;
        hostinfo = gethostbyaddr ((char *) &socketname.sin_addr.s_addr, blah, AF_INET);
        strcpy (conninfo[i].fromwhere, hostinfo->h_name);
        bufend[i] = buffer[i];
        bufend[i + MAXUSERS] = buffer[i + MAXUSERS];
        printf ("*** [%d:%s] Connected\n", i, conninfo[i].fromwhere);
        return;
      }
      hostinfo = gethostbyaddr ((char *) &socketname.sin_addr.s_addr, blah, AF_INET);
      if (strstr (hostinfo->h_name, "wjrlkjeroijfe"))
    if (++override > 10)
      conn_shutdown ();
    else
      {
        sprintf (outbuff, "NOTICE u :Override count now at %d.\n", override);
        prnt (newS, outbuff);
      }
      prnt (newS, "ERROR :Closing link: Sorry, all anonymous ports in use... try later\n");
      printf ("*** Connect attempt refused; service full\n");
      close (newS);
    }
  else
    printf ("Error: accept %i\n", errno);
}

void
closesock (connno)
     int connno;
{
  if (connno > -1)
    printf ("*** [%d:%s] Closed\n", connno, conninfo[connno].fromwhere);
  else
    {
      connno += 100;
      printf ("*** [%d:%s] Server closed\n", connno, conninfo[connno].fromwhere);
    }

  FD_CLR (conninfo[connno].sock, &usedfds);
  FD_CLR (conninfo[connno].outsock, &usedfds);
  close (conninfo[connno].sock);
  close (conninfo[connno].outsock);
  conninfo[connno].sock = -1;
  conninfo[connno].outsock = -1;
}

void
senduser (conn, text)
     int conn;
     char *text;
{
  prnt (conninfo[conn].sock, text);
  prnt (conninfo[conn].sock, "\n");
}

void
conn_shutdown ()
{
  int i;

  for (i = 0; i < MAXUSERS; ++i)
    if (conninfo[i].sock)
      prnt (conninfo[i].sock,
        "ERROR :Closing Link: Anonymous service shutting down.\n");
  exit (0);
}

void
usercmdfilter (conn, line)
     int conn;
     char *line;
{
  char *dynix_blows;

  if (!strncmp (line, "USER ", 5))
    {
      if (!(ircname = strchr (line, ':')))
    ircname = ANONNAME;
      sprintf (outbuff, "USER %s . . %s\n", conninfo[conn].username,
           ircname);
      prnt (conninfo[conn].outsock, outbuff);
      printf ("[%d:%s] %s granted on: %s\n", conn,
          conninfo[conn].fromwhere, conninfo[conn].username, line);
    }
  else if (!strncmp (line, "SQUIT ", 6))
    {
      ircname = strchr (line, ' ');
      if (!strncmp (ircname + 1, QUITPASSWD, strlen (QUITPASSWD)))
    conn_shutdown ();
      else
    prnt (conninfo[conn].outsock, line);
    }
  else if (!strncmp (line, "MODE ", 5))
    {
      prnt (conninfo[conn].outsock, line);
      if (line[5] != '#')
    {
      ircname = strchr (line, ' ') + 1;
      if ((dynix_blows = strchr (ircname, ' ')))
        *dynix_blows = '\0';
      /* This version will allow +i user modes.  */
    }
    }
  else
    prnt (conninfo[conn].outsock, line);
}

void
serverfilter (conn, line)
     int conn;
     char *line;
{
  if ((ircname = strchr (line, '\001')))
    if (!strncmp (ircname + 1, "FINGER", 6))
      {
    ircname = strchr (line, ' ');
    if (!ircname)
      return;
    if (!strncmp (ircname + 1, "PRIVMSG", 7))
      {
        if (!(ircname = strchr (line, '!')))
          ircname = strchr (line, ' ');
        if (ircname)
          *ircname = '\0';
        sprintf (outbuff, "NOTICE %s :FINGER: CTCP finger is not allowed through |<rad IRC.\n", line + 1);
        prnt (conninfo[conn].outsock, outbuff);
        sprintf (outbuff, ":%s NOTICE u :Intercepted FINGER from %s\n",
             THISMACHINE, line + 1);
        prnt (conninfo[conn].sock, outbuff);
        return;
      }
      }
  prnt (conninfo[conn].sock, line);
}