/*
* Strobe (c) 1995 Julian Assange (proff@suburbia.net),
* All rights reserved.
*
* $ cc strobe.c -o strobe
*/
#define VERSION "1.03"
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/time.h>
#include <ctype.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/socket.h>
#ifdef _AIX
#include <sys/select.h>
#endif
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <string.h>
#include <errno.h>
#if defined(solaris) || defined(linux) || defined(__FreeBSD__) || \
defined(__NetBSD__) || defined(__GCC__)
#define fvoid void
#else
#define fvoid
extern int optind;
extern char *optarg;
#endif
#define bool char
#ifndef INADDR_NONE
#define INADDR_NONE ((unsigned long)-1)
#endif
#define port_t (unsigned short)
/*
* the below should be set via the Makefile, but if not...
*/
#ifndef ETC_SERVICES
#define ETC_SERVICES "/etc/services"
#endif
#ifndef STROBE_SERVICES
#define STROBE_SERVICES "strobe.services"
#endif
#ifndef LIB_STROBE_SERVICES
#define LIB_STROBE_SERVICES "/usr/local/lib/strobe.services"
#endif
int a_timeout = 20;
char *a_output = NULL;
char *a_services = "strobe.services";
char *a_input = NULL;
/* char *a_prescan = NULL; */
int a_start = 1;
int a_end = 65535;
int a_sock_max = 64;
int a_abort = 0;
int a_bindport = 0;
char *a_bindaddr = NULL;
struct in_addr bindaddr;
bool f_linear = 0;
bool f_verbose = 0;
bool f_verbose_stats = 0;
bool f_fast = 0;
bool f_stats = 0;
bool f_quiet = 0;
bool f_delete_dupes = 0;
bool f_minimise = 0;
bool f_dontgetpeername = 0;
int connects = 0;
int hosts_done = 0;
int attempts_done = 0;
int attempts_outstanding = 0;
struct timeval time_start;
fd_set set_sel;
fd_set set_sel_r;
fd_set set_sel_w;
int host_n;
int Argc;
char **Argv;
FILE *fh_input;
#define HO_ACTIVE 1
#define HO_ABORT 2
#define HO_COMPLETING 4
struct hosts_s {
char *name;
struct in_addr in_addr;
int port;
int portlist_ent;
struct timeval time_used;
struct timeval time_start;
int attempts;
int attempts_done;
int attempts_highest_done;
int connects;
time_t notice_abort;
int status;
};
struct hosts_s ho_initial;
struct hosts_s *hosts;
#define HT_SOCKET 1
#define HT_CONNECTING 2
struct htuple_s {
char *name;
struct in_addr in_addr;
int port;
int sfd;
int status;
struct timeval sock_start;
int timeout;
struct hosts_s *host;
};
struct htuple_s ht_initial;
struct htuple_s *attempt;
struct port_desc_s {
int port;
char *name;
char *portname;
struct port_desc_s *next;
struct port_desc_s *next_port;
};
struct port_desc_s **port_descs;
int *portlist = NULL;
int portlist_n = 0;
char *Srealloc(ptr, len)
char *ptr;
int len;
{
char *p;
int retries = 10;
if (!--retries) {
}
if (!f_quiet)
"Smalloc: couldn't allocate %d bytes...\
sleeping\n",
len);
sleep(2);
}
return p;
}
char *Smalloc(len)
int len;
{
return Srealloc(NULL, len);
}
fvoid sock_block(sfd)
int sfd;
{
int flags;
flags = (~O_NONBLOCK) & fcntl(sfd, F_GETFL);
fcntl(sfd, F_SETFL, flags);
}
fvoid sock_unblock(sfd)
int sfd;
{
int flags;
flags = O_NONBLOCK | fcntl(sfd, F_GETFL);
fcntl(sfd, F_SETFL, flags);
}
int timeval_subtract(result, x, y) /* from gnu c-lib info.texi */
struct timeval *result, *x, *y;
{
/* Perform the carry for the later subtraction by updating y. */
if (x->tv_usec < y->tv_usec) {
int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
y->tv_usec -= 1000000 * nsec;
y->tv_sec += nsec;
}
if (x->tv_usec - y->tv_usec > 1000000) {
int nsec = (y->tv_usec - x->tv_usec) / 1000000;
y->tv_usec += 1000000 * nsec;
y->tv_sec -= nsec;
}
/* Compute the time remaining to wait.
`tv_usec' is certainly positive. */
result->tv_sec = x->tv_sec - y->tv_sec;
result->tv_usec = x->tv_usec - y->tv_usec;
/* Return 1 if result is negative. */
return x->tv_sec < y->tv_sec;
}
fvoid attempt_clear(h)
struct htuple_s *h;
{
if (h->status & HT_SOCKET) {
struct timeval tv1, tv2;
gettimeofday(&tv1, NULL);
timeval_subtract(&tv2, &tv1, &(h->sock_start));
h->host->time_used.tv_sec += tv2.tv_sec;
if ((h->host->time_used.tv_usec += tv2.tv_usec) >= 1000000) {
h->host->time_used.tv_usec -= 1000000;
h->host->time_used.tv_sec++;
}
attempts_done++;
h->host->attempts_done++;
if (h->port > h->host->attempts_highest_done)
h->host->attempts_highest_done = h->port;
sock_unblock(h->sfd);
/* shutdown (h->sfd, 2); */
close(h->sfd);
if (FD_ISSET(h->sfd, &set_sel)) {
FD_CLR(h->sfd, &set_sel);
attempts_outstanding--;
}
}
*h = ht_initial;
}
fvoid clear_all()
{
int n;
for (n = 0; n < a_sock_max; n++)
attempt_clear(&attempt[n]);
}
fvoid attempt_init()
{
int n;
for (n = 0; n < a_sock_max; n++)
attempt[n] = ht_initial;
}
fvoid hosts_init()
{
int n;
for (n = 0; n < a_sock_max; n++)
hosts[n] = ho_initial;
}
fvoid fdsets_init()
{
FD_ZERO(&set_sel_r); /* yes, we have to do this, despite the later */
FD_ZERO(&set_sel_w); /* assisgnments */
FD_ZERO(&set_sel);
}
int sc_connect(h)
struct htuple_s *h;
{
struct sockaddr_in sa_in;
int sopts1 = 1;
struct linger slinger;
if ((h->sfd = socket(PF_INET, SOCK_STREAM, 0)) == -1)
return 0;
memset(&
;sa_in
, 0, sizeof(sa_in
)); h->status |= HT_SOCKET;
gettimeofday(&(h->sock_start), NULL);
sock_unblock(h->sfd);
setsockopt(h->sfd, SOL_SOCKET, SO_REUSEADDR, (char *)&sopts1,
sizeof(sopts1));
setsockopt(h->sfd, SOL_SOCKET, SO_OOBINLINE, (char *)&sopts1,
sizeof(sopts1));
slinger.l_onoff = 0; /* off */
setsockopt(h->sfd, SOL_SOCKET, SO_LINGER, (char *)&slinger,
sizeof(slinger));
sa_in.sin_family = AF_INET;
if (a_bindport)
sa_in.sin_port = a_bindport;
if (a_bindaddr)
sa_in.sin_addr = bindaddr;
if (a_bindaddr || a_bindport)
if (bind(h->sfd, (struct sockaddr *)&sa_in, sizeof(sa_in)) ==
-1) {
fprintf(stderr
, "
;couldn
't bind %s : %d ", a_bindaddr ? a_bindaddr : "0.0.0.0",
ntohs(a_bindport));
perror("");
if (errno == EACCES)
exit(1);
return 0;
}
sa_in.sin_addr = h->in_addr;
sa_in.sin_port = htons(h->port);
if (connect(h->sfd, (struct sockaddr *)&sa_in, sizeof(sa_in)) == -1) {
switch (errno) {
case EINPROGRESS:
case EWOULDBLOCK:
break;
case ETIMEDOUT:
case ECONNREFUSED:
case EADDRNOTAVAIL:
if (f_verbose) {
fprintf(stderr, "%s:%d ", h->name, h->port);
perror("");
}
h->host->attempts++;
attempt_clear(h);
return 1;
default:
if (!f_quiet) {
fprintf(stderr, "%s:%d ", h->name, h->port);
perror("");
}
attempt_clear(h);
return 0;
}
}
h->host->attempts++;
h->status |= HT_CONNECTING;
sock_block(h->sfd);
FD_SET(h->sfd, &set_sel);
attempts_outstanding++;
return 1;
}
int gatherer_tcp(h)
struct htuple_s *h;
{
struct port_desc_s *pd;
if (f_minimise)
printf("%s\t%d\n", h->name, h->port);
else {
if ((pd = port_descs[h->port])) {
printf("%-30s %-16s %5d/tcp %s\n", h->name,
pd->portname, h->port, pd->name);
while (!f_delete_dupes && !f_minimise
&& (pd = pd->next))
printf("#%-29s %-16s %5d/tcp %s\n", h->name,
pd->portname, h->port, pd->name);
} else
printf("%-30s %-16s %5d/tcp unassigned\n", h->name,
"unknown", h->port);
}
h->host->connects++;
connects++;
attempt_clear(h);
return 1;
}
bool gather()
{
struct timeval timeout;
struct htuple_s *h;
int n;
int selected;
time_t tim;
if (!attempts_outstanding)
return 1;
set_sel_r = set_sel_w = set_sel;
timeout.tv_sec = 0;
timeout.tv_usec = 250000; /* 1/4 of a second */
selected = select(FD_SETSIZE, &set_sel_r, &set_sel_w, 0, &timeout);
/* Look for timeouts */
tim = time(NULL);
for (n = 0; n < a_sock_max; n++) {
h = &attempt[n];
if ((h->status & HT_SOCKET) &&
((h->sock_start.tv_sec + h->timeout) < tim))
attempt_clear(h);
}
switch (selected) {
case -1:
perror("select");
return 0;
case 0:
return 1;
}
for (n = 0; selected && (n < a_sock_max); n++) {
h = &attempt[n];
if (h->status & HT_CONNECTING) {
if (FD_ISSET(h->sfd, &set_sel_r)
|| FD_ISSET(h->sfd, &set_sel_w)) {
struct sockaddr_in in;
int len = sizeof(in);
selected--;
/* select() lies occasionaly
*/
if (!f_dontgetpeername) {
/* but solaris2.3 crashes occasionally ;-| */
if (getpeername
(h->sfd, (struct sockaddr *)&in,
&len) == 0)
gatherer_tcp(h);
else
attempt_clear(h);
} else
gatherer_tcp(h);
}
}
}
return 1;
}
bool add_attempt(add)
struct htuple_s *add;
{
struct htuple_s *h;
static time_t oldtime;
static int n;
for (;;) {
for (; n < a_sock_max; n++) {
h = &attempt[n];
if (!h->status)
goto foundfree;
}
n = 0;
gather();
continue;
foundfree:
*h = *add;
if (!sc_connect(h)) {
gather();
continue;
}
if ((oldtime + 1) < time(NULL)) {
oldtime = time(NULL);
gather();
}
break;
}
return 1;
}
int scatter(host, timeout)
struct hosts_s *host;
int timeout;
{
static struct htuple_s add;
add = ht_initial;
add.host = host;
add.name = host->name;
add.in_addr = host->in_addr;
add.port = host->port;
add.timeout = timeout;
if (f_verbose)
fprintf(stderr, "attempting port=%d host=%s\n", add.port,
add.name);
add_attempt(&add);
return 1;
}
fvoid wait_end(t)
int t;
{
time_t st;
st = time(NULL);
while ((st + t) > time(NULL)) {
gather();
if (attempts_outstanding < 1)
break;
}
}
struct in_addr resolve(name)
char *name;
{
static struct in_addr in;
unsigned long l;
struct hostent *ent;
if ((l = inet_addr(name)) != INADDR_NONE) {
in.s_addr = l;
return in;
}
if (!(ent = gethostbyname(name))) {
perror(name);
in.s_addr = INADDR_NONE;
return in;
}
return *(struct in_addr *)ent->h_addr;
}
char *next_host()
{
static char lbuf[512];
hosts_done++;
if (a_input) {
int n;
reread:
if (!fgets(lbuf, sizeof(lbuf), fh_input)) {
fclose(fh_input);
a_input = NULL;
return next_host();
}
if (strchr("# \t\n\r", lbuf[0]))
goto reread;
n = strcspn(lbuf, " \t\n\r");
if (n)
lbuf[n] = '\0';
return lbuf;
}
if (host_n >= Argc)
return NULL;
return Argv[host_n++];
}
bool host_init(h, name, nocheck)
struct hosts_s *h;
char *name;
bool nocheck;
{
int n;
*h = ho_initial;
h->in_addr = resolve(name);
if (h->in_addr.s_addr == INADDR_NONE)
return 0;
if (!nocheck)
for (n = 0; n < a_sock_max; n++) {
if (hosts[n].name
&& hosts[n].in_addr.s_addr == h->in_addr.s_addr) {
if (!f_quiet)
fprintf(stderr,
"ip duplication: %s == %s (\
last host ignored)\n",
hosts[n].name, name);
return 0;
}
}
h->name = (char *)Smalloc(strlen(name) + 1);
strcpy(h->name, name);
h->port = a_start;
h->status = HO_ACTIVE;
gettimeofday(&(h->time_start), NULL);
return 1;
}
fvoid host_clear(h)
struct hosts_s *h;
{
if (h->name) {
free(h->name);
}
*h = ho_initial;
}
fvoid host_stats(h)
struct hosts_s *h;
{
struct timeval tv, tv2;
float t, st;
gettimeofday(&tv, NULL);
timeval_subtract(&tv2, &tv, &(h->time_start));
t = tv2.tv_sec + (float)tv2.tv_usec / 1000000.0;
st = h->time_used.tv_sec + (float)h->time_used.tv_usec / 1000000.0;
fprintf(stderr,
"stats: host = %s trys = %d cons = %d time = %.2fs trys/s\
= %.2f trys/ss = %.2f\n",
h->name, h->attempts_done, h->connects, t, h->attempts_done / t,
h->attempts_done / st);
}
fvoid final_stats()
{
struct timeval tv, tv2;
float t;
gettimeofday(&tv, NULL);
timeval_subtract(&tv2, &tv, &(time_start));
t = tv2.tv_sec + (float)tv2.tv_usec / 1000000.0;
fprintf(stderr,
"stats: hosts = %d trys = %d cons = %d time = %.2fs trys/s = %.2f\n",
hosts_done, attempts_done, connects, t, attempts_done / t);
}
bool skip_host(h)
struct hosts_s *h;
{
if (a_abort && !h->connects && (h->attempts_highest_done >= a_abort)) {
/* async pain */
if (h->status & HO_ABORT) {
if ((time(NULL) - h->notice_abort) > a_timeout) {
if (f_verbose)
fprintf(stderr,
"skipping: %s (no connects \
in %d attempts)\n",
h->name, h->attempts_done);
return 1;
}
} else {
h->notice_abort = time(NULL);
h->status |= HO_ABORT;
}
}
return 0;
}
int next_port(h)
struct hosts_s *h;
{
int n;
for (n = h->port; ++n <= a_end;) {
if (!f_fast)
return n;
if (++h->portlist_ent > portlist_n)
return -1;
return (portlist[h->portlist_ent - 1]);
}
return -1;
}
fvoid scan_ports_linear()
{
struct hosts_s host;
char *name;
while ((name = next_host())) {
if (!host_init(&host, name, 1))
continue;
for (;;) {
scatter(&host, a_timeout);
if (skip_host(&host))
break;
if ((host.port = next_port(&host)) == -1)
break;
}
wait_end(a_timeout);
if (f_verbose_stats)
host_stats(&host);
clear_all();
host_clear(&host);
}
}
/* Huristics:
* o fast connections have priority == maximise bandwidth i.e
* a port in the hand is worth two in the bush
*
* o newer hosts have priority == lower ports checked more quickly
*
* o all hosts eventually get equal "socket time" == despite
* priorities let no one host hog the sockets permanently
*
* o when host usage times are equal (typically on or shortly after
* initial startup) distribute hosts<->sockets evenly rather than
* play a game of chaotic bifurcatic ping-pong
*/
fvoid scan_ports_paralell()
{
int n;
struct timeval smallest_val;
int smallest_cnt;
char *name;
struct hosts_s *h, *smallest = &hosts[0];
while (smallest) {
smallest_val.tv_sec = 0xfffffff;
smallest_val.tv_usec = 0;
for (n = 0, smallest_cnt = 0xfffffff, smallest = NULL;
n < a_sock_max; n++) {
h = &hosts[n];
if (((h->status & HO_COMPLETING) &&
(h->attempts_done == h->attempts)) ||
skip_host(h)) {
if (f_verbose_stats)
host_stats(h);
host_clear(h);
}
if (!h->name && ((name = next_host())))
if (!host_init(h, name, 0)) {
host_clear(h);
continue;
}
if (h->name) {
if (((h->time_used.tv_sec < smallest_val.tv_sec)
||
((h->time_used.tv_sec ==
smallest_val.tv_sec)
&& (h->time_used.tv_usec <=
smallest_val.tv_usec)))
&&
(((h->time_used.tv_sec !=
smallest_val.tv_sec)
&& (h->time_used.tv_usec !=
smallest_val.tv_usec))
|| (h->attempts < smallest_cnt))) {
smallest_cnt = h->attempts;
smallest_val = h->time_used;
smallest = h;
}
}
}
if (smallest) {
if (!(smallest->status & HO_COMPLETING)) {
scatter(smallest, a_timeout);
if ((smallest->port =
next_port(smallest)) == -1)
smallest->status |= HO_COMPLETING;
} else
gather();
}
}
}
fvoid loaddescs()
{
FILE *fh;
char lbuf[1024];
char desc[256];
char portname[17];
unsigned int port;
char *fn;
char prot[4];
prot[3] = '\0';
if (!(fh = fopen((fn = a_services), "r")) &&
!(fh = fopen((fn = LIB_STROBE_SERVICES), "r")) &&
!(fh = fopen((fn = ETC_SERVICES), "r"))) {
perror(fn);
exit(1);
}
port_descs =
(struct port_desc_s **)Smalloc(sizeof(struct port_descs_s *) *
65536);
memset(port_descs, 0, 65536);
while (fgets(lbuf, sizeof(lbuf), fh)) {
char *p;
struct port_desc_s *pd, *pdp;
if (strchr("*# \t\n", lbuf[0]))
continue;
if (!(p = strchr(lbuf, '/')))
continue;
*p = ' ';
desc[0] = '\0';
if (sscanf
(lbuf, "%16s %u %3s %255[^\r\n]", portname, &port, prot,
desc) < 3 || strcmp(prot, "tcp") || (port > 65535))
continue;
pd = port_descs[port];
if (!pd) {
portlist =
(int *)Srealloc((char *)portlist,
++portlist_n * sizeof(int));
portlist[portlist_n - 1] = port;
}
if (!f_minimise) {
pdp =
(struct port_desc_s *)Smalloc(sizeof(*pd) +
strlen(desc) + 1 +
strlen(portname) + 1);
if (pd) {
for (; pd->next; pd = pd->next) ;
pd->next = pdp;
pd = pd->next;
} else {
pd = pdp;
port_descs[port] = pd;
}
pd->next = NULL;
pd->name = (char *)(pd) + sizeof(*pd);
pd->portname = pd->name + strlen(desc) + 1;
strcpy(pd->name, desc);
strcpy(pd->portname, portname);
} else
port_descs[port] = (struct port_desc_s *)-1;
}
if (f_minimise)
free(port_descs);
}
fvoid usage()
{
fprintf(stderr, "\
usage: %8s [options]\n\
\t\t[-v(erbose)]\n\
\t\t[-V(erbose_stats]\n\
\t\t[-m(inimise)]\n\
\t\t[-d(elete_dupes)]\n\
\t\t[-g(etpeername_disable)]\n\
\t\t[-s(tatistics)]\n\
\t\t[-q(uiet)]\n\
\t\t[-o output_file]\n\
\t\t[-b begin_port_n]\n\
\t\t[-e end_port_n]\n\
\t\t[-p single_port_n]\n\
\t\t[-P bind_port_n]\n\
\t\t[-A bind_addr_n]\n\
\t\t[-t timeout_n]\n\
\t\t[-n num_sockets_n]\n\
\t\t[-S services_file]\n\
\t\t[-i hosts_input_file]\n\
\t\t[-l(inear)]\n\
\t\t[-f(ast)]\n\
\t\t[-a abort_after_port_n]\n\
\t\t[-M(ail_author)]\n\
\t\t[host1 [...host_n]]\n", Argv[0]);
exit(1);
}
int main(argc, argv)
int argc;
char **argv;
{
int c;
Argc = argc;
Argv = argv;
while ((c =
getopt(argc, argv, "o:dvVmgb:e:p:P:a:A:t:n:S:i:lfsqM")) != -1)
switch (c) {
case 'o':
a_output = optarg;
break;
case 'd':
f_delete_dupes = 1;
break;
case 'v':
f_verbose = 1;
break;
case 'V':
f_verbose_stats = 1;
break;
case 'm':
f_minimise = 1;
break;
case 'g':
f_dontgetpeername = 1;
break;
case 'b':
a_start = atoi(optarg);
break;
case 'e':
a_end = atoi(optarg);
break;
case 'P':
a_bindport = htons(atoi(optarg));
break;
case 'A':
a_bindaddr = optarg;
bindaddr = resolve(a_bindaddr);
if (bindaddr.s_addr == INADDR_NONE) {
perror(a_bindaddr);
exit(1);
}
break;
case 'p':
a_start = a_end = atoi(optarg);
break;
case 'a':
a_abort = atoi(optarg);
break;
case 't':
a_timeout = atoi(optarg);
break;
case 'n':
a_sock_max = atoi(optarg);
break;
case 'S':
a_services = optarg;
break;
case 'i':
a_input = optarg;
break;
case 'l':
f_linear = 1;
break;
case 'f':
f_fast = 1;
break;
case 's':
f_stats = 1;
break;
case 'q':
f_quiet = 1;
break;
case 'M':
fprintf(stderr,
"Enter mail to author below. End with ^D or .\n");
system("mail strobe@suburbia.net");
break;
case '?':
default:
fprintf(stderr, "unknown option %s\n",
argv[optind - 1]);
usage();
/* NOT_REACHED */
}
host_n = optind;
if (!f_quiet)
fprintf(stderr,
"strobe %s (c) 1995 Julian Assange (proff@suburbia.net).\n",
VERSION);
if (a_input) {
if (!strcmp("-", a_input)) { /* Use stdin as input file */
fh_input = stdin;
} else {
if (!(fh_input = fopen(a_input, "r"))) {
perror(a_input);
exit(1);
}
}
} else {
switch (argc - host_n) { /* Number of hosts found on command line */
case 0:
fh_input = stdin;
a_input = "stdin"; /* Needed in "next_host()" */
break;
case 1:
f_linear = 1;
break;
}
}
if ((fh_input == stdin) && !f_quiet)
fprintf(stderr, "Reading host names from stdin...\n");
if (a_output) {
int fd;
if ((fd =
open(a_output, O_WRONLY | O_CREAT | O_TRUNC,
0666)) == -1) {
perror(a_output);
exit(1);
}
dup2(fd, 1);
}
attempt =
(struct htuple_s *)Smalloc(a_sock_max * sizeof(struct htuple_s));
attempt_init();
if (!f_linear) {
hosts =
(struct hosts_s *)Smalloc(a_sock_max *
sizeof(struct hosts_s));
hosts_init();
}
if (!f_minimise || f_fast)
loaddescs();
fdsets_init();
gettimeofday(&time_start, NULL);
f_linear ? scan_ports_linear() : scan_ports_paralell();
if (f_stats || f_verbose_stats)
final_stats();
exit(0);
}
]]>