/*
   chanprog.c -- handles:
     maintaining the server list
     revenge punishment
     reading the config file (non-Tcl)

   dprintf'ized, 1nov95
*/

/* config file format changed 27jan94 (Tcl outdates that) */

#define _CHANPROG

#if HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>   /* for mips */
#include "eggdrop.h"
#include "users.h"
#include "proto.h"

extern int serv;
extern int shtime;
extern int op_on_join;
extern int revenge;
extern int telnet_port;
extern int min_servs;
extern int curserv;
extern char botname[];
extern char origbotname[];
extern char botuser[];
extern char bothost[];
extern char botrealname[];
extern char botserver[];
extern char botchan[];
extern char curchan[];
extern char configfile[];
extern char dccdir[];
extern char dccin[];
extern char motdfile[];
extern char admin[];
#ifdef TCL
extern char need_op[];
extern char need_invite[];
#else
extern char gainops[];
#endif
extern char userfile[];
extern char helpbot[];
extern char helpserver[];
extern char helpdir[];
extern char initserver[];
extern char chankey[];
extern char notify_new[];
extern char tempdir[];
extern char ctcp_version[];
extern char ctcp_finger[];
extern char ctcp_userinfo[];
extern char textdir[];
extern char owner[];
extern int botserverport;
extern int dcc_total;
extern int use_stderr;
extern int greet;
extern int learn_users;
extern int helpserverport;
extern int helpserv;
extern int flood_thr;
extern int flood_pub_thr;
extern int flood_join_thr;
extern int require_x;
extern int enforce_bans;
extern int share_users;
extern int use_info;
extern int passive;
extern int strict_host;
extern int noshare;
extern int require_p;
extern int isolate;
extern int conmask;
extern int default_flags;
extern int keep_all_logs;
extern int chan_updates;
extern int raw_files;
extern int perm_bans;
extern int ban_time;
extern int ignore_time;
extern int make_userfile;
extern int upload_to_cd;
extern int dcc_limit;
extern int idle_kick;
extern int bitch;
extern int never_give_up;
extern int protect_ops;
extern int allow_new_telnets;
extern int forbid_bans;
extern int keepnick;
extern int dcc_block;
extern int dcc_maxsize;
extern int dcc_users;
extern struct dcc_t dcc[];
extern char *logfile[];
extern int logmask[];
extern char cx_file[];
extern int cx_line;
extern struct userrec *userlist;
extern char SBUF[];
char oldchan[121]="";
char oldnick[10]="";


/* clear old bans from the channel when we get ops? */
int clearbans=0;
/* where to store notes */
char notefile[121];

/* old-style queue, still used by server list */
struct eggqueue *serverlist=NULL;


/* remove space characters from beginning and end of string */
/* (more efficent by Fred1) */
void rmspace(s)
char *s;
{
#define whitespace(c) ( ((c)==32) || ((c)==9) || ((c)==13) || ((c)==10) )
  char *p;
  /* wipe end of string */
  for (p=s+strlen(s)-1; ((whitespace(*p))&&(p>=s)); p--); 
  if (p!=s+strlen(s)-1) *(p+1)=0;
  for (p=s; ((whitespace(*p)) && (*p)); p++); if (p!=s) strcpy(s,p);
}

/* memory we should be using */
int expmem_chanprog()
{
  int tot; struct eggqueue *s=serverlist;
  tot=0;
  while (s!=NULL) {
    tot+=strlen(s->item)+1;
    tot+=sizeof(struct eggqueue);
    s=s->next;
  }
#ifndef TCL
  {
  int i;
  for (i=0; i<MAXLOGS; i++) if (logfile[i]!=NULL) tot+=strlen(logfile[i])+1;
  }
#endif
  return tot;
}

/* add someone to a queue */
struct eggqueue *addq(ss,q)
char *ss; struct eggqueue *q;
{
  char s[512]; struct eggqueue *x,*z; char s1[121],*p;
  strcpy(s,ss);
  do {
    p=strchr(s,','); if (p!=NULL) { *p=0; p++; strcpy(s1,p); } else s1[0]=0;
    rmspace(s); rmspace(s1);
    x=(struct eggqueue *)nmalloc(sizeof(struct eggqueue));
    x->next=NULL;
    x->item=(char *)nmalloc(strlen(s)+1);
    strcpy(x->item,s);
    if (q==NULL) q=x;
    else {
      z=q; while (z->next!=NULL) z=z->next;
      z->next=x;
    }
    s[0]=0; strcpy(s,s1);
  } while (s[0]);
  return q;
}

/* remove someone from a queue */
struct eggqueue *delq(s,q,ok)
char *s; struct eggqueue *q; int *ok;
{
  struct eggqueue *x,*ret,*old;
  x=q; ret=q; old=q; *ok=0;
  while (x!=NULL) {
    if (strcasecmp(x->item,s)==0) {
      if (x==ret) {
	ret=(x->next);
	nfree(x->item); nfree(x);
	x=ret;
      }
      else {
	old->next=x->next;
	nfree(x->item); nfree(x); x=old->next;
      }
      *ok=1;
    }
    else { old=x; x=x->next; }
  }
  return ret;
}

/* clear out a list */
void clearq(xx)
struct eggqueue *xx;
{
  struct eggqueue *x,*x1;
  x=xx; while (x!=NULL) {
    x1=x->next; nfree(x->item); nfree(x);
    x=x1;
  }
}

/* new server to the list */
void add_server(s) char *s; { serverlist=addq(s,serverlist); }

/* set botserver to the next available server */
/* -> if (*ptr == -1) then jump to that particular server */
void next_server(ptr,serv,port,pass)
int *ptr,*port; char *serv,*pass;
{
  struct eggqueue *x=serverlist; int ok=1,i; char s[121];
  context;
  if (x==NULL) return;
  /* -1  -->  go to specified server */
  if (*ptr == -1) {
    char sv[121]; int p;
    ok=0; i=0;
    while ((x!=NULL) && (!ok)) {
      strcpy(s,x->item); splitc(sv,s,':');
      if (!sv[0]) { strcpy(sv,s); p=6667; }
      else { p=atoi(s); }
      if ((strcasecmp(sv,serv)==0) && (p==*port)) ok=1;
      else { x=x->next; i++; }
    }
    if (ok) { *ptr=i; return; }  /* requested server is valid */
    /* gotta add it : */
    sprintf(s,"%s:%d",serv,*port);
    if (pass[0]) { strcat(s,":"); strcat(s,pass); }
    serverlist=addq(s,serverlist); *ptr=i;
    return;
  }
  /* find where i am and boogey */
  i=(*ptr);
  while ((i>0) && (x!=NULL)) { x=x->next; i--; }
  if (x!=NULL) { x=x->next; (*ptr)++; }     /* go to next server */
  if (x==NULL) { x=serverlist; *ptr=0; }    /* start over at the beginning */
  pass[0]=0; strcpy(s,x->item); splitc(serv,s,':');
  if (!serv[0]) { strcpy(serv,s); *port=6667; }
  else {
    char xs[121];
    *port=atoi(s); splitc(xs,s,':');
    if (xs[0]) strcpy(pass,s);
  }
  return;
}

/* show server list, and point out which ones the bot and helpbot are on */
void tell_servers(idx)
int idx;
{
  struct eggqueue *x=serverlist; int i,sp; char s[141],sv[121];
  context;
  if (x==NULL) {
    dprintf(idx,"No servers.\n"); return;
  }
  dprintf(idx,"My server list:\n"); i=0;
  while (x!=NULL) {
    strcpy(s,x->item); splitc(sv,s,':'); 
    if (!sv[0]) { strcpy(sv,s); sp=6667; }
    else sp=atoi(s);
    sprintf(s,"  %s:%d",sv,sp);
    if (i==curserv) strcat(s,"   <- I am here.");
    if ((helpbot[0]) && (i==helpserv)) strcat(s,"   <- The helpbot is here.");
    dprintf(idx,"%s\n",s); x=x->next; i++;
  }
}

void wipe_serverlist()
{
  if (serverlist==NULL) return;
  clearq(serverlist); serverlist=NULL;
}

/* revenge tactic: person did something bad */
/* if they're oplisted, remove them from the op list */
/* otherwise, deop them */
void unprog_op_and_deop(who,reason)
char *who; char *reason;
{
  char nick[10],s[121],s1[121]; int i,atr;
  context;
  atr=get_attr_host(who);
  if (atr & USER_FRIEND) {
    log(LOG_MISC,"%s is a friend (%s)",who,reason);
    return;  /* argh! */
  }
  if (change_attr(who,'-',USER_OP)) {
    log(LOG_MISC,"No longer opping %s (%s)",who,reason);
    return;
  }
  if (match_ban(who)) {
    /* what more can we do? */
    return;
  }
  if (atr & USER_DEOP) {
    /* this is out of control: BAN THEM */
    log(LOG_MISC,"Now banning %s (%s)",who,reason);
    strcpy(s1,who); splitnick(nick,s1); maskhost(s1,s);
    strcpy(s1,"*!*"); strcat(s1,&s[2]);   /* add extra * for ban */
    prog_ban(s1,time(NULL),reason);
    return;
  }
  if (change_attr(who,'+',USER_DEOP)) {
    /* in the user list already, cool :) */
    log(LOG_MISC,"Now deopping %s (%s)",who,reason);
    return;
  }
  strcpy(s1,who); splitnick(nick,s1);
  maskhost(s1,s);
  while (is_user(nick)) {
    if (strncmp(nick,"bad",3)==0) {
      i=atoi(&nick[3]); sprintf(nick,"bad%d",i+1);
    }
    else strcpy(nick,"bad1");
  }
  userlist=adduser(userlist,nick,s,"nopass",USER_DEOP);
  sprintf(s,"%s (%s)",who,reason);
  set_handle_comment(userlist,nick,s);
  log(LOG_MISC,"Now deopping %s (%s)",who,reason);
}

/* clear out the programming */
void clearprog()
{
  context;
  clear_userlist(userlist); userlist=NULL;
  clearq(serverlist); serverlist=NULL;
  strcpy(oldchan,curchan);
  strcpy(oldnick,botname);
}

/* Tcl has its own much simpler 'set' */
#ifndef TCL
#define PSET(x) { (x)=ans; \
               if (idx>=0) dprintf(idx,"Set %s %s.\n",which,ans?"on":"off"); }
#define ONOFF(idx,x,y,x1,y1) dprintf(idx,"%-15s %3s     %-15s %3s\n",x,y? \
				   "ON":"OFF",x1,(y1==(-1)?"":(y1?"ON":"OFF")))
/* set an on/off switch */
void prog_set(this,idx)
char *this; int idx;
{
  char which[41]; int ans;
  context;
  if (this[0]==0) {
    if (idx>=0) {
      ONOFF(idx,"log-time",shtime,"isolate",isolate);
      ONOFF(idx,"clear-bans",clearbans,"keep-all-logs",keep_all_logs);
      ONOFF(idx,"op-on-join",op_on_join,"chan-updates",chan_updates);
      ONOFF(idx,"revenge",revenge,"raw-files",raw_files);
      ONOFF(idx,"greet",greet,"perm-bans",perm_bans);
      ONOFF(idx,"learn-users",learn_users,"upload-to-cd",upload_to_cd);
      ONOFF(idx,"require-x",require_x,"bitch",bitch);
      ONOFF(idx,"require-p",require_p,"never-give-up",never_give_up);
      ONOFF(idx,"enforce-bans",enforce_bans,"protect-ops",protect_ops);
      ONOFF(idx,"use-info",use_info,"forbid-bans",forbid_bans);
      ONOFF(idx,"share-users",share_users,"keep-nick",keepnick);
      ONOFF(idx,"open-telnets",allow_new_telnets,"",-1);
      ONOFF(idx,"passive",passive,"",-1);
      ONOFF(idx,"strict-host",strict_host,"",-1);
    }
    return;
  }
  split(which,this);
  if (strcasecmp(this,"on")==0) ans=1;
  else if (strcasecmp(this,"off")==0) ans=0;
  else if ((this[0]=='Y') || (this[0]=='y') || (this[0]=='t') ||
	   (this[0]=='T')) ans=1;
  else if ((this[0]=='n') || (this[0]=='N') || (this[0]=='F') ||
	   (this[0]=='f')) ans=0;
  else return;
  if (strcasecmp(which,"log-time")==0) PSET(shtime)
  else if (strcasecmp(which,"clear-bans")==0) PSET(clearbans)
  else if (strcasecmp(which,"op-on-join")==0) PSET(op_on_join)
  else if (strcasecmp(which,"revenge")==0) PSET(revenge)
  else if (strcasecmp(which,"greet")==0) PSET(greet)
  else if (strcasecmp(which,"learn-users")==0) PSET(learn_users)
  else if (strcasecmp(which,"require-x")==0) PSET(require_x)
  else if (strcasecmp(which,"require-p")==0) PSET(require_p)
  else if (strcasecmp(which,"enforce-bans")==0) PSET(enforce_bans)
  else if (strcasecmp(which,"use-info")==0) PSET(use_info)
  else if (strcasecmp(which,"share-users")==0) PSET(share_users)
  else if (strcasecmp(which,"passive")==0) PSET(passive)
  else if (strcasecmp(which,"strict-host")==0) PSET(strict_host)
  else if (strcasecmp(which,"keep-all-logs")==0) PSET(keep_all_logs)
  else if (strcasecmp(which,"chan-updates")==0) PSET(chan_updates)
  else if (strcasecmp(which,"raw-files")==0) PSET(raw_files)
  else if (strcasecmp(which,"perm-bans")==0) PSET(perm_bans)
  else if (strcasecmp(which,"upload-to-cd")==0) PSET(upload_to_cd)
  else if (strcasecmp(which,"bitch")==0) PSET(bitch)
  else if (strcasecmp(which,"never-give-up")==0) PSET(never_give_up)
  else if (strcasecmp(which,"protect-ops")==0) PSET(protect_ops)
  else if (strcasecmp(which,"open-telnets")==0) PSET(allow_new_telnets)
  else if (strcasecmp(which,"forbid-bans")==0) PSET(forbid_bans)
  else if (strcasecmp(which,"keep-nick")==0) PSET(keepnick)
  else if (strcasecmp(which,"isolate")==0) {
    PSET(isolate)
    if (idx>=0) {
      if (isolate) chatout("*** Party line is now isolated.\n");
      else chatout("*** Party line is now open.\n");
      if (isolate) tandout("chat %s Isolating my party line.\n",origbotname);
      else tandout("chat %s Merging my party line.\n",origbotname);
    }
  }
  else {
    if (idx>=0) dprintf(idx,"No such variable.\n");
    else {
      if (use_stderr) 
	fprintf(stderr,"* Warning: Unknown set variable '%s'\n",which);
    }
    return;
  }
}
#endif (!defined TCL)

int logmodes(s)
char *s;
{
  int i; int res=0;
  for (i=0; i<strlen(s); i++) switch(s[i]) {
  case 'm': case 'M': res|=LOG_MSGS; break;
  case 'p': case 'P': res|=LOG_PUBLIC; break;
  case 'j': case 'J': res|=LOG_CHAN; break;
  case 'k': case 'K': res|=LOG_MODES; break;
  case 'c': case 'C': res|=LOG_CMDS; break;
  case 'o': case 'O': res|=LOG_MISC; break;
  case 'b': case 'B': res|=LOG_TAND; break;
#ifdef USE_CONSOLE_R
  case 'r': case 'R': res|=LOG_RAW; break;
#endif
  case 'x': case 'X': res|=LOG_FILES; break;
  }
  return res;
}

char *masktype(x)
int x;
{
  static char s[10]; char *p=s;
  if (x&LOG_MSGS) *p++='m';
  if (x&LOG_PUBLIC) *p++='p';
  if (x&LOG_CHAN) *p++='j';
  if (x&LOG_MODES) *p++='k';
  if (x&LOG_CMDS) *p++='c';
  if (x&LOG_MISC) *p++='o';
  if (x&LOG_TAND) *p++='b';
#ifdef USE_CONSOLE_R
  if (x&LOG_RAW) *p++='r';
#endif
  if (x&LOG_FILES) *p++='x';
  *p=0;
  return s;
}

char *maskname(x)
int x;
{
  static char s[80];
  s[0]=0;
  if (x&LOG_MSGS) strcat(s,"msgs, ");
  if (x&LOG_PUBLIC) strcat(s,"public, ");
  if (x&LOG_CHAN) strcat(s,"joins, ");
  if (x&LOG_MODES) strcat(s,"kicks/modes, ");
  if (x&LOG_CMDS) strcat(s,"cmds, ");
  if (x&LOG_MISC) strcat(s,"misc, ");
  if (x&LOG_TAND) strcat(s,"bots, ");
#ifdef USE_CONSOLE_R
  if (x&LOG_RAW) strcat(s,"raw, ");
#endif
  if (x&LOG_FILES) strcat(s,"files, ");
  if (!s[0]) strcpy(s,"none, ");
  s[strlen(s)-2]=0;
  return s;
}

/* show all internal state variables */
void tell_settings(idx)
int idx;
{
  char s[121]; int i;
  dprintf(idx,"%s!%s@%s (%s)\n",origbotname,botuser,bothost,botrealname);
  dprintf(idx,"for %s",botchan);
  if (chankey[0]) dprintf(idx," (key: %s)",chankey);
  get_mode_protect(s);
  if (s[0]) dprintf(idx," (forcing mode: %s)",s);
  dprintf(idx,"\nUserfile: %s   Motd: %s\n",userfile,motdfile);
  if (notefile[0])
    dprintf(idx,"Notes can be stored, in: %s\n",notefile);
  else dprintf(idx,"Notes can not be stored.\n");
  if (dccdir[0]) {
    dprintf(idx,"DCC file path: %s",dccdir);
    if (upload_to_cd) dprintf(idx,"\n     incoming: (go to the current dir)\n");
    else if (dccin[0]) dprintf(idx,"\n     incoming: %s\n",dccin);
    else dprintf(idx," (no uploads)\n");
    dprintf(idx,"DCC block is %d, max concurrent d/ls is %d\n",dcc_block,
	    dcc_limit);
    if (dcc_users) dprintf(idx,"    max users is %d\n",dcc_users);
    if ((upload_to_cd) || (dccin[0]))
      dprintf(idx,"DCC max file size: %dk\n",dcc_maxsize);
  }
  else dprintf(idx,"(No active file transfer path defined.)\n");
  if (telnet_port) 
    dprintf(idx,"Listening at telnet port %d\n",telnet_port);
  if (min_servs)
    dprintf(idx,"Requiring a net of at least %d server(s)\n",min_servs);
#ifdef TCL
  if (need_op[0]) dprintf(idx,"To get ops I do: %s\n",need_op);
  if (need_invite[0]) dprintf(idx,"To get invited I do: %s\n",need_invite);
#else
  if (gainops[0]) dprintf(idx,"To get ops I do: %s\n",gainops);
#endif
  if (initserver[0])
    dprintf(idx,"On connect, I do: %s\n",initserver);
  dprintf(idx,"Flood is: %d msg/min, %d pub/min, %d join/min\n",flood_thr,
	  flood_pub_thr,flood_join_thr);
  dprintf(idx,"Bans last %d mins, ignores last %d mins\n",ban_time,
	  ignore_time);
  if (idle_kick)
    dprintf(idx,"Kicking idle users after %d min\n",idle_kick);
  dprintf(idx,"Help dir (%s), temp dir (%s), text dir (%s)\n",helpdir,tempdir,
	  textdir);
  flags2str(default_flags,s);
  dprintf(idx,"New users get flags [%s], notify: %s\n",s,notify_new);
#ifdef OWNER
  if (owner[0])
    dprintf(idx,"Permanent owner(s): %s\n",owner);
#endif
  for (i=0; i<MAXLOGS; i++) if (logfile[i]!=NULL) {
    dprintf(idx,"Logfile #%d: %s (%s: %s)\n",i+1,logfile[i],
	    masktype(logmask[i]),maskname(logmask[i]));
  }
}

#ifndef TCL  /* '.define' is a non-Tcl command */
void define(idx,var,value)
int idx; char *var,*value;
{
  int ok=0,i; char s[121];
  context;
  if ((var[0]==0) && (idx>=0)) {
    dprintf(idx,"Variable definitions:\n");
    dprintf(idx,"  nick:            %s\n",origbotname);
    dprintf(idx,"  user:            %s\n",botuser);
    dprintf(idx,"  realname:        %s\n",botrealname);
    dprintf(idx,"  channel:         %s\n",botchan);
    dprintf(idx,"  userfile:        %s\n",userfile);
    dprintf(idx,"  dcc-path:        %s\n",dccdir);
    dprintf(idx,"  dcc-incoming:    %s\n",dccin);
    dprintf(idx,"  dcc-limit:       %d\n",dcc_limit);
    dprintf(idx,"  dcc-block:       %d\n",dcc_block);
    dprintf(idx,"  dcc-maxsize:     %d\n",dcc_maxsize);
    dprintf(idx,"  dcc-users:       %d\n",dcc_users);
    dprintf(idx,"  telnet:          %u\n",telnet_port);
    dprintf(idx,"  motd:            %s\n",motdfile);
    dprintf(idx,"  servlimit:       %u\n",min_servs);
    dprintf(idx,"  admin:           %s\n",admin);
    dprintf(idx,"  gain-ops:        %s\n",gainops);
    dprintf(idx,"  init-server:     %s\n",initserver);
    dprintf(idx,"  notefile:        %s\n",notefile);
    dprintf(idx,"  flood-msg:       %u\n",flood_thr);
    dprintf(idx,"  flood-chan:      %u\n",flood_pub_thr);
    dprintf(idx,"  flood-join:      %u\n",flood_join_thr);
    dprintf(idx,"  ban-time:        %u min\n",ban_time);
    dprintf(idx,"  ignore-time:     %u min\n",ignore_time);
    dprintf(idx,"  idle-kick:       %u min\n",idle_kick);
    dprintf(idx,"  helpbot:         %s\n",helpbot);
    dprintf(idx,"  helpdir:         %s\n",helpdir);
    dprintf(idx,"  tempdir:         %s\n",tempdir);
    dprintf(idx,"  textdir:         %s\n",textdir);
    dprintf(idx,"  channel-key:     %s\n",chankey);
    dprintf(idx,"  notify-newusers: %s\n",notify_new);
    dprintf(idx,"  ctcp-version:    %s\n",ctcp_version);
    dprintf(idx,"  ctcp-finger:     %s\n",ctcp_finger);
    dprintf(idx,"  ctcp-userinfo:   %s\n",ctcp_userinfo);
    dprintf(idx,"  owner:           %s\n",owner);
    flags2str(default_flags,s);
    dprintf(idx,"  default-flags:   %s\n",s);
    for (i=0; i<MAXLOGS; i++) if (logfile[i]!=NULL) {
      dprintf(idx,"  logfile:         %s (%s: %s)\n",
	      logfile[i],masktype(logmask[i]),maskname(logmask[i]));
    }
    dprintf(idx,"  console:         %s: (%s)\n",masktype(conmask),
	    maskname(conmask));
    get_mode_protect(s);
    dprintf(idx,"  chanmode:        %s\n",s);
  }
  else if (strcasecmp(var,"nick")==0) {
    value[9]=0; strcpy(botname,value); strcpy(origbotname,value); ok=1;
  }
  else if (strcasecmp(var,"user")==0) {
    value[10]=0; strcpy(botuser,value); ok=1;
  }
  else if (strcasecmp(var,"realname")==0) { strcpy(botrealname,value); ok=1; }
  else if (strcasecmp(var,"channel")==0) { strcpy(botchan,value); ok=1; }
  else if (strcasecmp(var,"userfile")==0) { strcpy(userfile,value); ok=1; }
  else if (strcasecmp(var,"dcc-path")==0) {
    if (value[strlen(value)-1]!='/') strcat(value,"/");
    strcpy(dccdir,value); ok=1; 
  }
  else if (strcasecmp(var,"dcc-incoming")==0) { 
    if (value[strlen(value)-1]!='/') strcat(value,"/");
    strcpy(dccin,value); ok=1; 
  }
  else if (strcasecmp(var,"load")==0) { readprog(value); ok=2; }
  else if (strcasecmp(var,"telnet")==0) { telnet_port=atoi(value); ok=3; }
  else if (strcasecmp(var,"motd")==0) { strcpy(motdfile,value); ok=1; }
  else if (strcasecmp(var,"servlimit")==0) { min_servs=atoi(value); ok=3; }
  else if (strcasecmp(var,"admin")==0) { strcpy(admin,value); ok=1; }
  else if (strcasecmp(var,"gain-ops")==0) { strcpy(gainops,value); ok=1; }
  else if (strcasecmp(var,"init-server")==0) {
    strcpy(initserver,value); ok=1;
  }
  else if (strcasecmp(var,"notefile")==0) { strcpy(notefile,value); ok=1; }
  else if (strcasecmp(var,"flood-msg")==0) { flood_thr=atoi(value); ok=3; }
  else if (strcasecmp(var,"flood-chan")==0) { 
    flood_pub_thr=atoi(value); ok=3;
  }
  else if (strcasecmp(var,"flood-join")==0) {
    flood_join_thr=atoi(value); ok=3;
  }
  else if (strcasecmp(var,"ban-time")==0) {
    ban_time=atoi(value); ok=3;
  }
  else if (strcasecmp(var,"ignore-time")==0) {
    ignore_time=atoi(value); ok=3;
  }
  else if (strcasecmp(var,"dcc-limit")==0) {
    dcc_limit=atoi(value); ok=3;
  }
  else if (strcasecmp(var,"dcc-block")==0) {
    dcc_block=atoi(value); ok=3;
  }
  else if (strcasecmp(var,"dcc-maxsize")==0) {
    dcc_maxsize=atoi(value); ok=3;
  }
  else if (strcasecmp(var,"dcc-users")==0) {
    dcc_users=atoi(value); ok=3;
  }
  else if (strcasecmp(var,"idle-kick")==0) {
    idle_kick=atoi(value); ok=3;
  }
  else if (strcasecmp(var,"helpbot")==0) {
    if (idx>=0) dprintf(idx,"No... it's too late for that. :)\n");
    else { value[9]=0; strcpy(helpbot,value); ok=1; }
  }
  else if (strcasecmp(var,"helpdir")==0) { 
    strcpy(helpdir,value); ok=1; 
    if (helpdir[strlen(helpdir)-1]!='/') strcat(helpdir,"/");
  }
  else if (strcasecmp(var,"tempdir")==0) { 
    strcpy(tempdir,value); ok=1; 
    if (tempdir[strlen(tempdir)-1]!='/') strcat(tempdir,"/");
  }
  else if (strcasecmp(var,"textdir")==0) {
    strcpy(textdir,value); ok=1;
    if (textdir[strlen(textdir)-1]!='/') strcat(textdir,"/");
  }
  else if (strcasecmp(var,"ctcp-version")==0) {
    strcpy(ctcp_version,value); ok=1;
  }
  else if (strcasecmp(var,"ctcp-finger")==0) {
    strcpy(ctcp_finger,value); ok=1;
  }
  else if (strcasecmp(var,"ctcp-userinfo")==0) {
    strcpy(ctcp_userinfo,value); ok=1;
  }
  else if (strcasecmp(var,"owner")==0) {
    strcpy(owner,value); ok=1;
  }
  else if (strcasecmp(var,"channel-key")==0) { strcpy(chankey,value); ok=1; }
  else if (strcasecmp(var,"notify-newusers")==0) {
    strcpy(notify_new,value); ok=1;
  }
  else if (strcasecmp(var,"logfile")==0) {
    int j=0; char xx[121];
    for (i=0; i<MAXLOGS; i++) if ((logfile[i]==NULL) && (!j)) {
      j=1; split(xx,value); ok=4;
      if (!xx[0]) logmask[i]=LOG_MODES|LOG_CMDS|LOG_MISC;
      else logmask[i]=logmodes(xx);
      logfile[i]=(char *)nmalloc(strlen(value)+1); strcpy(logfile[i],value);
      if (idx>=0) dprintf(idx,"New logfile: '%s' (%s)\n",value,
			  maskname(logmask[i]));
    }
  }
  else if (strcasecmp(var,"chanmode")==0) {
    set_mode_protect(value); ok=4;
    get_mode_protect(s);
    if (idx>=0) dprintf(idx,"Defined 'chanmode' as: %s\n",s);
  }
  else if (strcasecmp(var,"console")==0) {
    conmask=logmodes(value); ok=4;
    if (idx>=0) dprintf(idx,"Defined 'console' as: %s\n",maskname(conmask));
  }
  else if (strcasecmp(var,"default-flags")==0) {
    default_flags=str2flags(value); ok=1;
  }
  else {
    if (idx<0) {
      if (use_stderr)
	fprintf(stderr,"* Warning: unknown misc setting '%s'\n",var);
    }
    else dprintf(idx,"Cannot define '%s'.\n",var);
    return;
  }
  if (idx>=0) {
    if (ok==1) dprintf(idx,"Defined '%s' as: %s\n",var,value);
    if (ok==2) dprintf(idx,"Loaded: %s\n",value);
    if (ok==3) dprintf(idx,"Defined '%s' to %d.\n",var,atoi(value));
  }
}
#endif  /* !Tcl */

/* zones of config file */
#define SETZONE      1
#define SERVERSZONE  2
#define MISCZONE     3
#define UNKNOWN      4

#ifndef TCL
/* read in the channel programming: non-tcl */
int readprog(file)
char *file;
{
  char *p,code[41],s[121]; FILE *f; int zone=UNKNOWN,i;
  context;
  f=fopen(file,"r");
  if (f==NULL) return 0;
  noshare=1;
  while (!feof(f)) {
    fgets(s,120,f);
    if (!feof(f)) {
      p=strchr(s,';'); if (p!=NULL) *p=0;
      rmspace(s);
      if ((s[0]!='#') && (s[0]!=';') && (s[0])) {
	if (s[0]=='@') {
	  /* new zone */
	  strcpy(s,&s[1]);
	  if (strcasecmp(s,"set")==0) zone=SETZONE;
	  else if (strcasecmp(s,"servers")==0) zone=SERVERSZONE;
	  else if (strcasecmp(s,"misc")==0) zone=MISCZONE;
	  else {
	    if (use_stderr)
	      fprintf(stderr,"* Warning: unknown config-file zone '%s'\n",s);
	    zone=UNKNOWN;
	  }
	}
	else {
	  if (zone==MISCZONE) {
	    split(code,s); if (code[0]==0) { strcpy(code,s); s[0]=0; }
	    define(-1,code,s);
	  }
	  else if (zone==SETZONE) prog_set(s,-1);
	  else if (zone==SERVERSZONE) {
	    p=strchr(s,','); 
	    while (p!=NULL) {
	      splitc(code,s,','); rmspace(code); rmspace(s);
	      if (code[0]) add_server(code);
	      p=strchr(s,',');
	    }
	    if (s[0]) add_server(s);
	  }
	  else if (zone==UNKNOWN) ;  /* do nothing */
	}
      }
    }
  }
  noshare=0;
  fclose(f); return 1;
}
#endif  /* !Tcl */

void chanprog()
{
  int i;
  strcpy(botuser,"bot"); strcpy(botrealname,"eggdrop bot");
  admin[0]=0; helpdir[0]=0; initserver[0]=0; textdir[0]=0;
#ifdef TCL
  need_op[0]=0; need_invite[0]=0;
#else
  gainops[0]=0;
#endif
  notefile[0]=0; dccdir[0]=0; dccin[0]=0; tempdir[0]=0;
  for (i=0; i<MAXLOGS; i++) {
    if (logfile[i]!=NULL) { nfree(logfile[i]); logfile[i]=NULL; }
    logmask[i]=0;
  }
  conmask=0;
  /* now read it */
#ifdef TCL
  if (!readtclprog(configfile)) fatal("CONFIG FILE NOT FOUND",0);
#else
  if (!readprog(configfile)) fatal("CONFIGURATION FILE NOT FOUND!",0);
#endif
  strcpy(botname,origbotname);
  if (!botchan[0]) fatal("NO HOME CHANNEL.",0);
  if (!botname[0]) fatal("NO BOT NAME.",0);
  if (!userfile[0]) fatal("NO USER FILE.",0);

  if (!readuserfile(userfile)) {
    if (!make_userfile)
      fatal("USER FILE NOT FOUND!  (try 'eggdrop -m' to make one)",0);
    printf("\n\nSTARTING BOT IN USERFILE CREATION MODE.\n");
    printf("Go to IRC and:  /msg %s hello\n",botname);
    printf("This will make the bot recognize you as the master.\n\n");
  }
  else if (make_userfile) fatal("USERFILE ALREADY EXISTS (drop the '-m')",0);

  if (serverlist==NULL) fatal("NO SERVER.",0);
  if (dccdir[0]) if (dccdir[strlen(dccdir)-1]!='/') strcat(dccdir,"/");
  if (dccin[0]) if (dccin[strlen(dccin)-1]!='/') strcat(dccin,"/");
  if (helpdir[0]) if (helpdir[strlen(helpdir)-1]!='/') strcat(helpdir,"/");
  if (tempdir[0]) if (tempdir[strlen(tempdir)-1]!='/') strcat(tempdir,"/");
  if (textdir[0]) {
    if (textdir[strlen(textdir)-1]!='/') strcat(textdir,"/");
  }
  else strcpy(textdir,helpdir);

  /* test tempdir: it's vital */
  {
    FILE *f; char s[161];
    sprintf(s,"%s.test.file",tempdir);
    f=fopen(s,"w");
    if (f==NULL) fatal("CAN'T WRITE TO TEMP DIR.",0);
    fclose(f); unlink(s);
  }

#ifdef OWNER
  /* make sure default owners are +n */
  if (owner[0]) {
    char *p,s[121];
    strcpy(s,owner); p=strchr(s,','); while (p!=NULL) {
      *p=0; rmspace(s);
      set_attr_handle(s,get_attr_handle(s)|USER_OWNER);
      strcpy(s,p+1); p=strchr(s,',');
    }
    rmspace(s);
    if (s[0]) set_attr_handle(s,get_attr_handle(s)|USER_OWNER);
  }
#endif
}

void rehash()
{
  int old_tp=telnet_port;   /* save old telnet port value */
  clearprog(); chanprog();
  telnet_port=old_tp;
#ifdef NO_IRC
  helpbot[0]=0; dccdir[0]=0;
#else
  if ((strcasecmp(oldnick,botname)!=0) && (oldnick[0])) 
    tprintf(serv,"NICK %s\n",botname);
#ifdef TCL
  if (initserver[0]) do_tcl("init-server",initserver);
#else
  if (initserver[0]) tprintf(serv,"%s\n",initserver);
#endif
  if ((strcasecmp(oldchan,curchan)!=0) && (oldchan[0])) {
    tprintf(serv,"PART %s\n",oldchan);
    tprintf(serv,"JOIN %s\n",botchan);
  }
  /* update stuff, as if we just got control of the channel again: */
  recheck_channel();
#endif
}

void get_first_server()
{
  curserv=999; helpserv=999;
  /* silly, no? */
}