NeoStats-opsb/libopm/test.c

/*
 * Copyright (C) 2002  Erik Fears
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to
 *
 *       The Free Software Foundation, Inc.
 *       59 Temple Place - Suite 330
 *       Boston, MA  02111-1307, USA.
 *
 *
 */

#include "modconfig.h"

#include <stdio.h>
#include "opm.h"
#include "opm_error.h"
#include "opm_types.h"
#include "compat.h"
#include <sys/poll.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif

RCSID("$Id: test.c,v 1.36 2003/06/20 04:55:14 andy Exp $");

#define ARRAY_SIZEOF(x) (sizeof(x) / sizeof((x)[0]))

void open_proxy(OPM_T *, OPM_REMOTE_T *, int, void *);
void negotiation_failed(OPM_T *, OPM_REMOTE_T *, int, void *);
void timeout(OPM_T *, OPM_REMOTE_T *, int, void *);
void end(OPM_T *, OPM_REMOTE_T *, int, void *);
void handle_error(OPM_T *, OPM_REMOTE_T *, int, void *);

int complete = 0;

int main(int argc, char **argv)
{
   OPM_ERR_T err;
   int fdlimit = 1024;
   int scan_port = 6667;
   int max_read = 4096;
   int scantimeout  = 10;
   struct pollfd *ufds;
   unsigned int size;
   unsigned int i, s;

   unsigned short http_ports[] = {
      8000, 8080, 3128, 80
   };

   unsigned short wingate_ports[] = {
      23
   };

   unsigned short router_ports[] = {
      23
   };
   
   unsigned short socks4_ports[] = {
      1080
   };

   unsigned short socks5_ports[] = {
      1080
   };

   unsigned short httppost_ports[] = {
      80, 8090, 3128
   };
   
   OPM_T *scanner;
   OPM_REMOTE_T *remote;

   scanner = opm_create();
  
   if(argc >= 2)
      remote  = opm_remote_create(argv[1]);
   else
      remote  = opm_remote_create("127.0.0.1");

   /* Setup callbacks */
   opm_callback(scanner, OPM_CALLBACK_OPENPROXY, &open_proxy, NULL);
   opm_callback(scanner, OPM_CALLBACK_NEGFAIL, &negotiation_failed, NULL);
   opm_callback(scanner, OPM_CALLBACK_TIMEOUT, &timeout, NULL);
   opm_callback(scanner, OPM_CALLBACK_END, &end, NULL);
   opm_callback(scanner, OPM_CALLBACK_ERROR, &handle_error, NULL);


   /* Setup the scanner configuration */ 
   opm_config(scanner, OPM_CONFIG_FD_LIMIT, &fdlimit);
   opm_config(scanner, OPM_CONFIG_SCAN_IP, "216.175.104.202");
   opm_config(scanner, OPM_CONFIG_SCAN_PORT, &scan_port);
   opm_config(scanner, OPM_CONFIG_TARGET_STRING, "*** Looking up your hostname...");
   opm_config(scanner, OPM_CONFIG_TARGET_STRING, "ERROR :Trying to reconnect too fast.");
   opm_config(scanner, OPM_CONFIG_TIMEOUT, &scantimeout);
   opm_config(scanner, OPM_CONFIG_MAX_READ, &max_read);

   /* Setup the protocol configuration */
   for (s = ARRAY_SIZEOF(http_ports), i = 0; i < s; i++) {
      opm_addtype(scanner, OPM_TYPE_HTTP, http_ports[i]);
   }
   
   for (s = ARRAY_SIZEOF(wingate_ports), i = 0; i < s; i++) {
      opm_addtype(scanner, OPM_TYPE_WINGATE, wingate_ports[i]);
   }
   
   for (s = ARRAY_SIZEOF(router_ports), i = 0; i < s; i++) {
      opm_addtype(scanner, OPM_TYPE_ROUTER, router_ports[i]);
   }
   
   for (s = ARRAY_SIZEOF(socks4_ports), i = 0; i < s; i++) {
      opm_addtype(scanner, OPM_TYPE_SOCKS4, socks4_ports[i]);
   }
   
   for (s = ARRAY_SIZEOF(socks5_ports), i = 0; i < s; i++) {
      opm_addtype(scanner, OPM_TYPE_SOCKS5, socks5_ports[i]);
   }
   
   for (s = ARRAY_SIZEOF(httppost_ports), i = 0; i < s; i++) {
      opm_addtype(scanner, OPM_TYPE_HTTPPOST, httppost_ports[i]);
   }
   
   /* Remote structs can also have their own extended protocol configurations. For instance
      if the target hostname contains strings such as 'proxy' or 'www', extended ports could
      be scanned. */
   opm_remote_addtype(remote, OPM_TYPE_HTTP, 8001);
   opm_remote_addtype(remote, OPM_TYPE_HTTP, 8002);

   switch(err = opm_scan(scanner, remote))
   {
      case OPM_SUCCESS:
                       break;
      case OPM_ERR_BADADDR:
                       printf("Bad address\n");
                       opm_free(scanner);
                       opm_remote_free(remote);
                       return 0;
      default:
                       printf("Unknown Error %d\n", err);
                       return 0;
   }
   
   while (!complete) {
	   ufds = malloc((sizeof *ufds) * (*(unsigned int *) libopm_config(scanner->config, OPM_CONFIG_FD_LIMIT)));
	   size = libopm_before_poll(scanner, ufds);

	   err = poll(ufds, size, 0);
	   switch (err)
	      {
	      case -1:
	      	      /* error in select/poll */
		      printf("poll barked\n");
		      return;
	      case 0:
        	      /* Nothing to do */
	              continue;
	      default:
		      libopm_after_poll(scanner, ufds, size);
	      	      continue;
		      	      
	      /* Pass pointer to connection to handler. */
	      }
   }	   
   opm_free(scanner);

   return 0; 
}

void open_proxy(OPM_T *scanner, OPM_REMOTE_T *remote, int notused,
      void *data)
{
   USE_VAR(notused);
   USE_VAR(data);

   printf("Open proxy on %s:%d [%d bytes read]\n", remote->ip,
         remote->port, remote->bytes_read);
   opm_end(scanner, remote);
}

void negotiation_failed(OPM_T *scanner, OPM_REMOTE_T *remote, int notused,
      void *data)
{
   USE_VAR(scanner);
   USE_VAR(notused);
   USE_VAR(data);

   printf("Negotiation on %s:%d failed [%d bytes read]\n", remote->ip,
         remote->port, remote->bytes_read);
}

void timeout(OPM_T *scanner, OPM_REMOTE_T *remote, int notused, void *data)
{
   USE_VAR(scanner);
   USE_VAR(notused);
   USE_VAR(data);

   printf("Negotiation timed out on %s:%d\n", remote->ip, remote->port);
}

void end(OPM_T *scanner, OPM_REMOTE_T *remote, int notused, void *data)
{
   USE_VAR(scanner);
   USE_VAR(notused);
   USE_VAR(data);

   printf("Scan on %s has ended\n", remote->ip);
   opm_remote_free(remote);
   complete = 1;
}

void handle_error(OPM_T *scanner, OPM_REMOTE_T *remote, int err, void *data)
{
   USE_VAR(scanner);
   USE_VAR(data);

   switch(err)
   {
      case OPM_ERR_MAX_READ:
         printf("Reached MAX READ on %s:%d\n", remote->ip, remote->port);
         break;
      case OPM_ERR_BIND:
         printf("Unable to bind for %s:%d\n", remote->ip, remote->port);
         break;
      case OPM_ERR_NOFD:
         printf("Unable to allocate file descriptor for %s:%d\n",
               remote->ip, remote->port);
         break;
      default:
         printf("Unknown error on %s:%d, err = %d\n", remote->ip,
               remote->port, err);
   }
}