(*

 *      PageSix.mod

 *

 *      Programmer:		T. Ross

 *	Started:

 *	Last edited:		27 May 2006

 *

 *      Copyright 2006 Terry K. Ross <terry@aliboom.com>

 *

 *      This program is free software; you can redistribute it 

 *      and/or modify it under the terms of the GNU General Public

 *	License as published by the Free Software Foundation; 

 *	either version 2 of the License, or (at your option) any 

 *	later version.

 *

 *      This program is distributed in the hope that it will be 

 *      useful,but WITHOUT ANY WARRANTY; without even the implied

 *	warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 

 *	PURPOSE.  See theGNU General Public License for more details.

 *

 *      You should have received a copy of the GNU General Public 

 *      License along with this program; if not, write to the 

 *      Free Software Foundation, Inc., 675 Mass Ave, 

 *      Cambridge, MA 02139, USA.

 *)

<* GENHISTORY + *> 

<* GENDEBUG + *>

<* LINENO + *>

<*+ M2EXTENSIONS *>

<*+ M2ADDTYPES *>

<*+ CSTDLIB *>

<*+ NOHEADER *>

MODULE PageSix;

IMPORT COMPILER;

IMPORT Connect;

IMPORT Handler;

IMPORT FileSys;

IMPORT Message;

IMPORT RawIO;

IMPORT SeqFile;

IMPORT Sockets;

IMPORT STextIO;

IMPORT StreamFile;

IMPORT Strings, StringParse;

IMPORT SWholeIO;

IMPORT SYSTEM;

IMPORT SysClock;

IMPORT TextIO;

IMPORT TimeConv;

IMPORT Timers;

IMPORT types;

IMPORT util;

IMPORT WholeIO, WholeStr;

FROM Setup IMPORT check, strType;

IMPORT r;

CONST

  LF = 12C;

  CR = 15C;

  homechan = Message.homechan;

  (* for poll() *)

  POLLIN   = 1;

  POLLPRI  = 2;

  POLLOUT  = 4;

  POLLERR  = 8;

  POLLHUP  = 16;

  POLLNVAL = 32;

TYPE

  (* for poll() *)

  nfds_t = LONGCARD;

  pollfd = RECORD

    fd     : SYSTEM.int;    (*  File descriptor to poll.   *)

    events : SYSTEM.INT16;  (*  Types of events poller cares about.   *)

    revents: SYSTEM.INT16;  (*  Types of events that actually occurred.   *)

  END;

  Ptrpollfd = POINTER TO pollfd;

VAR 

  (* for poll() *)

  return       : INTEGER;

  tout         : SYSTEM.int;

  fd           : pollfd;

  nfds         : nfds_t;

  serv         : Sockets.Socket;

  found, done  : BOOLEAN;

  (* remainder *)

  parse	       : Message.Parse; 

  pid          : types.pid_t;

  file         : StreamFile.ChanId;

  res, iores   : StreamFile.OpenResults;

  string       : strType;

  temp         : ARRAY [0..80] OF CHAR;

PROCEDURE TimeStamp;

VAR

  dt: SysClock.DateTime;

  file : SeqFile.ChanId;

  res : SeqFile.OpenResults;

BEGIN  

  TimeConv.unpack(dt, COMPILER.TIMESTAMP);

  SeqFile.OpenWrite(file, "/home/terry/p6dat/dat/compiletime", SeqFile.raw+SeqFile.write+SeqFile.old, res);

  RawIO.Write(file, dt);

  SeqFile.Close(file);

END TimeStamp;

PROCEDURE ["C"] / poll ( fds: Ptrpollfd; nfds: nfds_t;

                         timeout: SYSTEM.int ): SYSTEM.int;

(* This will eventually be moved to the sockets definition file,

   once I have converted it from OS/2 to Linux. *)

(* PROCEDURE ["C"] / close (S: Sockets.Socket): BOOLEAN; *)

(* Attempting to use Sockets.close - if it works, delete this. *)

BEGIN (* PageSix.mod *)

  TimeStamp;

  tout := 50; (* set poll timeout to 50 milliseconds *)

  parse.botname := Connect.botName;

  (* Are we really starting, or did we rehash? *)

  IF FileSys.Exists("/home/terry/p6dat/tmp/rehash/yes") THEN 

     FileSys.Remove("/home/terry/p6dat/tmp/rehash/yes", done);

    (* Kill the old process *) (* This needs more work *)

    (* What should be happening here is that the bot is getting all of the info

       necessary to communicate with the server, and killing off the old version

       of the bot.

    *)   

    StreamFile.Open(file, "/home/terry/p6dat/tmp/rehash/pid", StreamFile.read,res);

    WholeIO.ReadInt(file, pid);

      (* Log it *)

      Strings.Assign("Closing pid P~", string);

      WholeStr.IntToStr(pid, temp);

      StringParse.Replace(string, "P~", temp);

      util.Log(string, parse);

    StreamFile.Close(file);

    (* Hmmmmm not working

    signal.kill(pid, signal.SIGTERM);

    *)

    StreamFile.Open(file, "/home/terry/p6dat/tmp/rehash/serv", StreamFile.read, res);

    WholeIO.ReadCard(file, parse.serv);

    STextIO.WriteString("<><><> Socket: ");

    SWholeIO.WriteCard(parse.serv,0);

    serv := parse.serv;

    STextIO.WriteLn;

    TextIO.SkipLine(file); 

    TextIO.ReadString(file, parse.server);

    STextIO.WriteString("<><><> Server: ");

    STextIO.WriteString(parse.server);

    STextIO.WriteLn;

    TextIO.SkipLine(file);

    TextIO.ReadString(file, temp);

    STextIO.WriteString("<><><> forumCheck: ");

    STextIO.WriteString(temp);

    STextIO.WriteLn;

    IF Strings.Equal(temp,"true") THEN

      check.trackercheck.on := TRUE;

    ELSE

      check.trackercheck.on := FALSE;

    END;

    (* get bug check status *)

    TextIO.SkipLine(file);

    TextIO.ReadString(file, temp);

    STextIO.WriteString("<><><> bugCheck: ");

    STextIO.WriteString(temp);

    STextIO.WriteLn;

    IF Strings.Equal(temp,"true") THEN

      check.bugcheck.on := TRUE;

    ELSE

      check.bugcheck.on := FALSE;

    END;  

    (* read linesSent *)

    TextIO.SkipLine(file);

    WholeIO.ReadCard(file, Message.linesSent);

    STextIO.WriteString("<><><> linesSent: ");

    SWholeIO.WriteCard(Message.linesSent, 0);

    STextIO.WriteLn;

    TextIO.SkipLine(file);

    (* read linesRead *)

    WholeIO.ReadCard(file, Message.linesRead);

    STextIO.WriteString("<><><> linesRead: ");

    SWholeIO.WriteCard(Message.linesRead, 0);

    STextIO.WriteLn;

    r.rehashReadTime;

    StreamFile.Close(file);

    parse := Message.DoRead(serv);

  ELSE (* We are actually firing up for the first time. *)

    (* *)

    serv := Connect.DoConnect("irc.freenode.net", 6667); 

    (* *)

    (* 

    serv := Connect.DoConnect("kornbluth.freenode.net", 6667);

    *)

    (*

    serv := Connect.DoConnect("niven.freenode.net", 6667); 

    *)

    Connect.DoLogin(parse.botname, parse.botname, "");

    Message.DoSend(serv, "JOIN #atari-3");

    parse := Message.DoRead(serv);

    check.trackercheck.on := FALSE;

    check.bugcheck. on := TRUE;

  END;

  (* set up poll() events *)

  fd.fd := serv;

  fd.events := SYSTEM.CAST(SYSTEM.INT16, POLLIN+POLLPRI);

  fd.revents := SYSTEM.CAST(SYSTEM.INT16, 0);

  REPEAT

    done := Timers.Timing();

    return := poll (fd, nfds, tout);

(*    IF (return > 0) THEN *)

    parse := Message.DoRead(serv);

    IF LENGTH(parse.raw) > 0 THEN

      Handler.Handler(parse);

    END;

    IF Message.InString("die bot",parse.raw) OR

       Message.InString("die", parse.raw) AND

       Message.InString(parse.message, parse.botname) THEN

         IF util.Auth(parse.raw, iores) THEN

	   found := TRUE;

	 ELSE

	   Message.PrintLine(parse.chan, "no.");

	 END;  

    END; (* IF *)

(*    END; (* IF (return > 0) *) *)

  UNTIL found; 

  (* OK, found is TRUE, so the die command was entered. Close down *)

  Connect.DoLogout("bye bye - qnr just killed me.");

  done := Sockets.close(serv);

EXCEPT

  RETURN;

END PageSix.