(* Developers notes and Turbo Pascal structures for RemoteAccess 2.62
			    Finalized

   Copyright (c) 1996-2000 Bruce F. Morse
   All Rights Reserved

   If you develop software which accesses any of the following files,
   you should read the following notes. They refer to important
   structure changes in this release (2.62) and are indicated with
   the "{}" characters in the first two column positions of the
   effected line.

	Data Types
	LIMITS.RA       {NOT changed for y2k - not necessary}
	HMBMSGHDR       {NOT changed for y2k - see note below}
	FILESHDR        {NOT changed for y2k - not necessary}
	FILESIDX        {NOT changed for y2k - not necessary}
   FILESrecord     { Added additional ATTRIBute }
   CONFIG.RA       { FORMAT changed for y2k }
	USERS           { FORMAT changed for y2k }
	TIMELOG         { FORMAT and SIZE changed for y2k }
	EVENT           { FORMAT changed for y2k }
	EXITINFO        { FORMAT changed for y2k }
	DOOR.SYS        {Not changed, but marked for future changes            }
			 { with optional parameter that uses 4-digit year       }
				  { in dropfile when implemented by 3rd party developers.}


Primary Purpose of data structure change
========================================

   The primary change in structures is to create a viable, working
   solution to "Year 2000 Concerns".  There were several alternatives
   to accomplish this including "testing the date".

   The one chosen revises the "Date" data type from "MM-DD-YY" to
   "MM-DD-KCYY" "MM", "DD" and "YY" are the same as they have been.
   "K" and "C" is for the added two digits of the year - "K" for
   the thousands digit and "C" for the century digit and will translate
   to the new displayed and internal format thus: "MM-DD-KCYY".
   All internal date coding will use that format and use that
   format for date storage except as noted.

   This decision is DIFFERENT than the one previously announced due
   to of the availability of larger hard drives at lower cost and
   the simplicity of "decoding the date format".

Sample of how date will be stored
---------------------------------

   Example: January 3rd, 2000 - will be handled internally by RA v2.6
   as "01-03-2000" and when stored will be split into two sections.
	OldDateFormat (of "MM-DD-YY") as "01-03-00" and
	PrefixDateFormat (of "KC") as "20".

   The OldDate coding (in CONFIG.RA) will be at the original location
   and using the original date format ("MM-DD-YY").  The program will
   continue to read and write to that area for compatibility.
   The "KC" century information ("20") will be stored in a seperate
   location within the file that was previously unused.
   RemoteAccess will properly extract the date as "01-03-2000"
   and carry it in that format throughout the internal workings
   of the program.


 *****************
 **** CAUTION ****
 *****************

   If your program EXRACTS the date from the file, then it will
   display (in mm-dd-yy) as "01-03-00"

   If your program has been upgraded, it will display the date, either
   as "01-03-00" or "01-03-2000" depending if it displays the date
   as a 2- or 4-digit year and what options you may have selected.

   Each of YOU will need to test your utilites and programs with
   the data files to see HOW it handles them and if it does so to
   your satisfaction.


   NOTE:
   -----
Hudson Message Base
-------------------
      Due to the common usage of the HUDSON MESSAGE BASE (HMB) format,
   The date format will remain in the 'MM-DD-YY' format.  However,
   Coding within RemoteAccess will take that into consideration
   and assume dates PRIOR TO (but not including) January 1st, 1950
   refer to dates in the year 2000 and beyond.
      At some later date, we suspect that the HMB (if continued to
   be used) will handle date structures in a different manner and
   appropriate changes to RemoteAccess will be made.

BBS User options
----------------
   The BBS user will have additional date display format choices
   that include all the previous 2-digit year options and the
   addition of new 4-digit year options.

   We will display the date for the SysOp as a 4-digit year
   formatted date.

Additional Added features
-------------------------
   At the request of you sysops, the Default settings for the
   New User's Message Area, File Area and File Group will be
   configurable in RACONFIG in the New User Configuration
   section.

(end of Version 2.6x's description of changes)

The following text is from the STRUCT.250 file
----------------------------------------------
   The area number to which records in the above files refer is no
   longer dependent upon the position of the record in the file.
   This is to allow utilities to move, copy, insert and delete
   areas and groups at will, without the need to renumber every
   reference to every moved area or group.

   The following applies to the record structure of all the above
   files as published in this document.

   If you look at each record definition, you will notice that the
   MESSAGErecord and FILESrecord structures each have 4 unused
   bytes at the beginning, and that the GROUPrecord structure has 2
   unused bytes at the beginning.

   In RA 2.60, the first two bytes of each of these records are
   redefined as a single word value (2 byte unsigned integer). This
   word holds the area number of that record - the name of the new
   field is 'AreaNum'. This has the following implications:

   1. To get the Hudson message-base board number for a record from
   MESSAGES.RA, do NOT rely on its position. The AreaNum field
   contains the actual board number.

   2. To access the correct FDB files from a file area record in
   FILES.RA, use the value contained in the AreaNum field, NOT the
   number of the position of the record.

   3. Utilities are now free to move any record to any location in
   these files without having to worry about renumbering FDB files
   or menu entries.

   4. When ADDING a new record, utilities MUST assign a valid area
   number to the record in the AreaNum field. Valid numbers are in
   the range 1 to 65535, and MUST be unique. See the note about
   index files below for information on how to determine the next
   available unique number.

   The INDEX files
   ---------------
   In order to provide the fastest possible access to the above four
   files, each is now indexed. The index files have the same path
   and base name with an extension of 'RDX' - for example, the index
   file for C:\RA\FILES.RA would be C:\RA\FILES.RDX.

   The index files are automatically generated by RACONFIG after
   editing areas. They must also be generated by any utility which:

   1. Adds, deletes or moves a record within its file, or
   2. Changes the AreaNum field of any record.

   FAILURE TO REINDEX WILL CAUSE UNPREDICTABLE RESULTS FOR THE
   SYSOP! RA and its utilities all check to make sure that the index
   files are up to date.

   The format of the index files is very simple. It is a flat file
   of word (2 byte unsigned integer) records which contains one
   record for each AreaNum value in the corresponding file. The
   physical position of each index record is equal to the AreaNum
   value minus 1. The value of the index record is equal to the
   physical position of the record for that area number in the main
   file PLUS 1. A value of zero indicates that the area number is
   not currently used.

   For example:

   File offest  FILES.RA AreaNum    FILES.RDX record value
	0             1                   1
	1             2                   2
	2             10                  0
	3             11                  0
	4             12                  0
	5             13                  0
	6             -                   0
	7             -                   0
	8             -                   0
	9             -                   3
  10             -                   4
  11             -                   5
  12             -                   6

   In the above example table, to look up the correct record in
   FILES.RA for a particular area number, the code might look
   something like this in Pascal:

   Seek(RDX, AreaNum-1);
   Read(RDX, Index);
   Seek(FILESRA, Index-1);
   Read(FILESRA, FILESRAinfo);

   Determining the next free unique area number is a simple matter
   of scanning the index file until a value of zero is encountered.

*)

type
  AskType        = (Yes, No, Ask, Only);
  VideoType      = (Auto, Short, Long);
  MsgType        = (LocalMail, NetMail, EchoMail, Internet, Newsgroup);
  MsgKindsType   = (Both, Private, Public, ROnly, NoReply);
  OrphanType     = (Ignore, Create, Kill);
  FlagType       = array[1..4] of Byte;
  ResetType      = (Never, Week, Month, Year);
  Time           = String[5];
{}OldDate        = String[8];
{}OldLongDate    = String[9];
{}Date           = String[10];
{}LongDate       = String[11];
{}PrefixDate     = String[2];
  ByteArray32    = Array[1..32] of Byte;

  NetAddress     = record    { unchanged at ver 2.6 }
		     Zone,
		     Net,
		     Node,
		     Point          : Word;
		   end;

  LIMITSrecord   = record    { unchanged at ver 2.6 }
		     Security,
		     Ltime,
		     L300,
		     L1200,
		     L2400,
		     L4800,
		     L7200,
		     L9600,
		     L12000,
		     L14400,
		     L16800,
		     L19200,
		     L38400,
		     Llocal,
		     RatioNum,
		     RatioK         : Word;
		     PerMinCost     : Real;

		     L21600,
		     L24000,
		     L26400,
		     L28800,
		     L57600,
		     L64000         : Word;

		     FlexiTime      : Real;
		     LsessionTime   : Word;
		     ResetAmt       : Word;
		     ResetPeriod    : ResetType;
		     ResetOffset    : Word;

		     L31200,
		     L33600         : Word;
		     FreeSpace      : Array[1..13] of Byte;
		   end;

  LANGUAGErecord = record   { unchanged at ver 2.6 }
		     Name           : String[20];
		     Attribute      : Byte;
		     DefName,
		     MenuPath,
		     TextPath,
		     QuesPath       : String[60];
		     Security       : Word;
		     Flags,
		     NotFlagsMask   : FlagType;
		     FreeSpace      : Array[1..190] of Byte;
		   end;

  MSGINFOrecord  = record    { unchanged at ver 2.6 }
		     LowMsg,
		     HighMsg,
		     TotalMsgs      : Word;
		     TotalOnBoard   : array[1..200] of Word;
		   end;

  HMBMSGIDXrecord = record   { unchanged at ver 2.6 }
		      MsgNum         : Integer;
		      Board          : Byte;
		    end;

  MSGTOIDXrecord = String[35]; { unchanged at ver 2.6 }

  HMBMSGHDRrecord= record             { Format of structure unchanged   }
		     MsgNum         : Integer;  {  only lable name for 'PostDate' }
		     PrevReply,                 {  to reflect correct data type.  }
		     NextReply,
		     TimesRead      : Word;
		     StartBlock     : Word;
		     NumBlocks,
		     DestNet,
		     DestNode,
		     OrigNet,
		     OrigNode       : Word;
		     DestZone,
		     OrigZone       : Byte;
		     Cost           : Word;
		     MsgAttr,
		     NetAttr,
		     Board          : Byte;
		     PostTime       : Time;
{see note}           PostDate       : OldDate;
		     WhoTo,
		     WhoFrom        : MSGTOIDXrecord;
		     Subject        : String[72];
		   end;

  MSGTXTrecord   = String[255];  { unchanged at ver 2.6 }

  USERONrecord   = record        { unchanged at ver 2.6 }
		     Name,
		     Handle         : MSGTOIDXrecord;
		     Line           : Byte;
		     Baud           : Word;
		     City           : String[25];
		     Status,
		     Attribute      : Byte;
		     StatDesc       : String[10];
		     FreeSpace      : Array[1..98] of Byte;
		     NoCalls        : Word;
		   end;

		   { Status byte - 0 : Browsing (in a menu)
				   1 : Uploading/downloading
				   2 : Reading/posting messages
				   3 : In a door/external utility
				   4 : Chatting with sysop
				   5 : Answering questionnaire
				   6 : RTC
				   7 : New user logon
				 255 : User-defined - display StatDesc

		     Attribute   - Bit 0 : Hidden
				       1 : Wants chat
				       2 : Reserved for RANETMGR
				       3 : Do not disturb flag
				       6 : Ready (0=busy) }

  LASTCALLrecord = record         { unchanged at ver 2.6 }
		     Line           : Byte;
		     Name,
		     Handle         : MSGTOIDXrecord;
		     City           : String[25];
		     Baud           : Word;
		     Times          : LongInt;
		     LogOn          : String[5];  {format - 'hh:mm'}
		     LogOff         : String[5];  {format - 'hh:mm'}
		     Attribute      : Byte;
		   end;

		{ Attribute - Bit 0 : Hidden }

  FILESHDRrecord = record         { unchanged at ver 2.6 }
		     Name           : String[12];
		     Size,
		     CRC32          : LongInt;
		     Uploader       : String[35];
		     UploadDate,                     {Unix style date - not affected by y2k}
		     FileDate,                       {Unix style date - not affected by y2k}
		     LastDL         : LongInt;       {Unix style date - not affected by y2k}
		     TimesDL        : Word;
		     Attrib         : Byte;
		     Password       : String[15];
		     KeyWord        : Array[1..5] of String[15];
		     Cost           : Word;
		     LongDescPtr    : LongInt;
		     FreeSpace      : Array[1..20] of Byte;
		   end;

	  {Attrib - Bit 0 : Deleted
			1 : Unlisted
			2 : Free (don't adjust ratio) - Does NOT affect "Cost"
			3 : Not available (don't allow downloads)
			4 : Locked (no kill)
			5 : Missing/offline
			6 : No time restrictions - always allow DL
	  }

  FILESIDXrecord = record         { unchanged at ver 2.6 }
		     Name           : String[12];
		     UploadDate     : LongInt;       {not affected by y2k}
		     KeyWordCRC     : Array[1..5] of LongInt;
		     LongDescPtr    : LongInt;
		   end;

  LASTREADrecord = array[1..200] of Word;   { unchanged at ver 2.6 }

  USERSIDXrecord = record              { unchanged at ver 2.6 }
		     NameCRC32,
		     HandleCRC32    : LongInt;
		   end;

  COMBINEDrecord = array[1..200] of Word;    { unchanged at ver 2.6 }

  USERSrecord    = record  {Format change only - no change to file size }
		     Name           : MSGTOIDXrecord;
		     Location       : String[25];
		     Organisation,
		     Address1,
		     Address2,
		     Address3       : String[50];
		     Handle         : String[35];
		     Comment        : String[80];
		     PasswordCRC    : LongInt;
		     DataPhone,
		     VoicePhone     : String[15];
		     LastTime       : Time;
{}                   OldLastDate    : OldDate;  { MM-DD-YY format unchanged }

		     Attribute,

		      { Bit 0 : Deleted
				 1 : Clear screen
				 2 : More prompt
				 3 : ANSI
				 4 : No-kill
				 5 : Xfer priority
				 6 : Full screen msg editor
				 7 : Quiet mode }

		     Attribute2     : Byte;

		      { Bit 0 : Hot-keys
				 1 : AVT/0
				 2 : Full screen message viewer
				 3 : Hidden from userlist
				 4 : Page priority
				 5 : No echomail in mailbox scan
				 6 : Guest account
				 7 : Post bill enabled }

		     Flags          : FlagType;
		     Credit,
		     Pending        : LongInt;
		     MsgsPosted,
		     Security       : Word;
		     LastRead,
		     NoCalls,
		     Uploads,
		     Downloads,
		     UploadsK,
		     DownloadsK,
		     TodayK         : LongInt;
		     Elapsed        : Integer;
		     ScreenLength   : Word;
		     LastPwdChange  : Byte;
		     Group          : Word;
		     CombinedInfo   : COMBINEDrecord;
{}                   OldFirstDate,
{}                   OldBirthDate,
{}                   OldSubDate     : OldDate;   {MM-DD-YY format unchanged}
		     ScreenWidth,
		     Language,
		     DateFormat     : Byte;

		{ DateFormat   Returns Date Name }
	      {  Value       Format Picture   }
	      {    1          'DD-MM-YY '     }
	      {    2          'MM-DD-YY '     }
	      {    3          'YY-MM-DD '     }
	      {    4          'DD-Mmm-YY'     }
	      {                               }
{}            {    5          'DD-MM-YYYY '   }
{}            {    6          'MM-DD-YYYY '   }
{}            {    7          'YYYY-MM-DD '   }
{}            {    8          'DD-Mmm-YYYY'   }
{}            { Values of 5 - 8 added at Version 2.60 }

		     ForwardTo      : String[35];
		     MsgArea,
		     FileArea       : Word;
		     DefaultProtocol: Char;
		     FileGroup      : Word;
		     LastDOBCheck   : Byte;
		     Sex            : Byte;
		     XIrecord       : LongInt;
		     MsgGroup       : Word;

		     Attribute3     : Byte;

		      { Bit 0 : Mailbox check: scan selected areas only }

		     Password       : String[15];

{}         PrefixLastDate,                 { here is where 'KC' information }
{}         PrefixFirstDate,                {  is stored for the indicated   }
{}         PrefixBirthDate,                {  variables.                    }
{}         PrefixSubDate  : PrefixDate;    {                                }

{}         FreeSpace      : Array[1..19] of Byte;  { 19 was 31 pre y2k version }
		   end;

  USERSXIrecord  = record     { unchanged at ver 2.6 }
		     FreeSpace      : Array[1..200] of Byte;
		   end;

  SYSINFOrecord  = record       { unchanged at ver 2.6 }
		     TotalCalls     : LongInt;
		     LastCaller,
		     LastHandle     : MSGTOIDXrecord;
		     ExtraSpace     : array[1..92] of Byte;
		   end;

  TIMELOGrecord  = record    { This file CHANGES SIZE }
{}         StartDate      : Date;  {changes to 4-digit year }
		     BusyPerHour    : array[0..23] of Word;
		     BusyPerDay     : array[0..6] of Word;
		   end;


{} OldTIMELOGrecord  = record  { Old style record for use     }
{}                             {  exclusively in EXITINFO.BBS }
{}         OldStartDate   : OldDate;  {MM-DD-YY}
{}         OldBusyPerHour : array[0..23] of Word;
{}         OldBusyPerDay  : array[0..6] of Word;
{}       end;

  MNUrecord      = record
		     Typ            : Byte;
		     Security,
		     MaxSec         : Word;
		     NotFlagsMask,
		     Flags          : FlagType;
		     TimeLeft,
		     TimeUsed       : Word;
		     Age,
		     TermAttrib     : Byte;

		     {Bit 0 : ANSI
			       1 : AVT
			       2 : RIP}

		     MinSpeed,
		     MaxSpeed,
		     Credit,
		     OptionCost,
		     PerMinCost     : LongInt;
		     Node,
		     Group          : ByteArray32;
		     StartTime,
		     StopTime       : Array[1..7] of Word;
		     Display        : String[135];
		     HotKey         : String[8];
		     MiscData       : String[135];
		     Foreground,
		     Background     : Byte;
{}                   Y2kDropFile    : Boolean;  {New field defined but unused }
{}                   FreeSpace      : Array[1..49] of Byte; {decremented}
		   end;

  EVENTrecord    = record  { This file changes format - size unchanged }
		     Status         : Byte; { 0=Deleted 1=Enabled 2=Disabled }
		     StartTime      : Time;
		     ErrorLevel     : Byte;
		     Days           : Byte;
		     Forced         : Boolean;
{}                   LastTimeRun    : OldDate;  {Old 'MM-DD-YY' New 'MMKDDCYY'}
		   end;

  EVENTrecordArray = array[1..20] of EVENTrecord;  { unchanged in ver 2.6 }

  MESSAGErecord  = record
		     AreaNum,
		     Unused         : Word;
		     Name           : String[40];
		     Typ            : MsgType;
		     MsgKinds       : MsgKindsType;
		     Attribute      : Byte;

		      { Bit 0 : Enable EchoInfo
				 1 : Combined access
				 2 : File attaches
				 3 : Allow aliases
				 4 : Use SoftCRs as characters
				 5 : Force handle
				 6 : Allow deletes
				 7 : Is a JAM area }

		     DaysKill,              { Kill older than 'x' days }
		     RecvKill       : Byte; { Kill recv msgs, recv for more than 'x' days }
		     CountKill      : Word;

		     ReadSecurity   : Word;
		     ReadFlags,
		     ReadNotFlags   : FlagType;

		     WriteSecurity  : Word;
		     WriteFlags,
		     WriteNotFlags  : FlagType;

		     SysopSecurity  : Word;
		     SysopFlags,
		     SysopNotFlags  : FlagType;

		     OriginLine     : String[60];
		     AkaAddress     : Byte;

		     Age            : Byte;

		     JAMbase        : String[60];
		     Group          : Word;
		     AltGroup       : Array[1..3] of Word;

		     Attribute2     : Byte;

		      { Bit 0 : Include in all groups }

		     NetmailArea    : Word;
		     FreeSpace2     : Array[1..7] of Byte;
		   end;

  GROUPrecord    = record      {format and size unhanged at ver 2.6 }
		     AreaNum        : Word;
		     Name           : String[40];
		     Security       : Word;
		     Flags,
		     NotFlagsMask   : FlagType;
		     FreeSpace      : Array[1..100] of Byte;
		   end;

  FILESrecord    = record     { new attrib type added at ver 2.6 }
		     AreaNum,
		     Unused         : Word;
		     Name           : String[40];
		     Attrib         : Byte;

		      { Bit 0 : Include in new files scan
				 1 : Include in upload dupe scan
				 2 : Permit long descriptions
				 3 : Area is on CD-ROM
				 4 : All files are FREE
				 5 : Allow DLs not in FDB
				 6 : Allow users to password uploads
				 7 : Scan uploads
{}                               8 : Unscanned uploads available for download }

		     FilePath       : String[40];
		     KillDaysDL,
		     KillDaysFD     : Word;
		     Password       : String[15];
		     MoveArea       : Word;
		     Age,
		     ConvertExt     : Byte;
		     Group          : Word;
		     Attrib2        : Byte;

		      { Bit 0 : Include in all groups }

		     DefCost,
		     UploadArea,
		     UploadSecurity : Word;
		     UploadFlags,
		     UploadNotFlags : FlagType;
		     Security       : Word;
		     Flags,
		     NotFlags       : FlagType;
		     ListSecurity   : Word;
		     ListFlags,
		     ListNotFlags   : FlagType;
		     AltGroup       : Array[1..3] of Word;
		     Device         : Byte;
		     FreeSpace      : Array[1..13] of Byte;
		   end;

  CONFrecord     = record     { unchanged at ver 2.6 }
		     Name,
		     Parent         : String[8];
		     Desc           : String[70];
		     Attr           : Byte;

		      { Bit 0 : Private
				 1 : Unlisted
				 2 : Global
				 3 : Permanent
				 4 : Use handles
							    }

		     Moderator      : String[35];
		     Language       : String[20];
		     Password       : String[15];
		     Security       : Word;
		     Flags          : FlagType;
		     NumNodes       : Byte;
		     Active         : Array[1..250] of Byte;
		     Child          : Array[1..250] of Boolean;
		     NotFlagsMask   : FlagType;
		     FreeSpace      : Array[1..96] of Byte;
		   end;

  MODEMrecord  = record     {no change at version 2.60 }
		   ComPort,
		   InitTries        : Byte;
		   BufferSize,
		   ModemDelay       : Word;
		   MaxSpeed         : LongInt;
		   SendBreak,
		   LockModem,
		   AnswerPhone,
		   OffHook          : Boolean;
		   InitStr,
		   InitStr2,
		   BusyStr          : String[70];
		   InitResp,
		   BusyResp,
		   Connect300,
		   Connect1200,
		   Connect2400,
		   Connect4800,
		   Connect7200,
		   Connect9600,
		   Connect12k,
		   Connect14k,
		   Connect16k,
		   Connect19k,
		   Connect38k,
		   ConnectFax       : String[40];
		   RingStr,
		   AnswerStr        : String[20];
		   ErrorFreeString  : String[15];

		   Connect21k,
		   Connect24k,
		   Connect26k,
		   Connect28k,
		   Connect57k,
		   Connect64k       : String[40];

		   Connect31k,
		   Connect33k       : String[40];

		   FreeSpace        : Array[1..100] of Byte;
		 end;

  ARCrecord = record
		Extension : String[3];
		UnpackCmd,
		PackCmd   : String[60];
	      end;

  CONFIGrecord = record    { variables added - size unchanged }
    VersionID           : Word;
    xCommPort           : Byte;
    xBaud               : LongInt;
    xInitTries          : Byte;
    xInitStr,
    xBusyStr            : String[70];
    xInitResp,
    xBusyResp,
    xConnect300,
    xConnect1200,
    xConnect2400,
    xConnect4800,
    xConnect9600,
    xConnect19k,
    xConnect38k         : String[40];
    xAnswerPhone        : Boolean;
    xRing,
    xAnswerStr          : String[20];
    xFlushBuffer        : Boolean;
    xModemDelay         : Integer;

    MinimumBaud,
    GraphicsBaud,
    TransferBaud        : word;
    SlowBaudTimeStart,
    SlowBaudTimeEnd,
    DownloadTimeStart,
    DownloadTimeEnd     : Time;

    PageStart           : Array[0..6] of Time;
    PageEnd             : Array[0..6] of Time;

    SeriNum,
    CustNum             : String[22];
    FreeSpace1          : Array[1..24] of Byte;
    PwdExpiry           : Word;

    MenuPath,
    TextPath,
    AttachPath,
    NodelistPath,
    MsgBasePath,
    SysPath,
    ExternalEdCmd       : String[60];

    Address             : Array[0..9] of NetAddress;
    SystemName          : String[30];

    NewSecurity         : Word;
    NewCredit           : Word;
    NewFlags            : FlagType;

    OriginLine          : String[60];
    QuoteString         : String[15];
    Sysop               : String[35];
    LogFileName         : String[60];
    FastLogon,
    AllowSysRem,
    MonoMode,
    StrictPwdChecking,
    DirectWrite,
    SnowCheck           : Boolean;
    CreditFactor        : Integer;

    UserTimeOut,
    LogonTime,
    PasswordTries,
    MaxPage,
    PageLength          : Word;
    CheckForMultiLogon,
    ExcludeSysopFromList,
    OneWordNames        : Boolean;
    CheckMail           : AskType;
    AskVoicePhone,
    AskDataPhone,
    DoFullMailCheck,
    AllowFileShells,
    FixUploadDates,
    FreezeChat          : Boolean;
    ANSI,                       { ANSI: Yes, no, or ask new users     }
    ClearScreen,                { Clear:        "                     }
    MorePrompt          : AskType;    { More:         "                     }
    UploadMsgs          : Boolean;
    KillSent            : AskType;    { Kill/Sent     "                     }

    CrashAskSec         : Word;       { Min sec# to ask 'Crash Mail ?'      }
    CrashAskFlags       : FlagType;
    CrashSec            : Word;       { Min sec# to always send crash mail. }
    CrashFlags          : FlagType;
    FAttachSec          : Word;       {        "    ask 'File Attach ?'     }
    FAttachFlags        : FlagType;

    NormFore,
    NormBack,
    StatFore,
    StatBack,
    HiBack,
    HiFore,
    WindFore,
    WindBack,
    ExitLocal,
    Exit300,
    Exit1200,
    Exit2400,
    Exit4800,
    Exit9600,
    Exit19k,
    Exit38k             : Byte;

    MultiLine           : Boolean;
    MinPwdLen           : Byte;
    MinUpSpace          : Word;
    HotKeys             : AskType;
    BorderFore,
    BorderBack,
    BarFore,
    BarBack,
    LogStyle,
    MultiTasker,
    PwdBoard            : Byte;
    xBufferSize         : Word;
    FKeys               : Array[1..10] of String[60];

    WhyPage             : Boolean;
    LeaveMsg            : Byte;
    ShowMissingFiles,
    xLockModem          : Boolean;
    FreeSpace2          : Array[1..10] of Byte;
    AllowNetmailReplies : Boolean;
    LogonPrompt         : String[40];
    CheckNewFiles       : AskType;
    ReplyHeader         : String[60];
    BlankSecs           : byte;
    ProtocolAttrib      : Array[1..6] of Byte;
    xErrorFreeString    : String[15];
    xDefaultCombined    : array[1..25] of Byte;
    RenumThreshold      : Word;
    LeftBracket,
    RightBracket        : Char;
    AskForHandle        : Boolean;
    AskForBirthDate     : Boolean;

    GroupMailSec        : Word;

    ConfirmMsgDeletes   : Boolean;

    FreeSpace4          : Array[1..30] of byte;

    TempScanDir         : String[60];
    ScanNow             : AskType;
    xUnknownArcAction,
    xFailedUnpackAction,
    FailedScanAction    : Byte; {Bit 0:Mark deleted, 1:Mark unlisted, 2:Mark notavail}
    xUnknownArcArea,
    xFailedUnpackArea,
    FailedScanArea      : Word;
    ScanCmd             : String[60];
    xDeductIfUnknown    : Boolean;

    NewUserGroup        : Byte;
    AVATAR              : AskType;
    BadPwdArea          : Byte;
    Location            : String[40];
    DoAfterAction       : Byte; {0 = wait for CR, > 0 = wait for x seconds}
    OldFileLine         : String[40];
    CRfore,
    CRback              : Byte;
    LangHdr             : String[40];
    xSendBreak          : Boolean;
    ListPath            : String[60];
    FullMsgView         : AskType;
    EMSI_Enable         : AskType;
    EMSI_NewUser        : Boolean;

    EchoChar            : String[1];
    xConnect7200,
    xConnect12000,
    xConnect14400       : String[40];
    Exit7200,
    Exit12000,
    Exit14400           : Byte;
    ChatCommand         : String[60];
    ExtEd               : AskType;
    NewuserLanguage     : Byte;
    LanguagePrompt      : String[40];
    VideoMode           : VideoType;
    AutoDetectANSI      : Boolean;
    xOffHook            : Boolean;
    NewUserDateFormat   : Byte;
    KeyboardPwd         : String[15];
    CapLocation         : Boolean;
    NewuserSub          : Byte;
    PrinterName         : String[4];
    HilitePromptFore,
    HiLitePromptBack    : Byte;
    xInitStr2           : String[70];
    AltJSwap            : Boolean;
    SemPath             : String[60];
    AutoChatCapture     : Boolean;

    FileBasePath        : String[60];
    NewFileTag          : Boolean;
    IgnoreDupeExt       : Boolean;
    TempCDFilePath      : String[60];
    TagFore,
    TagBack             : Byte;
    xConnect16k         : String[40];
    Exit16k,
    FilePayback         : Byte;
    FileLine,
    FileMissingLine     : String[200];
    NewUserULCredit     : Byte;
    NewUserULCreditK    : Word;
    ArcInfo             : Array[1..10] of ARCrecord;
    RAMGRAltFKeys       : Array[1..5] of String[60];
    ArcViewCmd          : String[60];
    xConnectFax         : String[40];
    ExitFax             : Byte;
    UseXMS,
    UseEMS              : Boolean;
    CheckDOB            : Byte;
    EchoCheck           : AskType;
    ccSec,
    ReturnRecSec        : Word;
    HonourNetReq        : Boolean;
    DefaultCombined     : COMBINEDrecord;
    AskForSex,
    AskForAddress       : Boolean;
    DLdesc              : AskType;
    NewPhoneScan        : Boolean;

    Exit21k,
    Exit24k,
    Exit26k,
    Exit28k,
    Exit57k,
    Exit64k             : Byte;

    TagLogoffWarning,
    LimitLocal,
    SavePasswords       : Boolean;

    BlankLogins         : Byte;
    ripiconpath         : string[60];

    Exit31k,
    Exit33k             : Byte;
    IncludeNewCDareas   : Boolean;

{}  NewUserMsgArea,
{}  NewUserFileArea,
{}  NewUserFileGroup    : Word;

{}  FutureExpansion : Array[1..507] of Byte; {was 513 }
  end;

  EXITINFOrecord = record  {format changes slightly
		     Baud             : Word;
		     SysInfo          : SYSINFOrecord;      { not affected }
{See note}           OldTimeLogInfo   : OldTIMELOGrecord;   { Century Prefix below }
		     UserInfo         : USERSrecord;        { Format change - size unchanged }
		     EventInfo        : EVENTrecord;        { Format change - size unchanged }
		     NetMailEntered,
		     EchoMailEntered  : Boolean;
		     LoginTime        : Time;
{See note} OldLoginDate     : OldDate;            { Century Prefix below }
		     TimeLimit        : Word;
		     LoginSec         : LongInt;
		     UserRecord       : Integer;
		     ReadThru,
		     NumberPages,
		     DownloadLimit    : Word;
		     TimeOfCreation   : Time;
		     LogonPasswordCRC : LongInt;
		     WantChat         : Boolean;

		     DeductedTime     : Integer;
		     MenuStack        : Array[1..50] of String[8];
		     MenuStackPointer : Byte;
		     UserXIinfo       : USERSXIrecord;
		     ErrorFreeConnect,
		     SysopNext        : Boolean;

		     EMSI_Session     : Boolean;        { These fields hold  }
		     EMSI_Crtdef,                       { data related to an }
		     EMSI_Protocols,                    { EMSI session       }
		     EMSI_Capabilities,
		     EMSI_Requests,
		     EMSI_Software    : String[40];
		     Hold_Attr1,
		     Hold_Attr2,
		     Hold_Len         : Byte;

		     PageReason       : String[80];
		     StatusLine       : Byte;
		     LastCostMenu     : String[8];
		     MenuCostPerMin   : Word;

		     DoesAVT,
		     RIPmode          : Boolean;
		     RIPVersion       : Byte;

	   PrefixTimeLogInfo_StartDate,       { 'KC' From TimeLogRecord.StartDate }
	   PrefixLoginDate  : String[2];      { 'KC' From USERSrecord.LoginDate   }
		     ExtraSpace       : Array[1..79] of Byte;  { 79 was 85 }
		 end;

  PROTOCOLrecord = record       { Unchanged at ver 2.6 }
		     Name           : String[15];
		     ActiveKey      : Char;
		     OpusTypeCtlFile,
		     BatchAvailable : Boolean;
		     Attribute      : Byte; { 0=Disabled, 1=Enabled }
		     LogFileName,
		     CtlFileName,
		     DnCmdString,
		     DnCtlString,
		     UpCmdString,
		     UpCtlString    : String[80];
		     UpLogKeyword,
		     DnLogKeyword   : String[20];
		     XferDescWordNum,
		     XferNameWordNum : Byte;
		   end;


*** end of file ***
