ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng)/ProfitPress-MegaCDROM2.B6I/BBS/MISC/UBBS208B.ZIP/UBBSFMTS.TXT

Text File | 1991-07-24 | 38.4 KB | 972 lines

                         UltraBBS v2.08 File Formats
                                  07/25/91

Message File Format
-------------------

In the messages file (extension ".DAT"), each record is 150 bytes long. The
first record in each messages file has the following format:

struct firstrecord
{
 long nextrecord;
 long highmsgnum;
 long lowmsgnum;
 long lastfidomsgimported;
 char reserved[134];
}

The nextrecord variable contains the next record # that should be used in
the messages file (first record in file is record # 0).  The highmsgnum
variable contains the current high message number in the message base, and
lowmsgnum contains the current low message number in the message base.
The lastfidomsgimported variable is used by the FIDOCVT program and
is the number of the last message that was imported by FIDOCVT (or the
last message that has already been exported to FIDO format).

The header of each message in the messages file has the following format:

struct msgrecord
{
 long msgnum;
 unsigned char from[26];
 unsigned char to[26];
 unsigned char msgdate[9];
 unsigned char msgtime[6];
 unsigned char subject[26];
 unsigned char msgpass[21];
 unsigned char active;
 long referto;
 unsigned char datercvd[9];
 unsigned char records;
 unsigned char private;
 unsigned char timercvd[6];
 unsigned char echoflag;
 unsigned char rr;
 unsigned char perm;
 unsigned char attached;
 int hasreplies;
 unsigned char reserved[4];
}

All character arrays ("strings") are NULL TERMINATED character arrays!
They are NOT padded with spaces!  This applies for the rest of this file,
except where specifically stated otherwise.  Whatever follows the null byte
is of no consequence, it is ignored.

The msgnum variable is the number of this message.  The from variable
is the name of the user who entered the message.  The to variable is
the name of the user to whom the message was entered.  The msgdate variable
is the date on which the message was entered ("MM/DD/YY" format).  The
msgtime variable is the time on which the message was entered ("HH:MM"
format).  The subject variable is the subject of the message.  The msgpass
variable is the password of the message, it should be null if there is no
password on the message.  The active variable is nonzero if the message is
active, zero if the message is killed.  The referto variable contains the
message number of the message which this message is a reply off of, 0
if this message is not a reply to any other message.  The datercvd variable
contains the date on which this message was received ("MM/DD/YY" format),
it should be a 0 length string if the message has not been received yet.
The records variable contains the # of records in the message's text area
(it does NOT include the header!).  The private variable is nonzero if the
message is receiver only, or zero if it is public or password protected.
The timercvd variable contains the time on which this message was received
("HH:MM" format), it should be a 0 length string if the message has not been
received yet.  The echoflag variable is used only for conferences designated
as 'echo' conferences.  If nonzero, it is assumed that the message is
supposed to be exported for echomail, if zero, it should stay only in the
local message base.  The rr variable is nonzero if the user has requested a
return receipt, zero if he has not (a return receipt is generated when the
message is first received, the rr flag is NOT changed).  The perm variable
is nonzero if the message cannot be killed by the receiver, zero if it can
(this should only be used on public messages).  The attached variable is
nonzero if a file is attached to the message, zero if a file is not
attached.  The hasreplies variable is nonzero if the message has replies
to it, otherwise it is set to zero.  The reserved variable is used for
future use and should be set to all nulls. If a file is attached, it will
be placed in a subdirectory off of your attach directory named
MSGNUMBER.CONF (for example, ATTACHDIR\1.0\filename.ext for message # 1 in
conference # 0).

The actual text records of the message (following each header) are strings
of text, each representing a line of the message, followed by (Ctrl-A)
characters.  The very last (Ctrl-A) of the message (representing the
(Enter) on the last line of the message) is followed by a (Ctrl-B)
character.  The rest of the current record is padded out by unpredictable
characters to the next 150-byte boundary.

The records in the messages index file (extension ".NDX") have the
following format:

struct messageindexrecord
{
 long record;
 unsigned char to[26];
 unsigned char from[26];
 unsigned char private;
 unsigned char active;
 unsigned char subject[26];
}

The index begins at the low message number specified in the first record of
the message file.  The long integer is the record # in the messages file of
the message it represents (first record in file is record # 0 again). For
example, if the low message number is 5, and you wanted to find message # 5
in the messages file, you would look at the first record in the index file
to get message # 5's record in the messages file.  The to, from, private,
active, and subject fields should correspond to those fields in that
message's actual header.  Since the index file is based on the lowmsgnum
variable, you will not want to change the lowmsgnum variable at any time
unless your program does a complete pack of the message files.

FileBase File Format
--------------------

In the FileBase data file (extension ".DAT"), each record is 338 bytes
long.  Each file entry in the file has the following format:

struct filerecord
{
 unsigned char file[13];
 unsigned long filesize;
 unsigned char uploadedby[26];
 int timesdled;
 unsigned char filelocation[41];
 unsigned char lastdl[9];
 unsigned char dateoful[9];
 int freefile;
 unsigned char id[5];
 unsigned char descrip[225];
 int deleteflag;
}

The file variable contains the actual file name of the file on the BBS.
The filesize variable contains the size (in bytes) of the file on disk, or
0 if the file has a "variable" size.  The uploadedby field contains the full
name of the user who uploaded the file.  The timesdled field contains the
number of times that this file has been downloaded.  The filelocation
variable contains the actual physical location of the file (on the disk
drive).  The lastdl and dateoful fields contain (in "MM/DD/YY" format) the
last date the file was downloaded, and the date that the file was uploaded,
respectively.  The freefile variable is nonzero if the file is free (no
download charge), or zero if not.  The idvariable contains the 4 character
Directory ID of the file.  The descrip variable contains the description of
the file (5 lines, 45 characters each).  The descrip variable is NOT null
terminated and is padded with spaces!  The deleteflag variable is nonzero
if the file is flagged for deletion, zero if not.

The FileBase index files have a one-character extension that is the first
letter in their file name.  The records in the FileBase index files have
the following format:

struct fileindexrecord
{
 unsigned char file[13];
 unsigned char id[5];
 long record;
 long binarydate;
}

The file variable contains the file name of the file.  The id variable
contains the 4 character Directory ID of the file.  The record variable
contains the actual record (again, first record in data file is # 0) in the
FileBase data file where complete information on the file is stored.  The
binarydate field contains the file's date as a long integer.  This value is
obtained by rearranging the fields of the date to YYMMDD and then taking
the value into a long integer (ie: 10/12/90 = 901012).

User File Format
----------------

In the Users data file (extension ".DAT"), each record is 1695 bytes
long.  Each user entry in the file has the following format:

struct userrecord
{
 unsigned char name[26];
 unsigned char userpass[21];
 int security;
 int expert;
 unsigned char city[21];
 unsigned char lastdate[9];
 unsigned char lasttime[6];
 unsigned char newfchk[9];
 int downloads;
 int uploads;
 int elapsedmins;
 unsigned char page;
 unsigned char voice[14];
 unsigned char data[14];
 unsigned char protocol;
 int timeson;
 unsigned int doorsent;
 unsigned int msgsent;
 unsigned char confs[25];
 long lastmsg[200];
 unsigned char expiredate[9];
 int expiresec;
 unsigned char econfs[25];
 unsigned char birthdate[9];
 unsigned char sysopcomment[61];
 unsigned char fileforuser[41];
 unsigned char autopage;
 unsigned char userscanconfs[25];
 int deleteuser;
 unsigned char reserved2;
 double kuploaded;
 double kdownloaded;
 unsigned char fsdefault;
 int clrscrn;
 int timestored;
 long kbytesdled;
 unsigned char reserved[6];
}

The name variable is the full name of the user.  The userpass variable
contains the user's password.  The security variable contains the user's
security level.  The expert variable is nonzero if the user has turned on
expert mode, zero if not.  The city variable contains the user's
city/state.  The lastdate and lasttime variables (in "MM/DD/YY" and "HH:MM"
form, respectively) contain the last date and last time on which the user
called the BBS.  The newfchk variable (in "MM/DD/YY" format) contains the
last date that the user checked for new files.  The downloads and uploads
variables contain the number of downloads and uploads the user has done on
the BBS.  The elapsedmins field contains the elapsed minutes that the user
has spent on the BBS in all his calls on the last date he called.  The page
variable contains the user's screen page length.  The voice and data
variable contains the user's voice and data phone numbers, respectively.
The protocol variable contains the user's default transfer protocol.  The
timeson, doorsent, and msgsent variables contain the number of times the
user has logged on, the number of doors he has opened, and the number of
messages he has entered, respectively.  The confs variable is a 25-byte
(NOT null terminated) field that consists of 200 bits, each representing
one conference in the user's conference string (for example, bit 0 of the
first byte is conference 0, bit 2 of the second byte is conference 10).
The lastmsg[] array is a 200-element array of long integers, representing the
last message number read in each conference (0-199).  The expiredate (in
"MM/DD/YY" format) contains the date on which the user's subscription will
expire ("00/00/00" means it won't expire).  The expiresec variable contains
the security level to set this user to after his subscription expires.  The
econfs variable is the same format as the confs variable described above,
but is the conference string to set the user to after his subscription
expires.  The birthdate variable contains the date (in "MM/DD/YY" format)
on which the user was born.  The sysopcomment variable contains the comment
which the sysop has put on this user.  The fileforuser variable contains
the name of a file to display to the user upon login (a 0 length string if
no file should be displayed).  The autopage character should be set to
'N', 'I', or 'V'.  An 'N' means that no autopage will be done when this
user logs on.  If it is set to 'I' or 'V', an invisible or visible
(respectively) autopage will be executed when the user logs in.  The
userscanconfs variable works the same way as the two conference variables
mentioned above.  It defined the conferences that will be scanned upon
login, with the (Y) command, with (R A), for offline reading, etc.  The
deleteuser variable, if set to a nonzero value, means the user is marked
for deletion, otherwise the user is not marked for deletion.  The reserved2
variable is reserved for future use and should be left alone.  The
kuploaded and kdownloaded variables (stored as double precision values in
IEEE format) store the number of kilobytes (bytes / 1024) that the user has
uploaded and downloaded, respectively.  The fsdefault variable should be
set to a value of 0, 1, or 2.  A 0 means to ask the user if he wishes to
use the full screen editor each time he enters a message.  A 1 means that
the user wishes to use the full screen editor whenever possible, and a 2
means to not use it whenever possible.  The clrscrn variable, if set to a
nonzero value, means that the user wishes the screen to be clear prior to
reading each message; otherwise, the screen is not cleared.  The timestored
variable stored the amount of time (in minutes) that the user has stored in
the time bank.  The kbytesdled variable stores the number of kilobytes that
the user had downloaded on his last date on.  The reserved variable is
reserved for future use and must be set to all nulls.

The User File index files have a one-character extension that is the first
letter in the full name of the user.  The records in the user index files
have the following format:

struct userindexrecord
{
 unsigned char username[26];
 long record;
}

The username field is the full name of the user, and the record field is
the record (again, record # 0 is the first record in the data file) in the
users data file of this user.

Conferences Data File Format
----------------------------

In the conferences data file, each record is 2717 bytes long.  The first
record in the file contains the information for Conference # 0, the second
record contains the information for Conference # 1, and so on.  The format
of each record is as follows:

struct confrecord
{
 unsigned char confname[41];
 int allowalias;
 int echoconf;
 int allowesc;
 int maxdir;
 unsigned char msgsfile[41];
 unsigned char mainmenufile[41];
 unsigned char sysopmenufile[41];
 unsigned char newsfile[41];
 unsigned char uploaddir[31];
 int defaultfiledir;
 unsigned char doormenu[41];
 unsigned char doorlst[41];
 unsigned char bltmenu[41];
 unsigned char bltlst[41];
 unsigned char quesmenu[41];
 unsigned char queslst[41];
 unsigned char dirmenu[41];
 unsigned char votingmenu[41];
 unsigned char votinglst[41];
 int allowupload;
 struct dirinfo
 {char dirid[5];
  int dirsec;
 } dir[300];
}

The confname variable is the name of this conference.  The allowalias
variable, if set to nonzero means that aliases will be allowed in this
conference, else aliases will not be allowed.  If echoconf is nonzero, then
this conference is designated as 'echo', and users entering messages will
be prompted as to whether they wish to make their messages 'echo' or not.
If allowesc if nonzero, then users are allowed to use ESC (usually ANSI)
codes in their messages.  The maxdir variable contains the highest
directory number in this conference.  The msgsfile variable contains the
name (without extension) of the message file for this conference.  The
mainmenufile, sysopmenufile, newsfile, and uploaddir variables contain the
names for the main menu file, the sysop menu file, the news file, and the
directory to place uploads, respectively.  The defaultfiledir variable
stores the default file directory number to place uploaded files in.  The
doormenu, doorlst, bltmenu, bltlst, quesmenu, queslst, dirmenu, votingmenu,
and votinglst variables contain the file names of the door menu, door data
file, bulletins menu, bulletins data file, questionnaire menu,
questionnaire data file, file directory menu, voting booths menu, and
voting booths data file.  If the allowupload variable is zero, then uploads
will not be allowed in this conference.  The dir[] array is an array of 300
structures, each containing a 4 character directory ID and the security
required to download files from that directory ID.  All elements of dir[]
above the maxdir number are ignored.

NODEINFO File Format
--------------------

The NODEINFO file contains 99 records, each corresponding to a node on the
system.  Any records above your highest node number are ignored, but should
still be there.  The format of each node's record is as follows (71 byte
record length):

struct noderecord
{
 unsigned char status;
 unsigned char groupsummons;
 unsigned char nodepage;
 unsigned char nodebeeps;
 unsigned char lasteventdate[9];
 unsigned char lasteventtime[6];
 unsigned char nodeuser[26];
 unsigned char logoffflag;
 unsigned char nodedoor[21];
 int exittodos;
 int lasteventnumber;
 int pagingsysop;
}

The status variable contains the status of this node.  Possible values are
as follows:
   0 = UltraBBS isn't loaded on this node
   1 - 99 = User is in a private (1-99) channel in node chat
   100 = User is available for chat
   101 = User is unavailable for chat
   102 = User is entering a message
   103 = User is in a door
   104 = User is in remote DOS
   105 = User is transferring a file
   108 = User is in main channel of node chat
   109 = This node is waiting for calls
   110 = User is chatting with sysop
   111 = User is logging onto BBS (not at main menu yet)
The groupsummons variable is nonzero if this node is being summoned to
group chat.  After displaying the summons to the user, this flag is set to
zero.  The nodepage and nodebeeps variables record the state of the page
bell and beeps on this node (nonzero = on, zero = off).  The lasteventdate
and lasteventtime variables (in "MM/DD/YY" and "HH:MM" formats) store the
date and time of the last event run on this node.  The nodeuser variable
stores the user name of the user on this node.  The logoffflag variable, if
set to 1, it means that the user on this node has a logoff pending.  If it
is set to 2, it means that the user on this node has a lockout pending.
The nodedoor variable stores the name of the door that the user on this
node is in, if he is in a door.  The exittodos variable, if nonzero, means
that this node should exit to DOS after the current caller, or if no caller
is online, it should exit to DOS immediately.  The lasteventnumber
variable stores the number of the last event that was executed.  The
pagingsysop variable is nonzero if the user is currently paging the sysop,
zero if he is not.

Callers File Format
-------------------

The callers file for each node is created by taking the name specified in
the SETUP program, and appending the current node number (for example, if
Node 1's callers log would be CALLER1, then Node 99's callers log would be
CALLER99).  Each entry in the callers log is exactly 79 bytes long.  The
last two bytes are a CR/LF sequence (ASC 13, ASC 10).  The file, when
TYPEd, appears to be a text file, but must NOT be modified as a text file!

Doors Data File Format
----------------------

The first record in the doors data file is door # 1, the second record is
door # 2, etc.  The format of each record is as follows (98 byte record
length):

struct doorrecord
{
 unsigned char doorname[21];
 unsigned char doorfile[41];
 int doorsec;
 unsigned char doorpass[21];
 unsigned char doortype[11];
 int doorwatch;
}

The doorname variable contains the name of this door.  The doorfile
variable contains the full path (and any parameters) to the .BAT file for
this door. The doorsec variable contains the security level required to
access this door.  The doorpass variable contains the password required to
access this door (a 0 length string if no password is required).  The
doortype variable contains the door type which will be used for the CONVERT
program.  The doorwatch variable, if nonzero, means that the FOSSIL will
reboot the computer if the user hangs up in this door.

Questionnaires Data File Format
-------------------------------

The first record in the questionnaires data file is questionnaire # 1, the
second is questionnaire # 2, etc.  The format of each record is as follows
(126 byte record length):

struct quesrecord
{
 unsigned char quesname[21];
 unsigned char quesfile[41];
 unsigned char ansfile[41];
 int quessec;
 unsigned char quespass[21];
}

The quesname variable is the name of this questionnaire.  The quesfile and
ansfile variables are the file names of the questionnaire script file, and
the output answers file, respectively.  The quessec variable is the
security required to answer this questionnaire, and the quespass variable
is the password that is required (a 0 length string means no passworD).

Voting Booths Data File Format
------------------------------

The first record in the voting booths data file is voting booth # 1, the
second is voting booth # 2, etc.  The format of each record is as follows
(1388 byte record length):

struct votingrecord
{
 unsigned char votingname[46];
 unsigned char datafile[41];
 int votingsec;
 unsigned char votingpass[21];
 unsigned char choices[18][71];
}

The votingname variable is the question presented by this voting booth.
The datafile variable contains the name of the voting results data file for
this voting booth.  The votingsec & votingpass variables contain the
security required for this voting booth, and the password required for the
booth (0 length password means no password).  The choices[] array is an 18
element array containing strings of the 18 possible responses.

Bulletins Data File Format
--------------------------

The first record in the bulletins data file is bulletin # 1, the second
record is bulletin # 2, etc.  The format of each record is as follows (64
byte record length):

struct bltrecord
{
 unsigned char bltfile[41];
 unsigned char bltpass[21];
 int bltsec;
}

The bltfile variable contains the file name of the actual bulletin.  The
bltpass & bltsec variables contain the password (0 length means no
password) and the security required to access this bulletin.

No Uploads File Format
----------------------

The format of a record in the no uploads file is as follows (43 byte record
length):

struct nouprecord
{
 unsigned char file[41];
 int upsecurity;
}

The file variable is the wildcard specification for this entry.  The
upsecurity variable contains the minimum security level required to upload
a file that matches the wildcard spec.

Compression Methods Data File Format
------------------------------------

The first record in the compression methods data file will be the default
compression method for use in Qmail packets.  The format for each entry is
as follows (224 byte record length):

struct comprecord
{
 unsigned char ext[4];
 unsigned char viewform[51];
 unsigned char addform[51];
 unsigned char getform[51];
 unsigned char testform[51];
 unsigned char badtext[16];
}

The ext variable contains the 3 character extension used by this
compression method.  The viewform, addform, getform, and testform store the
command line needed to execute the various functions.  See the UltraBBS
sysop documentation for more information on what these strings should look
like.  The badtext variable contains the text that the compressor will
display if a file is bad during an integrity check.

Protocols Data File Format
--------------------------

The format of each record in the protocols data file is as follows (109
byte record length):

struct protrecord
{
 unsigned char letter;
 unsigned char batch;
 unsigned char uload[41];
 unsigned char dload[41];
 unsigned char protname[21];
 int atsign;
 int dszlog;
}

The letter variable is the letter used to select this protocol from the
BBS.  The batch variable should be set to 'S', 'M', or 'B' for single file,
multiple files, or bidirectional multiple files.  The uload and dload
variables store the name of the batch file for uploads and downloads,
respectively (dload variable is used for bidirectional transfer batch
files).  The protname variable contains the name of this protocol.  The
atsign variable, if nonzero, means that this protocol supports the
'@listfile' command line parameter, to transfer up to 99 files instead of
just 6 or 7.  The dszlog variable, if nonzero, means that this protocol
will write a DSZ.LOG file after a download.

Limits Data File Format
-----------------------

The format of each record in the limits data file is as follows (14 byte
record length):

struct limitsrecord
{
 int limitssec;
 int limitsmins;
 int kbytesperup;
 int filesperup;
 int doornumber;
 long kbytesperday;
}

The limitssec variable is the security for which this record applies.  The
limitsmins variable is the number of minutes that this security level will
get each day.  The kbytesperup (stored as a double precision IEEE format
number) and filesperup variables determine how many Download Kilobytes the
user may have for each 1 Upload Kilobyte; and the number of Download Files
the user may have for each 1 Upload File.  To negate the function of
either, set it to 0.  The doornumber variable contains the door number
which will be automatically opened when any user of this security level
logs on.  The kbytesperday variable stores the number of kilobytes that
a user of this security level can download per day.

Voting Results Data File Format
-------------------------------

A voting results data file contains records 27 bytes in length for each
user who has voted (a user will not appear more than once in the file).
The format of each record is as follows:

struct votedrecord
{
 unsigned char name[26];
 unsigned char choice;
}

The name variable is the name of the user to which this vote applies, and
the choice variable is the choice number which he voted for.

Node Chat Data File Format
--------------------------

Each record (one character typed in node chat) is 3 bytes in the node chat
data file.  The first byte of the record is a char that should be set to
the channel # that this message is going through (0-99).  If the record is
representing a character, then the second byte of the record should be set
to the number of the node that is sending the character, and the third byte
should be set to the actual character.  If the record is to notify of an
exit/entrance/hangup/etc, then the second byte should be set to 253 for a
force off (hang up, etc), 254 for an entrance, and 255 for an exit; and the
third byte should be set to the node number to which this
exit/entrance/hangup applies to.

UBBS.SYS Door Exit File Format
------------------------------

The UBBS.SYS file is created before exiting to a door, and is read back in
by UltraBBS upon returning to obtain info about who is on.  This file is
usually just used by CONVERT to make other, more commonly used, door files,
but some software authors may wish to use it to alter user information, or
obtain more detailed, UltraBBS-specific information.  Its format is as
follows:

struct ubbs_sysfile
{
 long modembaud;
 long callerbaud;
 int eight_bit;
 char time_on[6];
 char date_on[9];
 int kbytesperup;
 int filesperup;
 long kbytesperday;
 int graphics;
 long userpos;
 int local_user;
 int confnum;
 char confsjoined[200];
 char prevdate[9];
 char prevtime[6];
 int disable_remote;
 int available;
 long logon_time;
 long secs_session;
 long elapsedsecs;
 long eventadjust;
 char markedfiles[99][13];
 unsigned char markednum;
 char oldfchk[9];
  -------------------- Variables below this line are write-only.  UltraBBS
                       does not read them in upon returning from a door.
                       If you wish to modify other variables, do so in the
                       users file!
 char bbsname[31];
 char sysopname[26];
 char curtime[6];
 char page_bell;
 char beeps;
 int junk;
 long timeused;
 char eventtime[6];
 int eventactive;
 int port;
 char usermixed[26];
 int minsremaining;
 char node;
 struct user currentuser;
}

The modembaud variable contains the actual bps rate (locked bps rate) of
the port.  The callerbaud variable contains the bps rate the caller is
actually communicating at.  eight_bit is nonzero if the caller is 8N1, zero
if 7E1.  The time_on string contains the time at which the caller logged on
(HH:MM format), and date_on contains the date at which he logged on
(MM/DD/YY format).  kbytesperup and filesperup contain the number of
kilobytes that this user may download per kilobyte he uploads, and files he
may down per file he uploads (a value of 0 sets these to unlimited).  The
graphics variable is 0 if (N)o graphics, 1 if (B)lack & White graphics, 2
if (C)olor graphics.  The userpos variable contains the user's position in
the user file (the first record in user file is rec # 0).  local_user is
nonzero if the user is on local, zero if remote.  confnum contains the
current conference number the user is in.  confsjoined is a non-null
terminated string that contains spaces or 'X's, specifying which
conferences the user has joined during the current call.  The prevdate and
prevtime variables (MM/DD/YY and HH:MM) contain the date and time of the
user's last call (before this one).  disable_remote if nonzero if the
remote user's keyboard is disabled, zero otherwise.  available is nonzero
if the user is available for chat, zero otherwise.  logon_time contains the
seconds at which the user logged in (# of seconds elapsed since 00:00:00
Greenwich mean time, January 1, 1970).  secs_session contains the number of
seconds this user has per call (obtained from LIMITS.DAT).  elapsedsecs is
the number of seconds this user has used in calls earlier today.
eventadjust is the number of seconds the user has lost today because of
time adjustments due to upcoming events.  markedfiles is an array of
strings (containing 99 strings) containing which files the user has marked
to download via the (FL) command.  markednum contains the number of files
the user has marked.  oldfchk contains the last date (MM/DD/YY format)
which the user checked for new files.  bbsname contains the name of the
BBS.  sysopname is the name of the sysop, in all caps.  The curtime
variable contains the time (HH:MM format) that this UBBS.SYS file was
created.  The page_bell variable is true (nonzero) if the page bell is on,
zero if it's off.  beeps is nonzero if beeps/music is on, zero otherwise.
The junk variable is not used.  timeused contains the amount of time (in
seconds) the user has used so far today.  eventtime contains the time
(HH:MM format) of the next event.  eventactive is nonzero if any events are
configured, zero otherwise.  port contains the COM port number of the
current COM port (0=COM1, 1=COM2, 2=COM3, etc).  usermixed contains the
mixed case name of the user (ie: 'Bob Farmer').  minsremaining contains the
time, in minutes, that the user has remaining as of the creation of this
UBBS.SYS file.  This variable can be used, possibly in conjunction with the
curtime variable, to quickly obtain a time left calculation.  The node
variable contains the node # of this node.  The currentuser structure is in
the same format as a record in the user file (see above), and contains the
user record of the current user.

Caller Number Data File Format
------------------------------

The caller number data file is 4 bytes, and simply contains a single
long integer which is the number of calls made to the system.

UltraBBS's UBBS.DAT File Format
-------------------------------

The UBBS.DAT file is a line-by-line, sequential text file maintained by the
SETUP program.  The lines, in order, are as follows:

Maximum # of Messages for (O) and (D C)
Event # 1 Guard Time
Event # 2 Guard Time
Event # 3 Guard Time
Security to Edit His Own Messages
Use BIOS Output?
Security for (6)
BBS Listing Data File Name
Security for (BB)
Use Terse Caller Logging?
Caller Number File Name
Number of Rings to Skip Before Answering
Instant Logon Password
Event # 2 Active?
Event # 3 Active?
Event # 2 Time
Event # 3 Time
Security for (11)
Security for (TI)
Maximum Storable Time in (TI)
Check Message 'To' Field?
Delete the File For User?
Birthday File Name
Security for (10)
Start of SysOp Page Hours
End of SysOp Page Hours
Holding Directory Name
Scratch Directory Name
No New Users File Name
FileBase File Name
Help Prefix File Name
Conference Data File Name
Conference Menu File Name
Caller File Prefix File Name
Node Chat File Name
Welcome File Name
Goodbye File Name
Limits Data File Name
NODEINFO Data File Name
Protocols Data File Name
User Data File Name
No Registration File Name
No Uploads Data File Name
Low Security File Name
New User File Name
Remote DOS Batch File Name
Aliases Data File Name
User Security Files Path Name
Event # 1 Time
BBS Name
SysOp's Name
Initialization Command
Answer Command
Off-Hook Command
Batch Directory Name
Public Conferences String (exactly 200 chars)
New User Questionnaire File
New User Answers File
Expired Subscription File Name
Compression Data File Name
Post-Upload Batch File Name
Node Number
Communications Port
Allow New Users?
Security to Overwrite Files
RTS/CTS Checking?
Test Uploads?
Security for (M)ultiple Copy Save
Security to Read Killed Messages
Security to Edit/Move Messages
Security to Kill Any Messages
Security to Skip Message Password
Security to Leave Message To SysOp
Initialization Baud Rate
Page Bell FIle Name
Private Directory ID
Security for (G X)
Highest Node Number
Minimum Security to Logon
Security to Classify Files
Use Post-Upload Batch File?
New User Security
Allow Aborting of Welcome?
Lowest Baud Rate Allowed
Seconds Allowed for Registration
Security to Read Private Messages
Seconds Between Node Checks
SysOp Menu Security
Upload Time Credit Factor
Seconds of Idle Time Allowed
Security to Edit Any Description
Security to Import File into Message
Lock Baud Rate?
Allow 7E1 Callers?
Event # 1 Active?
Shell to Doors?
Reboot on DOS Hangup?
Shell to DOS?
Security for (NO)/(CH)
Security for (B)
Security for (W)
Security for (OP)/(DO)
Security for (G)
Security for (I)
Security for (J)
Security for (K)
Security for (O)
Security for (P)
Security for (Q)
Security for (R)
Security for (S)
Security for (US)
Security for (V)
Security for (X)
Security for (Y)
Security for (1)
Security for (2)
Security for (3)
Security for (4)
Security for (5)
Security for (7)
Security for (8)
Security for (BI)
Security for (D)
Security for (ED)
Security for (U)
Security for (Z)
Security for (VI)
Security for (RE)
Security for (F)
Security for (N)
Security for (E)
Security to Page Unavailable Users
Security for (WH)
Security for (L)
Security to Request Return Receipt
Security to Forward a Message
Pre-Upload File Name
Qmail Offline ID
BBS City/State
BBS Phone Number
Qmail Menu File Name
Security for (FL)
File Attach Directory Name
Allow Non-2-Word Names?
Continue After Modem Init Failure?
Security for (9)

Information for BASIC Programmers
---------------------------------

All numbers are stored in IEEE format.  Variable information:

An 'unsigned char' or a 'char' is a numerical value stored in one byte.  To
convert it to BASIC, read it in as a 1-character string (A$, for example),
then, to get its value into a variable, (A%, for example), use A% = ASC(A$).

An 'int' or an 'unsigned int' is a 2-byte number, equivalent to BASIC's
INTEGER type (%).

A 'long' or an 'unsigned long' is a 4-byte integral number, equivalent to
QuickBASIC's LONG INTEGER type (&).

A 'double' is an 8-byte floating point number, equivalent to BASIC's DOUBLE
type (#).  NOTE: older versions of Microsoft's QuickBASIC store DOUBLEs in
Microsoft Binary format, remember, these are in IEEE format - 4.0+ of
QuickBASIC is fine.

A 'float' is a 4-byte floating point number, equivalent to BASIC's SINGLE
type (!).  NOTE: older versions of Microsoft's QuickBASIC store SINGLEs in
Microsoft Binary format, remember, these are in IEEE format - 4.0+ of
QuickBASIC is fine.

Any numerical type with a number in brackets after the variable name is an
array of the number of elements specified in brackets.  Two pairs of
brackets means a two-dimensional array, etc.

An 'unsigned char ....[]' value (unless it is literally an array of char
values) is a string.  The value in brackets is the max length of the
string.  However, all strings are null terminated.  First, this means that
the 'max length of the string' in brackets will actually be one more than
the true max length.  Second, at the end of all meaningful characters
in the string, there will be a null (ASCII 0) character, followed by
unpredictable trash.  The strings are NOT padded with spaces!  When reading
in these "string" values, use a BASIC STRING of the length in the brackets,
and this command may be used afterwards to obtain a true BASIC string:
REAL.STRING$ = LEFT$(STRING.FROM.FILE$, INSTR(STRING.FROM.FILE$, CHR$(0))-1)
Some arrays of unsigned char are not actually strings, but as mentioned
earlier, literally arrays of char values, and when this is the case, it is
mentioned in the description of that structure in this document.

Information for Pascal Programmers
----------------------------------

An 'unsigned char' type corresponds to Turbo Pascal's byte type.

A 'char' type corresponds to Turbo Pascal's shortint type.

An 'unsigned int' type corresponds to Turbo Pascal's word type.

An 'int' type corresponds to Turbo Pascal's integer type.

An 'unsigned long' or 'long' type corresponds to Turbo Pascal's longint type.

A 'double' is an 8-bit floating point type, and a 'float' is a 4-bit
floating point type.  Their Pascal equivalent types vary widely.  See your
compiler guide, and remember, these are in IEEE format.

Any numerical type with a number in brackets after the variable name is an
array of the number of elements specified in brackets.  Two pairs of
brackets means a two-dimensional array, etc.

An 'unsigned char ....[]' value (unless it is literally an array of char
values) is a string.  The value in brackets is the max length of the
string.  However, all strings are null terminated.  First, this means that
the 'max length of the string' in brackets will actually be one more than
the true max length.  Second, at the end of all meaningful characters
in the string, there will be a null (ASCII 0) character, followed by
unpredictable trash.  The strings are NOT padded with spaces!  When reading
in these "string" values, use a packed array of char of the length in the
brackets.  The true length of the string will be the position of the first
ASCII 0 (null) minus one (assuming first char in the string is pos # 1).
Some arrays of unsigned char are not actually strings, but as mentioned
earlier, literally arrays of char values, and when this is the case, it is
mentioned in the description of that structure in this document.