/*
 * $Id: ward.c,v 1.1.1.1 2001/03/10 17:32:21 raptor Exp $
 *
 * ward v1.0 - classic war dialer
 * Copyright (c) 2001 Raptor <raptor@0xdeadbeef.eu.org>
 *
 * WARD is a classic war dialer: it scans a list
 * of phone numbers, finding the ones where a modem
 * is answering the call. Wargames still r0cks.
 * WARD can generate phone numbers lists based on
 * a user-supplied mask, in incremental or random
 * order. Remember to change some defines to make
 * it fit your current system configuration.
 *
 * Inspired to the old sordial.c (thanx sorbo!).
 * Thanx also to Megat0n for his termios advice.
 *
 * Tested on Linux. Compile with gcc ward.c -o ward -lm.
 * OpenBSD still have some problems with non-gsm modems.
 *
 * FOR EDUCATIONAL PURPOSES.
 *
 */


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdarg.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <signal.h>
#include <math.h>
#include <string.h>

#define VERSION         "1.0"
#define AUTHOR          "Raptor"
#define MAIL_SUPPORT    "<raptor@0xdeadbeef.eu.org>"

#define OPT_NMASK      	0x01
#define OPT_RAND       	0x02
#define OPT_GENERATE   	0x04
#define OPT_SCAN	0x08
#define OPT_TIMEOUT   	0x10

/* Local setup - change if needed */
#define MODEM_DEV 	"/dev/modem"
#define MODEM_SPEED 	B9600
#define MODEM_TIMEOUT 	60
#define MAX_NUM_LEN 	15
/* Local setup end */


/* Function prototypes */
void scan(char *nfile);
int dial(char *number);
void writefile(int last, int incr, char *nfile);
void listgen(char *nmask, int incr, char *nfile);
int initmodem(char * device);
void closemodem(int fd);
void sendcmd(int fd, int timewait, char * fmt,...);
void cleanup(int ignored);
void fatalerr(char * pattern,...);
void usage(char *name);
/* Prototypes end */


int fd, timeout = MODEM_TIMEOUT;
char **numbers;
struct termios newtio, oldtio;



int main(int argc, char **argv) 
{
	char nmask[MAX_NUM_LEN], nfile[255];
	int incr = 1;

	int opt_line = 0;

/* Disable buffering for stdout */
	setvbuf(stdout, NULL, _IONBF, 0);

/* Parse command line */
	if (argc < 2) usage(argv[0]);

	{
	int c=0;

	while ((c = getopt(argc, argv, "rn:g:s:t:h")) != EOF)

              	switch (c) {
		case 'h':
			usage(argv[0]);
			break;	
              	case 'n':
			opt_line |= OPT_NMASK;
              		strncpy(nmask, optarg, MAX_NUM_LEN - 1);
			break;
		case 'r': 
			opt_line |= OPT_RAND;
			incr = 0;
			break;
		case 'g': 
			opt_line |= OPT_GENERATE;
			strncpy(nfile, optarg, 254);
			break;				
 		case 's':
			opt_line |= OPT_SCAN;
 	                strncpy(nfile, optarg, 254);
 	                break;
		case 't':
			opt_line |= OPT_TIMEOUT;
			timeout = atoi(optarg);
			break;
		}			
	}		


/* Input control */
	if (!(opt_line&OPT_GENERATE) && !(opt_line&OPT_SCAN))
		fatalerr("err: please select an action [generate or scan]");
	
	if ((opt_line&OPT_GENERATE) && (opt_line&OPT_SCAN))
		fatalerr("err: select only one action [generate or scan]");

	if (!*nfile)
		fatalerr("err: please specify a filename to use");


/* Signals handling */
        signal(SIGINT, cleanup);


/* List generation mode */
	if (opt_line&OPT_GENERATE) {

		if (!(opt_line&OPT_NMASK) || !*nmask)
			fatalerr("err: -n/--nmask <arg> is required with -g");

		listgen(nmask, incr, nfile);

/* Scan mode */
     	} else 
		scan(nfile);


	exit(0);
}	 



void scan(char *nfile) /* Scanner engine */
{
	FILE * f;
	char n[MAX_NUM_LEN], status[10], c[2];
	int size = 1, result;

	bzero(n, MAX_NUM_LEN);
	bzero(status, 10);
	c[1] = 0;

/* Open numbers file */
	if ((f = fopen(nfile, "r+")) == NULL)
		fatalerr("err: unable to open file %s", nfile);

/* Open and init modem device */
	if ((fd = initmodem(MODEM_DEV)) < 0)
		fatalerr("err: unable to open %s", MODEM_DEV);

        fprintf(stderr,"WARD %s: classic war dialer\nCopyright (c) 2001 %s %s\n\n",VERSION,AUTHOR,MAIL_SUPPORT);
	fprintf(stdout, "Starting scan engine...\n");
	fprintf(stdout, "Resetting modem...\n");

        sendcmd(fd, 2, "ATZ\r");

	fprintf(stdout, "Done.                         \n");

                    
/* Parse the numbers file */
	while (size) {

/* Read phone number */
		while (1) {
			size = fread(c, 1, 1, f);  

			if (c[0] == '\t' || !size)
				break;

			if (c[0] != '\n')
				strncat(n, c, 1);
		}					

/* Read phone number status */
		while (1) {
			size = fread(c, 1, 1, f);

			if (c[0] == '\n' || !size)
				break;

			strncat(status, c, 1);
		}


/* Dial the number, if not already scanned */
		if (!strcmp(status, "UNSCANNED")) {

			result = dial(n);

                	switch (result) {
			case 1:
				fseek(f, -10, SEEK_CUR);
				fwrite("CONNECT  ", 9, 1, f);
				break;
			case 2:
				fseek(f, -10, SEEK_CUR);
                        	fwrite("BUSY     ", 9, 1, f);
				break;
			case 3:
				fseek(f, -10, SEEK_CUR);
                        	fwrite("TIMEOUT  ", 9, 1, f);
				break;
			}			
		}
				
        	bzero(n, MAX_NUM_LEN);
        	bzero(status, 10);
	}

/* Scan finished */
	fprintf(stdout, "Scan terminated.                    \n");
	sendcmd(fd, 2, "+++ATH0\r");
	sendcmd(fd, 2, "ATZ\r");
	closemodem(fd);

	return;
}



int dial(char *number) /* Actually dial a phone number */
{

/* 
 * Return values:
 *
 * 1) CONNECT
 * 2) BUSY
 * 3) Timeout
 * 4) EOF
 *
 */

	char buf[24];
	int i, rd;

        bzero(buf, sizeof(buf));

	if (!strlen(number)) 
		return(4);

/* Modem hangup */
	fprintf(stdout, "Hanging up...             \r");
	sendcmd(fd, 2, "ATH0\r");

        fprintf(stdout, "Dialing: %s (%i)        \r", number, timeout);
	
/* Create dial command string */
	sendcmd(fd, 2, "ATM0DT%s\r", number); /* modem volume set to 0 */

	for (i = timeout; i > 0; i--) {

		fprintf(stdout, "Dialing: %s (%i)    \r",number,i);

		if ((rd = read(fd, buf, 23))) {

			if (strstr(buf, "CONNECT") != NULL) {
				fprintf(stdout, "CONNECT: %s		 \n", number);

				sendcmd(fd, 2, "+++");

				return(1); /* CONNECT */
			}

			if (strstr(buf, "BUSY") != NULL) 
				return(2); /* BUSY */

		}
		sleep(1);
	}											
	return(3); /* Timeout */
}	



void writefile(int last, int incr, char *nfile) /* Write list to file */
{
	int i;
	FILE * f;

	if ((f = fopen(nfile, "a")) == NULL)
		fatalerr("err: unable to open file %s", nfile);
	
	fprintf(stdout, "Writing numbers to file...\n");

/* Use incremental mode writing to file */
	if (incr)
		for (i = 0; i < last; i++) {

			if (!fwrite(numbers[i], 1, strlen(numbers[i]), f))
				fatalerr("err: unable to write to file %s", nfile);

			fwrite("\tUNSCANNED\n", 1, 11, f); /* mark as new */

                        fprintf(stdout, "%d numbers left       \r", last - i);
		}

/* Use random mode (pHEAR) */
	else {
		int j;
		struct timeval rnd;

		while(last) {

/* Strong pseudo-random numbers generator */
			gettimeofday(&rnd, NULL);
			srand(rnd.tv_usec);

/* Some voodoo magic */
	                j= 0 + (int)((last + 0.0) * rand()/(RAND_MAX + 1.0));
			
                        if(!fwrite(numbers[j], 1, strlen(numbers[j]), f))
				fatalerr("err: unable to write to file %s", nfile);

			fwrite("\tUNSCANNED\n", 1, 11, f); /* mark as new */

			strncpy(numbers[j], numbers[last -1], MAX_NUM_LEN - 1);
			last--;
			
                        fprintf(stdout, "%d numbers left       \r", last);
		}		  

	}				
	fprintf(stdout, "Done.                 \n");

	return;
}		

	

void listgen(char *nmask, int incr, char *nfile) /* List generator engine */
{
	int i, j, tot_numbers, nextx = 0, nextn = 0, xpos[MAX_NUM_LEN];
	char n[MAX_NUM_LEN]; 
		

/* Find the position of the 'x' chars and substitute with '0' */
	for (i = 0; i < strlen(nmask); i++) {

		if (nmask[i] == 'x') {
			xpos[nextx] = i;
			nmask[i] = '0';
			nextx++;
		}
	}
	
	if (!nextx) 
		fatalerr("err: only 1 possible number, dial it by hand");

	tot_numbers = pow(10, nextx);
	numbers = (char **)malloc(tot_numbers * sizeof(char *));

/* Fill the numbers array with all possibilities */
        fprintf(stderr,"WARD %s: classic war dialer\nCopyright (c) 2001 %s %s\n\n",VERSION,AUTHOR,MAIL_SUPPORT);
	fprintf(stdout, "Generating number list...\n");

	for (i = 0; i < tot_numbers; i++) {

		snprintf(n, MAX_NUM_LEN, "%d", i);

/* Use POW operation properties in decimal notation */
	 	if (strlen(n) == nextx) {
	
	 		for (j = 0; j < nextx; j++) 
				nmask[xpos[j]] = n[j];
        
			numbers[nextn] = strdup((const char *)nmask);
                        nextn++;

		} else {

			for (j = 0 ; j < nextx - strlen(n); j++) 
				nmask[xpos[j]] = '0';

			for (j = nextx - strlen(n); j < nextx; j++)
				nmask[xpos[j]] = n[j + strlen(n) - nextx];

			numbers[nextn] = strdup((const char *)nmask);
                        nextn++;
		}

	}						
		
/* Write to file and free() the memory */
	writefile(nextn, incr, nfile);		

	for (i = 0; i < nextn; i++)
       		free(numbers[nextn]);

	return;
}	



int initmodem(char *device) /* Open modem device and init serial port */
{
	int flags;

        if( (fd = open(device, O_RDWR | O_NOCTTY | O_NONBLOCK)) < 0 )
                return(fd);

/* Save old settings */	
        tcgetattr(fd, &oldtio);

/* Set up the new struct and init serial port */
        bzero(&newtio, sizeof(newtio));

        newtio.c_cflag          = MODEM_SPEED | CS8 | CLOCAL | CREAD;
        newtio.c_iflag          = IGNPAR;
        newtio.c_oflag          = 0;
        newtio.c_lflag          = 0;
        newtio.c_cc[VTIME]      = 0;
        newtio.c_cc[VMIN]       = 0;

        tcflush(fd, TCIFLUSH);
        tcsetattr(fd, TCSANOW, &newtio);

/* We no longer want to have the serial port non-blocking */
        flags = fcntl(fd, F_GETFL);
        if (flags == -1)
                 fatalerr("err: failed to get serial tty flags"); 
        flags &= ~O_NONBLOCK;
        if (fcntl(fd, F_SETFL, flags) == -1)
                 fatalerr("err: failed to set serial port ~O_NONBLOCK");

        return(fd);
}



void closemodem(int fd) /* Close modem device */
{

/* Set old attributes for the serial port */
        tcsetattr(fd, TCSANOW, &oldtio);

        close(fd);
}



void sendcmd(int fd, int timewait, char * fmt,...) /* Send command to modem */
{
	char strbuf[128];
        va_list ap;

        bzero(strbuf, sizeof(strbuf));

        /* Flushes I/O */
        tcflush(fd, TCIOFLUSH);

        /* Transmits the command */
        va_start(ap, fmt);

        vsnprintf(strbuf, sizeof(strbuf) - 1, fmt, ap);
        write(fd, strbuf, strlen(strbuf));
        va_end(ap);

        /* Waits for whatever character has been transmitted */
        tcdrain(fd);
        sleep(timewait);

        return;
}



void cleanup(int ignored) /* SIGINT handler, close modem */
{
	if (fd) {
		sendcmd(fd, 2, "+++ATH0\r");
		sendcmd(fd, 2, "ATZ\r");
		closemodem(fd);
	}

	fprintf(stderr, "\n");
	fatalerr("err: program interrupted... cleanup done");	
}



void fatalerr(char * pattern,...) /* Error handling routine */
{
        va_list ap;
        va_start(ap, pattern);

        fprintf(stderr,"ward-");
        vfprintf(stderr,pattern,ap);
        fprintf(stderr," (exit forced).\n");

        va_end(ap);

        exit(-1);
}



void usage(char * name) /* Print usage */
{
        fprintf(stderr,"WARD %s: classic war dialer\nCopyright (c) 2001 %s %s\n\n",VERSION,AUTHOR,MAIL_SUPPORT);
        fprintf (stderr, 
		"usage: %s -g <file> -n <nmask> [-r]\t(generation mode)\n"
        	"       %s -s <file> [-t <timeout>]\t\t(scan mode)\n\n", name, name);

        fprintf (stderr,
		"In generation mode:\n"
                "     -g  generate number list and save it to file\n"
                "     -n  number mask to be used in generation mode\n"
                "     -r  toggle random mode ON\n\n"
		"In scan mode:\n"
                "     -s  scan a list of phone numbers from file\n"
                "     -t  set the modem timeout (default=%dsecs)\n\n"
                "     -h  print this help\n", timeout);

        exit (0);
}