#include <stdio.h>
#include <netdb.h>
#include <string.h>
#include <stdlib.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define AF_INET 2
typedef enum {FALSE = 0, TRUE = 1} boolean;

char *Blacklists[30];
int BlacklistCount = 0;
unsigned long LowIP;
unsigned long HighIP;
int Verbosity = 0;

boolean isdigit(char tempchar)
{
  if (tempchar > '9') return (FALSE);
  if (tempchar < '0') return (FALSE);
  return(TRUE);
}

int instring(char *tempstring, char findvalue)
{
   int tempindex = 0;
   int STOP = 0;
   while (!STOP)
   {
      if (tempstring[tempindex++] == findvalue) STOP = 1;
      if (tempstring[tempindex-1] == '\0') return(0);
   }
   return(tempindex);
}

boolean isipaddress(char *addr)
{
   int tempint1 = 0;
   for (tempint1 = 0 ; tempint1 < strlen(addr) ; tempint1 ++)
   {
      if (instring("0123456789.", addr[tempint1]) == 0)
      {
         return(FALSE);
      }
   }
   return(TRUE);
}

char *getname(char *addr)
{
   static char *return_string;
   static char ReturnValue[500];
   unsigned long inetaddr;
   struct in_addr inp;
   inetaddr = inet_aton(addr, &inp);

   if (gethostbyaddr((void *)(&inetaddr), 4, AF_INET) == 0)
   {
      sprintf(ReturnValue, "");
/*
      printf("%s\n", inet_ntoa(inetaddr));
*/
      return(ReturnValue);
   }
   return_string = gethostbyaddr((void *)(&inetaddr), 4, AF_INET)->h_name;
   return(return_string);
}

char *getaddr(char *name)
{
   static char ReturnValue[500];
   static char addr[500];
   unsigned long tempaddr;

   if (gethostbyname(name) == 0)
   {
      sprintf(ReturnValue, "");
      return(ReturnValue);
   }

tempaddr = ((gethostbyname(name)->h_addr_list[0][0] << 24) & 0xFF000000) |
   ((gethostbyname(name)->h_addr_list[0][1] << 16) & 0x00FF0000) |
   ((gethostbyname(name)->h_addr_list[0][2] << 8) & 0x0000FF00) |
   ((gethostbyname(name)->h_addr_list[0][3] & 0x000000FF));

/*
   sprintf(addr, "%s", inet_ntoa(tempaddr));
*/
   sprintf(addr, "%d.%d.%d.%d", ((tempaddr >> 24) & 0xFF), ((tempaddr >> 16) & 0xFF), ((tempaddr >> 8) & 0xFF), (tempaddr & 0xFF));

   return(addr);
}

int TestRange()
{
   char BlacklistString[500];
   char ReverseHost[500];
   char ForwardHost[500];
   int BlacklistCounter;
   int IPa, IPb, IPc, IPd;
   int Counter1;
   int Counter2;
   unsigned long Counter;
   unsigned long LowValue;
   unsigned long HighValue;

   char ReturnValue[500];

/*
   LowValue = 0x80BB0000;
   HighValue = 0x80BBFFFF;
*/

/*
   for (BlacklistCounter = 0 ; BlacklistCounter < BlacklistCount ; BlacklistCounter ++)
   {
      printf("Blacklist %d = %s\n", BlacklistCounter, Blacklists[BlacklistCounter]);
   }
*/

   for (Counter = LowIP ; Counter <= HighIP ; Counter ++)
   {
      IPa = (Counter >> 24 ) & 0xFF;
      IPb = (Counter >> 16 ) & 0xFF;
      IPc = (Counter >> 8 ) & 0xFF;
      IPd = Counter & 0xFF;

      for (BlacklistCounter = 0 ; BlacklistCounter < BlacklistCount ; BlacklistCounter ++)
      {
         sprintf(BlacklistString, Blacklists[BlacklistCounter]);

         sprintf(ReverseHost, "%d.%d.%d.%d.%s.", IPd, IPc, IPb, IPa, BlacklistString);
         sprintf(ForwardHost, "%d.%d.%d.%d - %s", IPa, IPb, IPc, IPd, BlacklistString);
         if (Verbosity > 0)
         {
            printf("Testing %s                             \r", ForwardHost);
            fflush(stdout);
         }
         sprintf(ReturnValue, getaddr(ReverseHost));
         if (strcmp(ReturnValue, ""))
         {
            printf("%s -> %s (%s)                  \n", ForwardHost, ReturnValue, BlacklistString);
            fflush(stdout);
         }
      }
   }
   printf("Finished scanning blacklists                               \n");
   fflush(stdout);
   return(0);
}

int Usage(int argc, char *argv[])
{
   printf("Usage: %s [-osirusoft | -o] [-rss | -r] [-spamcop | -s] [-v] [host | net/mask | hostA-hostB]\n", argv[0]);
   printf("   -o | -osirusoft  - use relays.osirusoft.com\n");
   printf("   -r | -rss        - use relays.mail-abuse.org (maps-rss)\n");
   printf("   -s | -spamcop    - use bl.spamcop.net\n");
   printf("   -v               - increase verbosity (once displays hosts as they're being tested, twice is overkill)\n");
   printf("   host             - check blacklists for this host\n");
   printf("   net/mask         - check blacklists for this network/netmask combination\n");
   printf("   hostA-hostB      - check blacklists for hostA-hostB range (inclusive)\n");
   printf("           examples: 128.187.0.0/16\n");
   printf("                     www.byu.edu\n");
   printf("                     128.187.0.0/255.255.0.0\n");
   printf("                     128.187.0.0-128.187.255.255\n");
   printf("   host or net/mask or hostA-hostB is required, and there should be only one\n");
   return(0);
}

int AddBlacklist(char *NewList)
{
   printf("Adding check of %s\n", NewList);
   Blacklists[BlacklistCount] = (char *)(calloc(strlen(NewList) + 1, sizeof(char)));
   sprintf(Blacklists[BlacklistCount++], NewList);
   return(0);
}

int CommandLine(int argc, char *argv[])
{
   int ArgCount;

   BlacklistCount = 0;
   /* default to all of BYU's IP address space */
   LowIP  = 0x80BB0000;
   HighIP = 0x80BBFFFF;

   for (ArgCount = 1 ; ArgCount < argc ; ArgCount ++)
   {
      if (!strcmp(argv[ArgCount], "-osirusoft") || !strcmp(argv[ArgCount], "-o"))
      {
         AddBlacklist("relays.osirusoft.com");
      }
      else if (!strcmp(argv[ArgCount], "-rss") || !strcmp(argv[ArgCount], "-r"))
      {
         AddBlacklist("relays.mail-abuse.org");
      }
      else if (!strcmp(argv[ArgCount], "-spamcop") || !strcmp(argv[ArgCount], "-s"))
      {
         AddBlacklist("bl.spamcop.net");
      }
      else if (!strcmp(argv[ArgCount], "-v"))
      {
         Verbosity ++;
      }
      else
      {
         char NetmaskString[400];
         int MaskDivision;
         int RangeDivision;

         MaskDivision = instring(argv[ArgCount], '/');
         RangeDivision = instring(argv[ArgCount], '-');
         /* now we test for host or net */
         if (MaskDivision)
         { /* it's net/mask or net/maskbits */
            unsigned long Netmask;
            unsigned long Network;
            unsigned int NetmaskParts[4];
            unsigned int NetworkParts[4];
            unsigned long AddIP;

            sscanf(argv[ArgCount], "%d.%d.%d.%d", &NetworkParts[0],  &NetworkParts[1],  &NetworkParts[2],  &NetworkParts[3]);
            Network = (NetworkParts[0] << 24) | (NetworkParts[1] << 16) | (NetworkParts[2] << 8) | NetworkParts[3];
            if (Verbosity > 1)
            {
               printf("The network is %d.%d.%d.%d or %08X\n", NetworkParts[0], NetworkParts[1], NetworkParts[2], NetworkParts[3], Network);
               printf("I think this is a net/mask\n");
            }
            if (instring(argv[ArgCount] + MaskDivision, '.'))
            { /* net/mask */
               sscanf(argv[ArgCount] + MaskDivision, "%d.%d.%d.%d", &NetmaskParts[0],  &NetmaskParts[1],  &NetmaskParts[2],  &NetmaskParts[3]);
               Netmask = (NetmaskParts[0] << 24) | (NetmaskParts[1] << 16) | (NetmaskParts[2] << 8) | NetmaskParts[3];
               if (Verbosity > 1)
               {
                  printf("It's a netmask\n");
                  printf("The netmask is %d.%d.%d.%d or %08X\n", NetmaskParts[0],  NetmaskParts[1],  NetmaskParts[2],  NetmaskParts[3], Netmask);
               }
               exit (-1);
            } /* net/mask */
            else
            { /* net/maskbits */
               int NetmaskBits;
               sscanf(argv[ArgCount] + MaskDivision, "%d", &NetmaskBits);
               Netmask = (0xFFFFFFFF >> (32 - NetmaskBits)) << (32 - NetmaskBits);
               if (Verbosity > 1)
               {
                  printf("It's NetmaskBits\n");
                  printf("The netmask is %08X\n", Netmask);
               }
            } /* net/maskbits */
            LowIP = Network & Netmask;
            AddIP = ~Netmask;
            HighIP = LowIP + AddIP;
         }
         else if (RangeDivision)
         {
            unsigned int IPParts[4];

            sscanf(argv[ArgCount], "%d.%d.%d.%d", &IPParts[0], &IPParts[1], &IPParts[2], &IPParts[3]);
            LowIP = (IPParts[0] << 24) | (IPParts[1] << 16) | (IPParts[2] << 8) | IPParts[3];

            sscanf(argv[ArgCount] + RangeDivision, "%d.%d.%d.%d", &IPParts[0], &IPParts[1], &IPParts[2], &IPParts[3]);
            HighIP = (IPParts[0] << 24) | (IPParts[1] << 16) | (IPParts[2] << 8) | IPParts[3];
         }
         else
         {
            unsigned int IPParts[4];

            if (isipaddress(argv[ArgCount]))
            { /* looks like an ip */
               sscanf(argv[ArgCount], "%d.%d.%d.%d", &IPParts[0], &IPParts[1], &IPParts[2], &IPParts[3]);
               LowIP = (IPParts[0] << 24) | (IPParts[1] << 16) | (IPParts[2] << 8) | IPParts[3];
               HighIP = LowIP;
            } /* ip address */
            else
            { /* hostname */
               char IPAddr[400];

               sprintf(IPAddr, getaddr(argv[ArgCount]));
               if (strcmp(IPAddr, ""))
               {
                  sscanf(IPAddr, "%d.%d.%d.%d", &IPParts[0], &IPParts[1], &IPParts[2], &IPParts[3]);
                  LowIP = (IPParts[0] << 24) | (IPParts[1] << 16) | (IPParts[2] << 8) | IPParts[3];
                  HighIP = LowIP;
               }
               else
               {
                  printf("Could not get address for %s\n", argv[ArgCount]);
                  Usage(argc, argv);
                  exit (-1);
               }
            } /* hostname */
         } /* host or ip */
      } /* host, net, ip, etc */
   } /* foreach arg */
   if (Verbosity > 1)
   {
      printf("LowIP is %08X\n", LowIP);
      printf("HighIP is %08X\n", HighIP);
   }

   if (BlacklistCount == 0)
   {
      Usage(argc, argv);
      exit(-1);
   }
   
   return(0);
} /* CommandLine */

int main(int argc, char *argv[])
{
   CommandLine(argc, argv);
   TestRange();
   return(0);
}