#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h> /* for snmp */
#include <netinet/in.h> /* for snmp */
#include <stdio.h>
#include <ctype.h>
#include <time.h>
#include <sys/time.h> /* for snmp and other stuff */
#include <netdb.h> /* for snmp */
#include <errno.h>

#include "asn1.h"
#include "snmp_api.h"
#include "snmp_impl.h"
#include "snmp_client.h"
#include "mib.h"
#include "snmp.h"


/* START OF USER DEFINABLE SETTINGS */

#define SNMP_SET	"/usr/local/bin/snmpset -v 1"
#define CONF		"/path/to/maxchk.cfg"
			/* Default: chassis_group-auto/manual-max.log */
#define LOG_FILE_KILL   "/tmp/.%s-%s-max.log" /* where to log autokills */
					    /* and web-based port kills */
#define LOG_FILE        "/tmp/.%s-max.log" /* where to log any other stuff */

/* the max number of chassises you will be checking */
#define	MAX_CHASSISES		20
/* 137 * number of chassises available to check in this run */
#define	SESSION_LIST_SIZE	(137*MAX_CHASSISES)

/* END OF USER DEFINABLE SETTINGS */


#define UPTIME_OID	".1.3.6.1.4.1.529.9.2.0"
#define USERNAME_OID	".1.3.6.1.4.1.529.12.2.1.3"
#define SESTIME_OID	".1.3.6.1.4.1.529.11.2.1.3"
			/* enterprises.529.11.2.1.3 */
#define CALLREF_OID	".1.3.6.1.4.1.529.11.2.1.4"
#define SCALLREF_OID	".1.3.6.1.4.1.529.12.2.1.7"
#define HANGUP_OID	".1.3.6.1.4.1.529.12.3.1.3"

#define TXRATE_OID	".1.3.6.1.4.1.529.11.2.1.14"
#define RXRATE_OID	".1.3.6.1.4.1.529.11.2.1.5"
#define IPADDY_OID	".1.3.6.1.4.1.529.12.2.1.4"
#define SLOTNUM_OID	".1.3.6.1.4.1.529.11.2.1.6"
#define SLOTLINE_OID	".1.3.6.1.4.1.529.11.2.1.7"

int count_groups(char *str);
int convert_time(char *str);
char *strip_user(char *str);
char *strip_ip(char *str);
char *strip_user2(char *str);
char *strip_html(char *buffer);
char *get_time_as_string(void);
char *format_time(unsigned long up, unsigned long session);
char *send_request_get(char *objid, struct snmp_session *ss);
void send_request_walk(char *objid, struct snmp_session *ss);
void set_snmp_stuff(struct snmp_session *session);
void clear_structs(void);
void clear_results(void);
void read_config2(void);
void usage(void);
void move_results(int mode);
void remove_first(char *inpstr);
void remove_first_comma(char *inpstr);
void remove_first_underscore(char *inpstr);
void midcpy(char *strf, char *strt, int fr, int to);
void move_down(int pos);
void copy_list();
void print_header();
void print_users();
void clear_list();

/* for killing prototypes */
int find_free();
char *find_name(char *str, int wport);
void wlog(char *str);

char high_total='4';
int MAXSES=0;
int MAX_CHASSIS=0;
int MUST_BE_AT_TIME=0; /* for killing */
int DEBUG=0;
int DEBUG2=0;
int SNMP_DEBUG=0;
char READ_COMM[20];
char RW_COMM[20];
char URL[200];
char except_list_shown[500];
char except_list_killed[500];
char except_list_all[500];
char connlist[200][500];
char templist[200][500];
char results[SESSION_LIST_SIZE][100];
int hostindex=0;
int listindex=0;
int listindex2=0;
int loop_limit=137;
int HTML=1;
int BASIC=0;
int KILLING=0;
int M_KILLING=0;
unsigned long uptime;
unsigned int hightime=0;
char mess[500];
char *progname;
/* struct snmp_session session, *ss; */

struct {
	char hostname[32];
	char groupname[32];
	char name[32];
	int linestotal;
	int beforekill; /* for killing */
	char wanline[10];
	int wanport1;
	int wanport2;
	int wanport3;
	int wanport4;
	int needslotnum; /* do we need to get slotnums? we need to get */
			 /* these in chassises where lines are plugged */
			 /* into ports 3 and/or 4..if not, slotnum and */
			 /* slotline are the same thing (1 or 2), and  */
			 /* no need to waste precious time getting     */
			 /* slotnums                                   */
	} pwtable[MAX_CHASSISES];
	
struct {
	int num;
	int slotnum;
	int slotnum2;
	int slotline;
	int slotline2;
	int wanport;
	unsigned int timeonnum; /* for killing */
	char hostname[32]; /* for killing */
	char username[80];
	char username2[80];
	unsigned long session_time;
	unsigned long session_time2;
	char timeon[10];
	unsigned long callref;
	unsigned long scallref;
	unsigned long txrate;
	unsigned long txrate2;
	unsigned long rxrate;
	unsigned long rxrate2;
	unsigned long uptime; /* for killing */
	char ip[50];
	char ip2[50];
	} list[SESSION_LIST_SIZE];

void main(int argc, char **argv)
{
int tempcount=0,timeon=0,timeon2=0;
int i=1,xx=0,a=0,b=0,count=0,pricount=0,found=0,j=0,high_user;
int group_pos=0;
int group_count=0;
int group_at=0;
int group_lines=0;
int ch, num_opts=0;

char chunk0[500];
char host[32];
char high_host[32];
char timemess[30];
char hostname[64]; /* for manual killing */
char username[80]; /* for manual killing */
char callref[15]; /* for manual killing */
unsigned long callrefnum; /* for manual killing */
char *t;
char line[257];
char list_buf[257];
char templine[500];
char line2[500];
char junk1[256];
char junk2[256];
char junk3[256];
char junk4[256];
char command[256];
char objid[2048];
struct snmp_session session;
struct snmp_session *ss;
time_t tm;

  t = strrchr(argv[0], '/');
  progname = (t != NULL) ? t+1 : argv[0];

if ((argc==2) && (strstr(argv[1],"_")) && (strstr(argv[1],"."))) {
/* looks like a port kill from the web page */
M_KILLING=1;

/* Parse fields */
for (i=0;i<strlen(argv[1]);++i) {
   if (argv[1][i]=='_') break;
  }
midcpy(argv[1],hostname,0,i-1);
remove_first_underscore(argv[1]);
i=0;
for (i=0;i<strlen(argv[1]);++i) {
   if (argv[1][i]=='_') break;
  }
midcpy(argv[1],username,0,i-1);
remove_first_underscore(argv[1]);
i=0;
for (i=0;i<strlen(argv[1]);++i) {
   if (argv[1][i]=='_') break; 
  }
midcpy(argv[1],callref,0,strlen(argv[1])+1);
remove_first_underscore(argv[1]);
i=0;
}

  while ((ch = getopt(argc, argv, "BPk123")) != -1) {
    switch (ch) {
    case 'P':
        HTML = 0;
        num_opts++;
        break;
    case 'B':
        BASIC = 1;
        num_opts++;
        break;
    case 'k':
        KILLING = 1;
	loop_limit=SESSION_LIST_SIZE;
        num_opts++;
        break;
    case '1':
        DEBUG = 1;
	DEBUG2 = 0;
	SNMP_DEBUG = 0;
        num_opts++;
        break;
    case '2':
        DEBUG = 1;
        DEBUG2 = 1;
	SNMP_DEBUG = 0;
        num_opts++;
        break;
    case '3':
        DEBUG = 1;
        DEBUG2 = 1;
	SNMP_DEBUG = 1;
        num_opts++;
        break;
    default: 
        usage();
    } /* end of switch */
  } /* end of while */

if (argc > num_opts+1) {
if (M_KILLING) {
fprintf(stdout,"Content-type: text/html\n\n");
fprintf(stdout,"<HTML><BODY>\n");
}
else if (HTML && !KILLING) {
fprintf(stdout,"Content-type: text/html\n\n");
          fprintf(stdout,"<HTML>\n");
          fprintf(stdout,"<HEAD>\n");   
          fprintf(stdout,"<SCRIPT LANGUAGE=\"JavaScript\">\n");
          fprintf(stdout,"function open_win(url) {\n");
          fprintf(stdout,"remote = window.open(\"\",\"remotewin\",\"width=600,height=350,scrollbars=yes\");\n");
          fprintf(stdout,"remote.location.href = url;\n");
          fprintf(stdout,"    if (remote.opener == null) remote.opener = window; \n");
          fprintf(stdout,"remote.opener.name = \"opener\";\n");
          fprintf(stdout,"}\n");
          fprintf(stdout,"</SCRIPT>\n");
          fprintf(stdout,"</HEAD>\n");
fprintf(stdout,"<BODY><center>\n");
fprintf(stdout,"<b><font size=+2>Ascend Max Port Usage</font></b><br>\n");
fprintf(stdout,"<b>%s</b>\n", get_time_as_string());
fprintf(stdout,"<br></center><br>\n");
}
}
else {
fprintf(stdout,"No hosts specified to check!\n");
usage();
exit(0);
}

for (a=0;a<MAX_CHASSISES;++a) {
	pwtable[a].wanport1=0;
	pwtable[a].wanport2=0;
	pwtable[a].wanport3=0;
	pwtable[a].wanport4=0;

	pwtable[a].linestotal=0;
	pwtable[a].beforekill=0;
	pwtable[a].needslotnum=0;
	pwtable[a].hostname[0]=0;
	pwtable[a].groupname[0]=0;
	pwtable[a].name[0]=0;
	pwtable[a].wanline[0]=0;
	}
a=0;

read_config2();

if (DEBUG2) {
printf("Done reading config\n");
}

for (i=num_opts+1;i<argc;++i) {
	if (KILLING) clear_structs();

if (M_KILLING) {
	strcpy(host,hostname);
	callrefnum=atol(callref);
}
else
	strcpy(host,argv[i]);

START:
        if (group_at)
         a=group_pos+1;
        else
         a=0;

	if (!KILLING)
	clear_structs();

if (DEBUG) {
printf("Structs cleared\n");
}

        for (xx=0;xx<137;xx++) {
		connlist[xx][0]='\0';
	}
	xx=0;
        for (xx=0;xx<137;xx++) {
		templist[xx][0]='\0';
	}

	clear_results();

	for (a=a;a<MAX_CHASSIS;++a) {
                if (!strcmp(pwtable[a].hostname,host)) {
                found=1;
                group_pos=0;
                group_count=0;
                group_at=0;
                break; 
                }
                else if (!strcmp(pwtable[a].groupname,host)) {
                found=1;
                group_count=count_groups(host);
                group_pos=a;
                group_at++;
if (DEBUG) {
                printf("In group %s (at num %d total %d) pos %d<br>\n",host,group_at,group_count,group_pos);
}
                break;
                }
	} /* end of for */
	if (!found) {
	printf("Cant find host %s in table!\n",host);
	if (HTML) printf("</BODY></HTML>\n");
	exit(0);
	}
	else {
	found=0;
	hostindex=a;
	a=0;
	}

	tempcount=0;
	timeon=0;
	timeon2=0;
	line2[0]=0;
	chunk0[0]=0;
	command[0]=0;
	line[0]=0;
	templine[0]=0;
	junk1[0]=0;
	junk2[0]=0;
	junk3[0]=0;
	junk4[0]=0;
	uptime=0;
	count=0;
	pricount=0;
	a=0;
	b=0;
	j=0;
	found=0;
	hightime=0;	/* for killing */
	high_user=0;	/* for killing */

if (KILLING) listindex=listindex2;

set_snmp_stuff(&session);
/* snmp_synch_setup(&session); */
if (SNMP_DEBUG) {
printf("opening socket to %s with %s..\n",session.peername,session.community);
}
ss = snmp_open(&session);
if (SNMP_DEBUG) {
if (ss == NULL){
        snmp_sess_perror("maxlist_open", &session);
        exit(1);
}
else
 printf("done!\n");
}
strcpy(objid,UPTIME_OID);
if (DEBUG2) {
printf("GETTING UPTIME\n");
}
if (SNMP_DEBUG) {
printf("sending request..\n");
}
uptime = atol(send_request_get(objid,ss));
if (DEBUG2) {
printf("Uptime: %ld\n",uptime);
}

/* get calls */

/* session time */
if (DEBUG2) {
printf("GETTING SESSION TIME\n");
}
if (!BASIC || KILLING || M_KILLING) {
set_snmp_stuff(&session);
/* snmp_synch_setup(&session); */
objid[0]=0;
strcpy(objid,SESTIME_OID);
send_request_walk(objid,ss);
move_results(0);
clear_results();
}

/* call reference number */
if (DEBUG2) {
printf("GETTING CALLREFs\n");
}
set_snmp_stuff(&session);
/* snmp_synch_setup(&session); */
objid[0]=0;
strcpy(objid,CALLREF_OID);
send_request_walk(objid,ss);
move_results(1);
clear_results();

/* scall reference number */
if (DEBUG2) {
printf("GETTING SCALLREFs\n");
}
set_snmp_stuff(&session);
/* snmp_synch_setup(&session); */
objid[0]=0;
strcpy(objid,SCALLREF_OID);
send_request_walk(objid,ss);
move_results(2);
clear_results();

/* txrate */
if (!BASIC && !KILLING && !M_KILLING) {
if (DEBUG2) {
printf("GETTING TXRATEs\n");
}
set_snmp_stuff(&session);
/* snmp_synch_setup(&session); */
objid[0]=0;
strcpy(objid,TXRATE_OID);
send_request_walk(objid,ss);
move_results(3);
clear_results();

/* rxrate */
if (DEBUG2) {
printf("GETTING RXRATEs\n");
}
set_snmp_stuff(&session);
/* snmp_synch_setup(&session); */
objid[0]=0;
strcpy(objid,RXRATE_OID);
send_request_walk(objid,ss);
move_results(4);
clear_results();
}

/* slotnum */
if (pwtable[hostindex].needslotnum) {
if (DEBUG2) {
printf("GETTING SLOTNUMs for %s\n",pwtable[hostindex].hostname);
}
set_snmp_stuff(&session);
/* snmp_synch_setup(&session); */
objid[0]=0;
strcpy(objid,SLOTNUM_OID);
send_request_walk(objid,ss);
}
move_results(5);
clear_results();

/* slotline */
if (DEBUG2) {
printf("GETTING SLOTLINEs\n");
}
set_snmp_stuff(&session);
/* snmp_synch_setup(&session); */
objid[0]=0;
strcpy(objid,SLOTLINE_OID);
send_request_walk(objid,ss);
move_results(6);
clear_results();

/* ip address */
if (!KILLING && !M_KILLING) {
if (DEBUG2) {
printf("GETTING IP ADDRESS\n");
}
set_snmp_stuff(&session);
/* snmp_synch_setup(&session); */
objid[0]=0;
strcpy(objid,IPADDY_OID);
send_request_walk(objid,ss);
move_results(8);
clear_results();
}

/* username */
if (DEBUG2) {
printf("GETTING USERNAME\n");
}
set_snmp_stuff(&session);
/* snmp_synch_setup(&session); */
objid[0]=0;
strcpy(objid,USERNAME_OID);
send_request_walk(objid,ss);
move_results(9);
clear_results();

/* close out snmp session */
snmp_close(ss);
a=0;

/* raw data list, if we're testing */
if (DEBUG2) {
printf("Username\tIP\t\tCALLREF\tSCALLREF\tTXRATE\tSLOTNUM SLOTLINE SESSION_T\n");
for (a=0;a<loop_limit;++a) {
if (strlen(list[a].username) > 7) {
printf("%d: %s\t%s\t%ld\t%ld\t%ld %d %d %ld\n",a,list[a].username,list[a].ip,
list[a].callref,list[a].scallref,list[a].txrate,list[a].slotnum,list[a].slotline
,list[a].session_time);
}
else {
printf("%d: %s\t\t%s\t%ld\t%ld\t%ld %d %d %ld\n",a,list[a].username,list[a].ip,
list[a].callref,list[a].scallref,list[a].txrate,list[a].slotnum,
list[a].slotline,list[a].session_time);
} /* end of else */
} /* end of for */
} /* end of DEBUG2 */

	/* match up call reference numbers for sessions */
	for (a=listindex;a<loop_limit;++a) {
		/* cycle through second column of callref numbers */
		/* looking for match */
		for (b=listindex;b<loop_limit;++b) {
			if (list[a].scallref==list[b].callref) {
			found=1;
			break;
			}
		} /* end of sub for */
		if (found==1) {
			strcpy(list[a].username2,list[a].username);
			strcpy(list[a].ip2,list[a].ip);
			list[a].txrate2=list[b].txrate;
			list[a].rxrate2=list[b].rxrate;
			list[a].session_time2=list[b].session_time;
			list[a].slotnum2=list[b].slotnum;
			list[a].slotline2=list[b].slotline;
			found=0;
			}
		found=0;
		b=0;
	} /* end of for */
	a=0;
	b=0;

for (a=listindex;a<loop_limit;++a) {
		strcpy(list[a].username,list[a].username2);
		strcpy(list[a].ip,list[a].ip2);
		list[a].txrate=list[a].txrate2;
		list[a].rxrate=list[a].rxrate2;
		list[a].session_time=list[a].session_time2;
		list[a].slotnum=list[a].slotnum2;
		list[a].slotline=list[a].slotline2;
		list[a].callref=list[a].scallref;
}
a=0;

/* little more organized list, if we're testing */
if (DEBUG2) {
printf("Username\tIP\t\tCALLREF   SCALLREF   SESSION_T SLOTNUM SLOTLINE\n");
for (a=0;a<loop_limit;++a) {
if (strlen(list[a].username)) {
if (strlen(list[a].username) > 7) {
printf("%s\t%s\t%ld %ld %d %d %d\n",list[a].username,list[a].ip,
list[a].callref,list[a].scallref,list[a].session_time,list[a].slotnum,list[a].slotline);
}
else {
printf("%s\t\t%s\t%ld %ld %d %d %d\n",list[a].username,list[a].ip,
list[a].callref,list[a].scallref,list[a].session_time,list[a].slotnum,list[a].slotline);
} /* end of else */
} /* end of if strlen */
} /* end of for */
} /* end of DEBUG2 */

	/* go through list looking for valid status flags */
	/* and setting uptimes				  */
	for (a=listindex;a<loop_limit;++a) {
	if (strlen(list[a].username)) {
	 list[a].wanport = (2 * (list[a].slotnum - 1) + list[a].slotline);
	 if ((list[a].wanport == pwtable[hostindex].wanport1) ||
		(list[a].wanport == pwtable[hostindex].wanport2) ||
		(list[a].wanport == pwtable[hostindex].wanport3) ||
		(list[a].wanport == pwtable[hostindex].wanport4)) {
	 if (KILLING || M_KILLING) { pricount++; list[a].num=1; }
	 }
	 else {
	 if (KILLING || M_KILLING) list[a].num=0;
	 continue;
	 }
if (!KILLING && !M_KILLING) {
	 /* start outputting user listings here */
	 strcpy(list[a].username,strip_user2(list[a].username));

/* users that wont be shown */
found=0;
strcpy(list_buf,except_list_shown);
if (strlen(list_buf)) {
	while (strlen(list_buf)) {
	sscanf(list_buf,"%s ",templine);
	remove_first(list_buf);
	if (strstr(list[a].username,templine)) { found=1; break; }
	}
	if (found) { found=0; continue; }
}
/* users that wont be anything */
found=0;
strcpy(list_buf,except_list_all);
if (strlen(list_buf)) {
	while (strlen(list_buf)) {
	sscanf(list_buf,"%s ",templine);
	remove_first(list_buf);
	if (strstr(list[a].username,templine)) { found=1; break; }
	}
	if (found) { found=0; continue; }
}


if (!BASIC)
	 strcpy(list[a].timeon,format_time(uptime,list[a].session_time));

	 strcpy(connlist[count],"");
	 strcat(connlist[count],"<tr>");

	 sprintf(mess,URL,pwtable[hostindex].hostname,list[a].username,list[a].callref);
	 sprintf(templine,"<td><a href=\"javascript:open_win('%s');\">%-16s</a></td>",mess,list[a].username);
	 strcat(connlist[count],templine);

if (!BASIC) {
	 sprintf(templine,"<td>%-6ld</td>",list[a].txrate);
	 strcat(connlist[count],templine);
	 sprintf(templine,"<td>%-6ld</td>",list[a].rxrate);
	 strcat(connlist[count],templine);
}
	 sprintf(templine,"<td>%-16s</td>",list[a].ip);
	 strcat(connlist[count],templine);
if (!BASIC) {
	 sprintf(templine,"<td>%-3d</td>",list[a].wanport);
	 strcat(connlist[count],templine);
if (!HTML) {
/* we put the session ID in the text-only list in case the admin wants */
/* to kill them from the command line. In the HTML table they can just */
/* click on their name, so we wont inlcude it			       */
sprintf(templine,"%-11d",list[a].callref);
strcat(connlist[count],templine);
}
                if ((strlen(list[a].timeon) > 4) || ((strlen(list[a].timeon) == 4)
                        && (list[a].timeon[0]>=high_total) )) {
                sprintf(templine,"<td><font color=\"#FF0000\"><b><!---->%s</b></font></td>",list[a].timeon);
                strcat(connlist[count],templine);
                }
                else {
                  sprintf(templine,"<td><!---->%s</td>",list[a].timeon);
                  strcat(connlist[count],templine);
                  }
}

	 strcat(connlist[count],"</tr>\n");
         connlist[count][strlen(connlist[count])]=0;
	 count++;
} /* end of if !KILLING */
	 } /* end of if strlen username */
	} /* end of sub for */

if (!KILLING && !M_KILLING) {
	a=0;

	/* sort session list by time */
	j=0; tempcount=0; found=0;

	if (strlen(connlist[0])) {
                  strcpy(templist[tempcount],connlist[j]);
	}
                j++;

                while (strlen(connlist[j])) {
                        a=0; b=0;
                        timeon=0;
                        line2[0]=0;
                        chunk0[0]=0;
                  /* check time from stored line */
                  strcpy(line2,connlist[j]);
                  for (a=0;a<strlen(line2);++a) {
                        if (line2[a]=='!') { a=a+6; break; }
                        } /* end of for */
                  b=a;
                  for (b=b;b<strlen(line2);++b) {
                        if (line2[b]=='<') break;
                        }

                  midcpy(line2,chunk0,a,b-1);
                  a=0; b=0;
                  timeon=convert_time(chunk0);   
                  while (!found) {
                        timeon2=0;
                        line2[0]=0;
                        chunk0[0]=0;
                  /* GET TIME FROM LIST ITEM */
                  /* check time from stored line */
                        if (!strlen(templist[tempcount])) goto COPYEND;
                  strcpy(line2,templist[tempcount]);

                  for (a=0;a<strlen(line2);++a) {
                        if (line2[a]=='!') { a=a+6; break; }
                        } /* end of for */
                  b=a;
                  for (b=b;b<strlen(line2);++b) {
                        if (line2[b]=='<') break;
                        } /* end of for */

                  midcpy(line2,chunk0,a,b-1);
                  a=0; b=0;
                  timeon2=convert_time(chunk0);  
                  if (timeon >= timeon2) {
                         move_down(tempcount);
		COPYEND:
                        strcpy(templist[tempcount],connlist[j]);
                        found=1;
                        }
                  else {
                        tempcount++;
                        }
                  } /* end of sub-while */
                j++;
                tempcount=0;
                found=0; 
                } /* end of while */
                j=0;

                copy_list();
		print_header();
                print_users();   
		/* print cumulative modem usage */
	if (HTML) {
          fprintf(stdout,"<tr><td bgcolor=\"#ffafaf\" colspan=13><font size=+1 color=\"#000000\"><b>Active modems: %d &nbsp;&nbsp; Free modems: %d</b></font></td></tr>",
	  count,pwtable[hostindex].linestotal-count);
          fprintf(stdout,"</TABLE>\n</center>");
	}
	else {
          fprintf(stdout,"Active modems: %-4d Free modems: %d\n",
	  count,pwtable[hostindex].linestotal-count);
	}
                clear_list();
} /* end of if !KILLING */

if (KILLING) {
        if (group_at) {
        group_lines+=pricount;
		if (DEBUG) {
		printf("Got %d active lines from %s, Total at %d<br>\n",pricount,pwtable[hostindex].hostname,group_lines);
		}
        }
}

if (!group_at) {
 if (KILLING) { if (pricount < pwtable[hostindex].beforekill) continue; }
 else if (M_KILLING) { }
 else continue;
}
else if (group_at==group_count) {
	if (DEBUG) {
		printf("This is the last host in group (%s:%d)<br>\n",pwtable[hostindex].name,group_at);
	}
	if (KILLING) {
         if (group_lines < pwtable[hostindex].beforekill) {
		if (DEBUG) {
		printf("Group lines (%d) less than required kill lines (%d)<br>\n",group_lines,pwtable[hostindex].beforekill);
		}
                group_pos=0;
                group_count=0;
                group_at=0;
                continue;
                } /* end of if compare */
		/* ready for kill */
		if (DEBUG) {
		printf("Group lines (%d) MORE than required kill lines (%d)<br>\n",group_lines,pwtable[hostindex].beforekill);
		}
	} /* end of if KILLING */
	else {
                group_pos=0;
                group_count=0;
                group_at=0;
                continue;
	}
} /* end of else if */
else if (group_at) {
         goto START;
}

if (KILLING) {
/* main calculations for auto-killer */
        /* go through list looking for valid status flags */
        /* and setting uptimes                            */
if (DEBUG) printf("Looking for high user<br>\n");

        for (a=0;a<loop_limit;++a) {
        if (list[a].num==1) {
         strcpy(list[a].username,strip_user2(list[a].username));
         /* get session time */
         if (list[a].session_time > 0)
          list[a].timeonnum=(list[a].uptime-list[a].session_time)/60;
         else   
          list[a].timeonnum=0;

         strcpy(list[a].timeon,format_time(list[a].uptime,list[a].session_time));

/* users that wont be killed */
found=0;
strcpy(list_buf,except_list_killed);
if (strlen(list_buf)) {
	while (strlen(list_buf)) {
	sscanf(list_buf,"%s ",templine);
	remove_first(list_buf);
	if (strstr(list[a].username,templine)) { found=1; break; }
	}
	if (found) { found=0; continue; }
}
/* users that wont be anything */
found=0;
strcpy(list_buf,except_list_all);
if (strlen(list_buf)) {
	while (strlen(list_buf)) {
	sscanf(list_buf,"%s ",templine);
	remove_first(list_buf);
	if (strstr(list[a].username,templine)) { found=1; break; }
	}
	if (found) { found=0; continue; }
}

                if ((list[a].timeonnum > hightime) &&
                    (strlen(list[a].username))) {
                hightime=list[a].timeonnum;
                high_user=a;
                strcpy(high_host,list[a].hostname);
                }
        } /* end of if valid */
        } /* end of sub for */
        a=0;

if (DEBUG) printf("High user is %s with online time of %s (%u)<br>\n",list[high_user].username,list[high_user].timeon,list[high_user].timeonnum);

        time(&tm);
        sprintf(timemess,"%s",ctime(&tm));
        timemess[strlen(timemess)-1]=0;
                
        if (group_at) a=group_lines;
        else a=pricount;
        
        /* is the user on for the lower limit? */
        if (list[high_user].timeonnum < MUST_BE_AT_TIME) {
         sprintf(junk1,"%s MAX-killer didn't disconnect user %s not high enough time on %s (%s:%d) with time %s (%u).  Active lines: %d\n",
timemess,list[high_user].username,find_name(high_host,list[high_user].wanport),high_host,list[high_user].wanport,
list[high_user].timeon,list[high_user].timeonnum,a);  
        wlog(junk1);
        } 
        else {  
        sprintf(command,"%s %s %s %s.%ld i 1 1>/dev/null",SNMP_SET,high_host,RW_COMM,HANGUP_OID,list[high_user].callref);
        system(command);
        sprintf(junk1,"\n%s MAX-killer disconnected user %s on %s (%s:%d) with time %s (%u). Active lines: %d\n",
timemess,list[high_user].username,find_name(high_host,list[high_user].wanport),high_host,list[high_user].wanport,
list[high_user].timeon,list[high_user].timeonnum,a);
        wlog(junk1);
	/* puts(junk1); */
        } /* end of else */
        
                group_pos=0;
                group_count=0;
                group_at=0;
                pricount=0;
                a=0;
                found=0;

} /* end of if killing */
else if (M_KILLING) {
found=0;
/* main calculations for manual killer */
        /* go through list looking for valid status flags */
        /* and setting uptimes                            */
        for (a=0;a<loop_limit;++a) {
        if (list[a].num==1) {
         strcpy(list[a].username,strip_user2(list[a].username));
         /* get session time */
	if (callrefnum==list[a].callref) {
         if (list[a].session_time > 0)
          list[a].timeonnum=(list[a].uptime-list[a].session_time)/60;
         else   
          list[a].timeonnum=0;

         strcpy(list[a].timeon,format_time(list[a].uptime,list[a].session_time));
         found=1;
         break;
        } /* end of if is callref */
        } /* end of if valid */
        } /* end of sub for */

        if (!found) {
        printf("Can't find call reference number %u!<br>\n",callrefnum);
        printf("</BODY></HTML>\n");
        exit(0);
        }
         
        time(&tm);
        sprintf(timemess,"%s",ctime(&tm));
        timemess[strlen(timemess)-1]=0;
                
        sprintf(command,"%s %s %s %s.%ld i 1 1>/dev/null",SNMP_SET,list[a].hostname,RW_COMM,HANGUP_OID,list[a].callref);
        system(command);
	printf("User %s disconnected from %s<br>\n",
	list[a].username,pwtable[hostindex].name);
        sprintf(junk1,"\n%s Port-killer disconnected user %s on %s (%s:%d) with time %s (%u). Active lines: %d\n",
	timemess,list[a].username,pwtable[hostindex].name,
	list[a].hostname,list[a].wanport,list[a].timeon,list[a].timeonnum,
	pricount);
        wlog(junk1);
        
                group_pos=0;
                group_count=0;
                group_at=0;
                pricount=0;
                a=0;
                found=0;

} /* end of if M_KILLING */

   } /* end of main argc for */

if (HTML && !KILLING)
 fprintf(stdout,"</BODY>\n</HTML>\n\n");

} /* end of main */


void midcpy(char *strf, char *strt, int fr, int to)
{
int f;
for (f=fr;f<=to;++f)
  {
   if (!strf[f])
     {
      strt[f-fr]='\0';
      return;
     }
   strt[f-fr]=strf[f];
  }
strt[f-fr]='\0';
}


char *strip_user(char *str)
{
int zz=0;
static char usern[100];

midcpy(str,str,1,strlen(str));
for (zz=0;zz<strlen(str);++zz) {
	if (str[zz]=='\"') break;
	}
midcpy(str,usern,0,zz-1);

return usern;
}

char *strip_ip(char *str)
{
int zz=0;
static char ipn[40];

for (zz=0;zz<strlen(str);++zz) {
	if (str[zz]==' ') break;
	}
midcpy(str,ipn,zz+1,strlen(str));

return ipn;
}

char *strip_user2(char *str)
{
int z=0;
static char usern2[100];

for (z=0;z<strlen(str);++z) {
	if (str[z]=='@') break;
	}
midcpy(str,usern2,0,z-1);
return usern2;
}

void clear_structs(void)
{
int z=0;

	for (z=0;z<loop_limit;++z) {
	list[z].num=0;
	list[z].slotnum=0;
	list[z].slotnum2=0;
	list[z].slotline=0;
	list[z].slotline2=0;
	list[z].wanport=0;
	list[z].timeonnum=0;
	list[z].timeon[0]=0;
	list[z].username[0]=0;
	list[z].username2[0]=0;
	list[z].hostname[0]=0;
	list[z].session_time=0;
	list[z].session_time2=0;
	list[z].timeon[0]=0;
	list[z].callref=0;
	list[z].scallref=0;
	list[z].txrate=0;
	list[z].txrate2=0;
	list[z].rxrate=0;
	list[z].rxrate2=0;
	list[z].ip[0]=0;
	list[z].ip2[0]=0;
	list[z].uptime=0;
	}
}

char *format_time(unsigned long up, unsigned long session)
{
int minutes;
int ftime_hours;
char ftime_mins[3];
static char ftime[7];

if (session==0) {
	strcpy(ftime,"0");
	goto END;
	}

minutes = (up-session)/60;

/* convert minutes to mm or hh:mm */
if (minutes < 60) {
	sprintf(ftime,"%d",minutes);
	}
else {
	ftime_hours=minutes/60;
	minutes%=60;
	if (minutes < 10)
	 sprintf(ftime_mins,"0%d",minutes);
	else
	 sprintf(ftime_mins,"%d",minutes);

	sprintf(ftime,"%d:%s",ftime_hours,ftime_mins);
     } /* end of else */

END:
return ftime;
}

void move_down(int pos)
{
int found=0;
int aa=MAXSES-1;

for (aa=aa;aa>=0;--aa) {
        if (strlen(templist[aa])) { found=1; break; }
        }

if (found) {
  while (aa >= pos) {
  strcpy(templist[aa+1],templist[aa]);
  aa--;
  } /* end of while */
} /* end of if */

found=0;
aa=0;
} 

void copy_list()
{    
int i=0;
int j=0;
        
/* now copy them all back to the original list */
for (i=0;i<pwtable[hostindex].linestotal;++i) {
   if (strlen(templist[i])) {
        strcpy(connlist[j],templist[i]);
        j++;
        }  
   else break;
   } /* end of for */
/* clear any not used rows */
for (i=j;i<pwtable[hostindex].linestotal;++i) connlist[i][0]=0;
/* clear templist so we can use it again later */
for (i=0;i<pwtable[hostindex].linestotal;++i) templist[i][0]=0;
   
}

void clear_list()
{
int i=0;

/* clear templist so we can use it again later */
for (i=0;i<pwtable[hostindex].linestotal;++i) templist[i][0]=0;
/* clear connection list so we can use it again later */
for (i=0;i<pwtable[hostindex].linestotal;++i) connlist[i][0]=0;

}

void print_users()
{
int i=0;

while (strlen(connlist[i])) {
	if (!HTML)
	fprintf(stdout,strip_html(connlist[i]));
	else
        fprintf(stdout,connlist[i]);

        fflush(stdout);
        i++;
        } /* end of while */

}

int convert_time(char *str)
{
int a=0;
int numchunk1=0;
int numchunk2=0;
char chunk1[10];
char chunk2[10];
                        
                  if (strstr(str,":")) {
                        for (a=0;a<strlen(str);++a) {
                          if (str[a]==':') break;
                          } /* end of for */
                        /* copy hours and minutes to memory */
                        midcpy(str,chunk1,0,a-1);
                        midcpy(str,chunk2,a+1,strlen(str));

                        /* change to numeric */
                        numchunk1=atoi(chunk1); /* hour */
                        numchunk1=numchunk1*60; /* change hour to minutes */
                        numchunk2=atoi(chunk2); /* extra minutes */
                        /* calculate online time in minutes */
                        numchunk1=numchunk1+numchunk2;
                    } /* end of it strstr colon */
                  else if (strstr(str,"-")) { numchunk1=0; }
                  else { numchunk1=atoi(str); }

return numchunk1;
}

void print_header()
{

if (HTML) {
          fprintf(stdout,"<br><center><TABLE BORDER=1>\n");
          fprintf(stdout,"<tr><td colspan=13><font size=+1><b>%s (%s)</b></font></td></tr>",
                   pwtable[hostindex].name,pwtable[hostindex].hostname);
if (!BASIC) {
          fprintf(stdout,"<tr bgcolor=\"#ffafaf\">\n<td><b>Username</b></td>
                <td><b>TX Rate</b></td><td><b>RX Rate</b></td>
                <td><b>Hostname</b></td><td><b>PRI #</b></td>
		<td><b>Session Time</b></td>    
                </tr>\n");
  }
else {
          fprintf(stdout,"<tr bgcolor=\"#ffafaf\">\n<td><b>Username</b></td>
                <td><b>Hostname</b></td></tr>\n");
  }
 }
else {
 if (!BASIC)
          fprintf(stdout,"%-16s TX    RX   Hostname       PRI SessionID  Session Time\n","Username");
 else
          fprintf(stdout,"%-15s %s\n","Username","Hostname");
 }
}

char *get_time_as_string(void)
{
    time_t now;
    char *timestring;
          
    time(&now);
    timestring = ctime(&now);
          
    timestring[strlen(timestring) - 1] = '\0'; /*trim newline at end*/

    return timestring;
}

void read_config2(void)
{
int yy=0,zz=0,i=0,j=0;
char fileline[257];
char readbuf[256];
char temp[5];
FILE *fp2;
        
/*
if (!(fp2=fopen("/servers/www/fasttrack/bb/www/max/cgi-bin/cygnus/config.cfg","r")))
*/
if (!(fp2=fopen(CONF,"r")))
{
        printf("Can't open config file!<br>\n</BODY></HTML>\n");
        exit(0);
        }
else {
        yy=0;
        zz=0;
        while (fgets(fileline,256,fp2) != NULL) {
                fileline[strlen(fileline)-1]=0;
        if (fileline[0]=='#' || fileline[0]==' ' || !strlen(fileline)) continue;
        else {
                if (yy==0) {
                MAXSES=atoi(fileline);
                }
                else if (yy==1) {
		MUST_BE_AT_TIME=atoi(fileline);
                }
                else if (yy==2) {
		strcpy(READ_COMM,fileline);
                }
                else if (yy==3) {
		strcpy(RW_COMM,fileline);
                }
                else if (yy==4) {
		strcpy(URL,fileline);
                }
                else if (yy==5) {
		strcpy(except_list_shown,fileline);
                }
                else if (yy==6) {
		strcpy(except_list_killed,fileline);
                }
                else if (yy==7) {
		strcpy(except_list_all,fileline);
                }
                else if (yy >= 8) {
                sscanf(fileline,"%s ",pwtable[zz].hostname);
                remove_first(fileline);
                sscanf(fileline,"%s ",readbuf);
                pwtable[zz].linestotal=atoi(readbuf);
                remove_first(fileline);
		/* scan in beforekill line */
		sscanf(fileline,"%s ",readbuf);
		pwtable[zz].beforekill=atoi(readbuf);
                remove_first(fileline); /* before kill */
		sscanf(fileline,"%s ",pwtable[zz].wanline);
		if (strstr(pwtable[zz].wanline,",")) {
		for (i=0;i<strlen(pwtable[zz].wanline);++i) {
			if (pwtable[zz].wanline[i]==',') j++;		
		   }
		i=0;
		for (i=0;i<j+1;++i) {
			midcpy(pwtable[zz].wanline,temp,0,1);
			if (!strcmp(temp,"3") || !strcmp(temp,"4"))
				pwtable[zz].needslotnum=1;
			if (i==0)
			pwtable[zz].wanport1=atoi(temp);
			else if (i==1)
			pwtable[zz].wanport2=atoi(temp);
			else if (i==2)
			pwtable[zz].wanport3=atoi(temp);
			else if (i==3)
			pwtable[zz].wanport4=atoi(temp);

			if (strstr(pwtable[zz].wanline,","))
			remove_first_comma(pwtable[zz].wanline);
		   }
		}
		else {
			pwtable[zz].wanport1=atoi(pwtable[zz].wanline);
		}
		i=0; j=0;
/*
		printf("Wanports: %d %d %d %d\n",pwtable[zz].wanport1,
pwtable[zz].wanport2,pwtable[zz].wanport3,pwtable[zz].wanport4);
*/
		remove_first(fileline);
                sscanf(fileline,"%s ",pwtable[zz].groupname);  
                remove_first(fileline); /* group name */
                strcpy(pwtable[zz].name,fileline);
                zz++;
                }
                yy++;
         } /* end of else */
        } /* end of while */
}
fclose(fp2);
MAX_CHASSIS=zz;
if (DEBUG2) {
for (zz=0;zz<MAX_CHASSIS;++zz)
printf("%2d: %s %s %d\n",zz,pwtable[zz].hostname,pwtable[zz].groupname,pwtable[zz].linestotal);
}
}

/*** removes first word at front of string and moves rest down ***/
void remove_first(char *inpstr)
{
int newpos,oldpos;

newpos=0;  oldpos=0;
/* find first word */
while(inpstr[oldpos]==' ') {
        if (!inpstr[oldpos]) { inpstr[0]=0;  return; }
        oldpos++;
        }
/* find end of first word */
while(inpstr[oldpos]!=' ') {
        if (!inpstr[oldpos]) { inpstr[0]=0;  return; }
        oldpos++;
        }
/* find second word */
while(inpstr[oldpos]==' ') {
        if (!inpstr[oldpos]) { inpstr[0]=0;  return; }
        oldpos++;
        }
while(inpstr[oldpos]!=0)
        inpstr[newpos++]=inpstr[oldpos++];
inpstr[newpos]='\0';
}

/*** removes first word at front of string and moves rest down ***/
void remove_first_comma(char *inpstr)
{
int newpos,oldpos;

newpos=0;  oldpos=0;
/* find first word */
while(inpstr[oldpos]==',') {
        if (!inpstr[oldpos]) { inpstr[0]=0;  return; }
        oldpos++;
        }
/* find end of first word */
while(inpstr[oldpos]!=',') {
        if (!inpstr[oldpos]) { inpstr[0]=0;  return; }
        oldpos++;
        }
/* find second word */
while(inpstr[oldpos]==',') {
        if (!inpstr[oldpos]) { inpstr[0]=0;  return; }
        oldpos++;
        }
while(inpstr[oldpos]!=0)
        inpstr[newpos++]=inpstr[oldpos++];
inpstr[newpos]='\0';
}


/*** removes first word at front of string and moves rest down ***/
void remove_first_underscore(char *inpstr)   
{
int newpos,oldpos;
        
newpos=0;  oldpos=0;
/* find first word */
while(inpstr[oldpos]=='_') {
        if (!inpstr[oldpos]) { inpstr[0]=0;  return; }
        oldpos++;
        }
/* find end of first word */
while(inpstr[oldpos]!='_') {
        if (!inpstr[oldpos]) { inpstr[0]=0;  return; }
        oldpos++;
        }
/* find second word */
while(inpstr[oldpos]=='_') {
        if (!inpstr[oldpos]) { inpstr[0]=0;  return; }
        oldpos++;
        }
while(inpstr[oldpos]!=0)
        inpstr[newpos++]=inpstr[oldpos++];
inpstr[newpos]='\0';
}


int count_groups(char *str)
{
int number=0;
int i=0;
char fileline[257];
char readbuf[256];
FILE *fp2;
        
if (!(fp2=fopen(CONF,"r")))
{               
        printf("Can't open config file!\nerrno: %d strerrno: %s\n",errno,strerror(errno));
        exit(0);
        }
else {
        i=0;
        while (fgets(fileline,256,fp2) != NULL) {
                fileline[strlen(fileline)-1]=0;
        if (fileline[0]=='#' || fileline[0]==' ' || !strlen(fileline)) continue;
        else {
                if ((i==0) || (i==1) || (i==2) || (i==3) ||
                    (i==4)) { i++; continue; }
                else if (i >= 5) {
                remove_first(fileline); /* host */
                remove_first(fileline); /* lines total */
                remove_first(fileline); /* before kill */
                remove_first(fileline); /* wanports */
                sscanf(fileline,"%s ",readbuf);  
                if (!strcmp(readbuf,str)) number++;
                }
            i++;
         } /* end of else */
        } /* end of while */
}
fclose(fp2);
                
return number;
}

char *strip_html(char *buffer)
{
int i=0,j=0;  
int pos=0;
static char buffer2[300];
         
buffer2[0]=0;
        
if (!strstr(buffer,"<") || !strstr(buffer,">")) {
        strcpy(buffer2,buffer);
        goto JUMP;
        }

j=0; pos=0;
for (i=0;i<strlen(buffer);++i) {
        if ((pos==1) && (buffer[i]=='>')) { pos=0; continue; }
        else if (pos==1) { continue; }
        
        if (buffer[i]=='<') { pos=1; continue; } 
        else { buffer2[j]=buffer[i]; j++; }
        
  } /* end of for */

buffer2[j]='\0';

JUMP:
return buffer2;
}       

/* show usage info */
void usage(void)
{
  fprintf(stderr, "Usage: %s [-PBk123] [hub/group1 hub/group2...] or [hub_username_sessionid]\n",progname);
  fprintf(stderr, "  -P\tPlain     - DONT add html codes to the output\n");
  fprintf(stderr, "  -B\tBasic     - Only show username/IP information\n");
  fprintf(stderr, "  -k\tAuto-kill - Kill highest user on specified boxes if all lines used\n");
  fprintf(stderr, "  \tPort-kill - use \"hub_username_sessionid\" option\n");
  fprintf(stderr, "Debugging:\n");
  fprintf(stderr, "  -1              - Basic debugging\n");
  fprintf(stderr, "  -2              - Verbose debugging\n");
  fprintf(stderr, "  -3              - Verbose debugging and SNMP debugging\n");
  fprintf(stderr, "\n");
  exit(0);
}

char *send_request_get(char *objid, struct snmp_session *ss) {
char buf[2048];
static char retval[2049];
int status=0;
oid name[MAX_NAME_LEN];
struct variable_list *vars;
struct snmp_pdu *pdu;
struct snmp_pdu *response;
size_t name_length = MAX_OID_LEN;

retval[0]=0;
buf[0]=0;

if (DEBUG2) {
printf("Requesting %s\n",objid);
}

/*
printf("SNMP_MSG_GET: %d\n",SNMP_MSG_GET);
*/

pdu = snmp_pdu_create(SNMP_MSG_GET);

if (SNMP_DEBUG) {
printf("Created SNMP request\n");
}

if(!read_objid(objid,name,&name_length)) {
        printf("Invalid OBJID: %s.\n",objid);
        return(NULL);
}
else {
snmp_add_null_var(pdu,name,name_length);
}

if (DEBUG2) printf("OBJID passed\n");
if (DEBUG) {
printf("getting from %s with %s..\n",ss->peername,ss->community);
if (DEBUG2) snmp_sess_perror("maxlist_retrieve", ss);
}
        
retry:
  status = snmp_synch_response(ss, pdu, &response);

  if(status == STAT_SUCCESS) {
  if(response->errstat == SNMP_ERR_NOERROR) {
     for(vars = response->variables;vars;vars = vars->next_variable)
       sprint_value(buf,vars->name,vars->name_length,vars);
  } else {  
        /*
    printf("Error in packet\n");
    printf("Reason: %s\n",snmp_errstring(response->errstat));
        */
        if ((pdu = snmp_fix_pdu(response, SNMP_MSG_GET)) != NULL)
          goto retry;
   } /* end of else */
  }  /* end of status if */
  else if (status == STAT_TIMEOUT) {
        printf("No Response from %s.\n", ss->peername);
    } else {    /* status == STAT_ERROR */
     snmp_sess_perror("maxlist", ss);
     printf("An error occurred\n");
    }
          
if (response)
 snmp_free_pdu(response);
/* snmp_close(ss); */ 
  
if (SNMP_DEBUG) {
printf("Freed\n");
}
/* retval = new char[strlen(buf)+1]; */
bzero(retval,strlen(buf)+1);
if (SNMP_DEBUG) {
printf("zeroed\n");
}
strncpy(retval,buf,strlen(buf));
if (SNMP_DEBUG) printf("copied\n");
return(retval);
}


void send_request_walk(char *objid, struct snmp_session *ss) {
char tempresult[200];
char *tempresult2;
int running,count,y=0;
char buf[2048];
static char retval[2049];
int status=0;
oid name[MAX_NAME_LEN];
size_t name_length = MAX_OID_LEN;
oid root[MAX_NAME_LEN];
size_t rootlen = MAX_OID_LEN;
struct variable_list *vars;
struct snmp_pdu *pdu;
struct snmp_pdu *response;

retval[0]=0;
buf[0]=0;

if (SNMP_DEBUG) printf("OBJID: %s\n",objid); 

if (!read_objid(objid, root, &rootlen)){
        fprintf(stderr, "Invalid root OBJID: %s\n", objid);
        return;
      }

    /* get first object to start walk */
    memmove(name, root, rootlen * sizeof(oid));
    name_length = rootlen;

    running = 1;
    count = 1;
    while(running){
      /* create PDU for GETNEXT request and add object name to request */
      pdu = snmp_pdu_create(SNMP_MSG_GETNEXT);
if (SNMP_DEBUG) printf("Created\n");
      snmp_add_null_var(pdu, name, name_length);

      /* do the request */
      status = snmp_synch_response(ss, pdu, &response);

      if (status == STAT_SUCCESS){
if (SNMP_DEBUG) printf("success\n");
        if (response->errstat == SNMP_ERR_NOERROR){
if (SNMP_DEBUG) printf("no error\n");
          /* check resulting variables */
          for(vars = response->variables; vars; vars = vars->next_variable){
            if ((vars->name_length < rootlen) ||
                (memcmp(root, vars->name, rootlen * sizeof(oid))!=0)) {
              /* not part of this subtree */
if (SNMP_DEBUG) printf("root %s not part of subtree\n",root);
              running = 0;
              continue;   
            }
if (SNMP_DEBUG) printf("getting variable\n");
            sprint_variable(tempresult, vars->name, vars->name_length, vars);
if (SNMP_DEBUG) printf("got\n");
	tempresult2 = strchr(tempresult,'=');
if (SNMP_DEBUG) printf("parsed\n");
	midcpy(tempresult2,results[y],2,strlen(tempresult2));
if (SNMP_DEBUG) printf("Result %d: %s\n",y,results[y]);
	if (!strcmp(objid,SESTIME_OID))
	    listindex2++;

	    y++;
            if ((vars->type != SNMP_ENDOFMIBVIEW) &&
                (vars->type != SNMP_NOSUCHOBJECT) &&
                (vars->type != SNMP_NOSUCHINSTANCE)){
              /* not an exception value */
              memmove((char *)name, (char *)vars->name,
              vars->name_length * sizeof(oid));
              name_length = vars->name_length;
            } else
              /* an exception value, so stop */
              running = 0;
          } /* end of for */
        } else {
          /* error in response, print it */
          running = 0;
          if (response->errstat == SNMP_ERR_NOSUCHNAME){
            printf("End of MIB\n");
          } else {
            fprintf(stderr, "Error in packet.\nReason: %s\n",
                    snmp_errstring(response->errstat));
            if (response->errstat == SNMP_ERR_NOSUCHNAME){
              fprintf(stderr, "The request for this object identifier failed: ");
              for(count = 1, vars = response->variables;
                    vars && count != response->errindex;
                    vars = vars->next_variable, count++)
                /*EMPTY*/;
              if (vars)
                fprintf(stderr, "This: %s", (char *)vars->name);
/*                fprint_objid(stderr, vars->name, vars->name_length); */
              fprintf(stderr, "\n");
            } /* end of sub NOSUCHNAME if */
          } /* end of NOSUCHNAME else */
        } /* end of ERR_NOERROR else */
      } else if (status == STAT_TIMEOUT){
        fprintf(stderr, "No Response from %s\n", ss->peername);
        running = 0;
      } else {    /* status == STAT_ERROR */
        fprintf(stderr, "A SNMP error occurred\n");
        running = 0;
      } /* end of status else */
      if (response)
        snmp_free_pdu(response);
    } /* end of running while */
/* snmp_close(ss); */

/*
if (SNMP_DEBUG) printf("Freed\n");
bzero(retval,strlen(buf)+1);
if (SNMP_DEBUG) printf("zeroed\n");
strncpy(retval,buf,strlen(buf));
if (SNMP_DEBUG) printf("copied\n");
return(retval);
*/
}

void set_snmp_stuff(struct snmp_session *session) {
char *community;
char *hostname;

community = READ_COMM;
hostname = pwtable[hostindex].hostname;

if (SNMP_DEBUG) {
printf("setting snmp stuff for set host %s (orig: %s)\n",hostname,pwtable[hostindex].hostname);
}

snmp_sess_init( session );

/*
memset(session, 0, sizeof(struct snmp_session));
*/
session->peername = (char *)hostname;
session->version = 0;
session->community = (unsigned char *)community;
session->community_len = strlen((char *)community);
/*
session->remote_port = (u_short)161;
session->retries = -1;
*/
session->timeout = (long)-1;
/*
session->authenticator = NULL;
*/
}

void clear_results(void) {
int jj=0;

        for (jj=0;jj<SESSION_LIST_SIZE;jj++) {
		results[jj][0]='\0';
	}
}

void move_results(int mode) {
int kk=0,yy=0;

if (KILLING) kk=listindex;

for (kk=kk,yy=0;kk<SESSION_LIST_SIZE;++kk,++yy) {
        if (mode==0) {
        list[kk].session_time = atol(results[yy]);
	strcpy(list[kk].hostname,pwtable[hostindex].hostname);
	list[kk].uptime=uptime;
        }
        else if (mode==1) {
        list[kk].callref = atol(results[yy]);
        }
        else if (mode==2) {
        list[kk].scallref = atol(results[yy]);
        }
        else if (mode==3) {
        list[kk].txrate = atol(results[yy]);
        }
        else if (mode==4) {
        list[kk].rxrate = atol(results[yy]);
        }
        else if (mode==5) {
	if (pwtable[hostindex].needslotnum)
		list[kk].slotnum = atoi(results[yy]);
	else
		list[kk].slotnum = 1;
        }
        else if (mode==6) {
        list[kk].slotline = atoi(results[yy]);
        }
        else if (mode==8) {
        strcpy(list[kk].ip,strip_ip(results[yy]));
        }
        else if (mode==9) {
        strcpy(list[kk].username,strip_user(results[yy]));
        }
} /* end of for */
kk=0;
yy=0;
        
}

int find_free()
{
int zz=0;
 
for (zz=0;zz<SESSION_LIST_SIZE;++zz) {
	if (strlen(list[zz].username)) {
        if (list[zz].num==0) break;
	}
        }

return zz;
}

char *find_name(char *str, int wport)
{
int zz=0;

for (zz=0;zz<MAX_CHASSIS;++zz) {   
        if (!strcmp(str,pwtable[zz].hostname) &&
	    ( (wport==pwtable[zz].wanport1) ||
	      (wport==pwtable[zz].wanport2) ||
	      (wport==pwtable[zz].wanport3) ||
	      (wport==pwtable[zz].wanport4)
	    )
           ) break;
   }

return pwtable[zz].name;
}

void wlog(char *str)
{
char filename2[256];
FILE *fp;

if (KILLING)
	sprintf(filename2,LOG_FILE_KILL,pwtable[hostindex].groupname,"auto");
else if (M_KILLING)
	sprintf(filename2,LOG_FILE_KILL,pwtable[hostindex].groupname,"manual");
else
	sprintf(filename2,LOG_FILE,pwtable[hostindex].groupname);
fp=fopen(filename2,"a");
fputs(str,fp);
fclose(fp);
}