This repository has been archived on 2025-02-12. You can view files and clone it, but cannot push or open issues or pull requests.
NeoStats-opsb/libopm/test.c

245 lines
6.7 KiB
C
Raw Normal View History

/*
* 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);
}
}