ProBoard Interface Functions

This is a list of all the functions that can be used to interface with ProBoard.

Several types have been defined in the file PB_SDK.H

bool : a boolean value that can have the values TRUE or FALSE
byte : an unsigned character (8 bits)
word : an unsigned short integer (16 bits)
dword : an unsigned long integer (32 bits)
KEY : used for key scan codes (for sysopkey handlers and the
ScanKey() function).

void AddTime( int min );

Adds 'min' minutes to the user's time left. If 'min' is negative, the number of minutes will be subtracted from the time left.

Examples:

AddTime( 10 ); /* Adds 10 minutes */
AddTime( -5 ); /* Subtracts 5 minutes */

int TimeLeft( void );

Returns the time left in minutes for the current user.

int TimeOnline( void );

Returns the time in minutes that the current user is online.

void SuspendTimer( void );

Suspends the online-timer for the current user. No time will be subtracted until RestartTimer() is called.

void RestartTimer( void );

Restarts the timer after a call to SuspendTimer().

void AdjustTime( void );

Call this function if you changed the user's level. This recalculates all limits (time,download,…).

void MsgEd( void );

Fires up the internal message editor or the fullscreen editor, depending on the settings of the user. The message will be stored in the file MSGTMP in the current directory. If a message is aborted, the file MSGTMP will be deleted by the message editor. If you create a MSGTMP file before invoking the message editor, this file will be used as a 'quote' message.

int PostMessage( char *from, char *to, char *subject, int area, bool pvt );

Posts a message to a user.

from = Name of the sender
to = Name of the user you're sending the message to
subject = Subject of the message
area = Message area number where the message has to be posted in
pvt = Private status (TRUE=private, FALSE=public)

No checking is performed on any of the parameters!

Return value: -1 on error
0 if ok

int PostNetmail( char *from, char *to, char *subject, int area, FIDO_NODE *address, bool attach, bool crash, bool kill );

Posts a netmail message.

from = Name of the sender
to = Name of the user you're sending the message to
subject = Subject of the message
area = Message area number where the message has to be posted in
address = Destination node number of this message.
attach = TRUE for a file attach message
crash = TRUE if this message is a crashmail message
kill = TRUE if the message has to be deleted after it is sent

FIDO_NODE is a structure with the following fields:

struct
{
unsigned zone; /* Zone number */
unsigned net; /* Net number */
unsigned node; /* Node number */
unsigned point; /* Point number */
}

No checking is performed on any of the parameters!

Return value: -1 on error
0 if ok

bool ReadMsgArea( int area, MSGAREA *ma );

Reads data about a message area.

area = Message area number (1-200)
ma = Pointer to a MSGAREA structure to be filled

Check the file PB_SDK.H for details about the MSGAREA structure definition.

Return value: 6
FALSE if not defined
TRUE if read ok

bool ReadMessage( MESSAGE *msg, long msgid, int areanum );

Reads message id <msgid> from area numer <areanum> into the MESSAGE structure. To access the text of the message, use the function CreateMessageText(). See the file PB_SDK.H for a description of the MESSAGE structure.

Return value: FALSE if the message does not exists
TRUE if the message is read ok

void WriteMSGTMP( char *text );

Writes the string <text> to the file MSGTMP. The file is always recreated when using this function. To append text to MSGTMP, use the function AppendMSGTMP(). You have to insert your own CR/LF pairs in the text if you want to force a newline. Lines can be longer than 80 characters. The message processing functions will do a word-wrap if necessary. Do NOT insert a single CR or LF in the text. (\r or \n).

void AppendMSGTMP( char *text );

Same as WriteMSGTMP(), but adds text to an EXISTING file.

void ShowMessage( MESSAGE *msg );

Shows the message <msg> to the user, including header and message text.

See the file PB_SDK.H for an description of the MESSAGE structure.

void CreateMessageText( MESSAGE *msg );

Reads the text that belongs to message <msg>, and stores it in a file called MSGTMP in the current directory. This file can then be accessed as an ordinary textfile.

void CreateMessageTextString( MESSAGE *msg, char *text, int max);

Reads the text that belongs to message <msg>, and stores it in the string <text>. The text will be terminated by a '\0' character. You have to specify a maximum number of characters that can be stored in <text>.

bool FirstMessage( MESSAGE *msg, int area, int order, long first);

bool NextMessage( MESSAGE *msg, int area, int order );

These functions are used to read messages in forward or reverse order. To start scanning messages, you have to call the FirstMessage() function first, and the NextMessage() function to read more messages.

msg = MESSAGE structure where the message has to be stored.
area = area number to read messages in
order = 1 for forward order, -1 for reverse order
first = message to start reading from. This message does NOT need to
exist. The first non-deleted message following this message
will be read first.

See the file PB_SDK.H for an description of the MESSAGE structure.

Return value: FALSE No more messages found.
TRUE Message was found and read ok.

This is an example on how to use these functions:

result = FirstMessage( msg,
5,
+1,
1 );
while ( result == TRUE )
{
/* Do something with the message */
result = NextMessage( msg,
5,
+1 );
}

void DeleteMessage( MESSAGE *msg );

Deletes message <msg>.

void MarkMessage( long msgid );

Marks message <msgid> for later retrieval. Up to 200 messages can be marked.

void ReadMarkedMessages( void );

Shows all marked messages to the user, with the option to wait after each message. If the user selected to wait after each message, the standard message options menu will be shown to the user. (Next,Prev,Stop,…).

In fact, this function is identical to menu function “Read Messages”, with the user selecting “Marked”.

void ListMarkedMessages( void );

Is similar to ReadMarkedMessages(), but this function acts as a “QuickScan Messages” with the user selecting “Marked”.

void UnMarkAllMessages( void );

Unmarks all messages that were previously marked. You have to call this function before marking any messages, because the list of marked messages is remembered until a user logs off.

int NumMsgAreas( void );

Returns the highest message area number that is not empty.

long GetLastRead( int areanum, long user_recno );

void SetLastRead( int areanum, long user_recno, long msgid );

Reads / Sets the lastread pointer for a specific user and message area. If GetLastRead() returns -1, an error occurred.

<areanum> ..... The area number (1-10000)
<user_recno> .. The record number of the user (0 - ...)
<msgid> ....... The id of the message you want to set the lastread
pointer to.

int FuzzySearch( char *text, char *string, int degree );

Performs a fuzzy search for <string> in <text>. <degree> is the percentage of the characters in <string> that have to match.

Return value: -1 if not found
>0 percentage of characters matched

IO_... functions

All functions starting with IO_ are low-level functions to access the serial port directly. Do NOT use these functions for ordinary I/O operations. They are intended for writing file transfer protocols. See the file PB_SDK.H for the prototypes of these functions.

char WaitKey( void );

Waits for a character to be read from the modem or local keyboard.

Return value: the character read.

char WaitKeys( char *keylist );

Waits for any character specified in <keylist>.

Return value: the key from the list that was pressed (converted to
uppercase if the key is a letter).

Example:

c = WaitKeys( "ABC\r\x1b" );
/* Waits for A,B,C,<Enter> or <Esc> */

void Input( char *buf, int len, int readmode );

Asks for a string from the user. The string is stored in <buf>, and the user will not be allowed to enter more than <len> characters.

<readmode> : INPUT_ALL : All characters are allowed
INPUT_UPFIRST : First character of each word is
converted to uppercase.
INPUT_UPALL : All characters are converted to
uppercase.
INPUT_DIGITS : Only digits are accepted.
INPUT_NOFIELD : OR together with any of the previous
modes if you don't want an input-
field background to be displayed.

bool Ask( bool default );

Asks for a Yes or No response from the user. Pressing 'Y' returns TRUE and outputs “Yes”. Pressing 'N' returns FALSE and sends “No” to the user. Pressing <Enter> returns <default>, and sends “Yes” or “No”, depending on <default>.

char PeekChar( void );

Checks if a character is available in the input buffer, and returns that character if there is.

Return value: 0 if no character available
!= 0 the character read (key pressed by user)

void SetColor( char color );

Changes the current output color. All text that is output after this function is called will be displayed in the specified color. This function does nothing when the user does not have ANSI or AVATAR enabled.

<color> can be one of the following:

BLACK, RED, GREEN, YELLOW, MAGENTA, BLUE, CYAN, WHITE

void SetfullColor( unsigned char color );

Changes the current foreground & background color. The color code is an IBM-type screen color code. This function does nothing when the user does not have ANSI or AVATAR enabled.

Some examples:

0x1E : Bright yellow on dark blue background.
0x87 : Blinking white on a black background.

void GotoXY( int x, int y );

Moves the cursor to position (x,y). The upper left corner of the screen is (1,1). This function does nothing when the user does not have ANSI or AVATAR enabled.

void ClrEol();

Clears from the current cursor position to the end of the line. This function does nothing when the user does not have ANSI or AVATAR enabled.

void EnableStop( void );

void DisableStop( void );

bool Stopped( void );

Enables stopping of output by pressing 'S'. When enabled, a user can press 'S' to stop incoming text. When this happens, any string output function will immediately return to the caller, en the function Stopped() will return TRUE to indicate that the user requested to stop output.

EnableStop() Enables this feature and sets the "stopped"
status to FALSE .
DisableStop() Disables the stop feature.
Stopped() Returns the "stopped" flag (TRUE or FALSE).

Example:

EnableStop();
for ( i = 0; i < 100; i++ )
{
printf( "...something..." );
if ( Stopped() )
{
break;
}
}

char ShowHotkeyFile( char *filename, char *hotkeys );

Shows the file <filename> to the user, and watches for incoming keys that are specified in <hotkeys>. If one of these keys is detected, the function stops output, and returns the hotkey. The “stop” feature will be enabled when sending the file.

Return value: 0 : File sent completely and no hotkeys pressed.
1 : 'S' pressed (output stopped)
2 : File not found
!=2 : Hotkey detected

char ShowHotkeyANSIFile( char *filename, char *hotkeys );

This function is identical to ShowKotkeyFile(), except for the fact that no extension and path can be specified. Depending on the setting of the user, <filename>.ANS/ASC in the textfiles directory will be sent. If no .ANS file is found, it will try to send the .ASC file. If that fails too, 2 will be returned.

Return value: 0 : File sent completely and no hotkeys pressed.
1 : 'S' pressed (output stopped)
2 : File not found
!=2 : Hotkey detected

void InitLineCounter( void );

bool LineCounter( void );

These functions are used to support page pausing (“More Y/N”). Calling InitLineCounter() initializes the line counter to 0. Every time you call LineCounter(), the line counter is incremented by one. If the counter reaches the screen length, the user will be asked if he wants to continue reading. If he selects “No”, the LineCounter() function will return FALSE.

Example:

InitLineCounter();
for ( ; ; )
{
printf( "...something...\n" );
if ( ! LineCounter() )
{
break;
}
}

bool ExternalInput( void );

Returns TRUE when the last character that was read through any of the input routings originated from the remote keyboard (ie. the sysop did not type it).

int ReadUser( USER_REC *rec, int recnr );

Reads user record number <recnr> (0-…) from the user file and stores it in <rec>.

Return value: -1 if record does not exist.
0 if record is read ok.

void WriteUser( USER_REC *rec );

Writes user record <rec> to the user file. The record number is stored in the USER_REC structure. If you want to write a user record to a different position in the user file, you have to change the 'record' field in the USER_REC structure.

bool SetUser( long recnr );

Sets the internal ProBoard user record to record number <recnr>. This function should ONLY be called from _LOGIN.PEX !!

Return value: TRUE on success
FALSE on error

char PlayMusic( char *filename, char *hotkeys );

Plays a .MUS file. The file has to be located in the ProBoard system directory. Do not include a path and extension in <filename>. The music can be stopped if the sysop presses one of the keys specified in <hotkeys>. ^^^^^

Return value: 0 Music file played till the end
1 Music file not found
>1 The hotkey pressed by the SYSOP
^^^^^

void PostInfo( char *filename );

Does exactly the same as the POSTINFO statement in a .Q-A file. No path and extension is allowed in <filename>. The file where the information will be written to will have the extension .ASW and will be placed in the ProBoard system directory.

int ReadFileArea( int areanum, FILEAREA *fa );

Reads information about file area number <areanum> in the <fa> structure.

Check the file PB_SDK.H for details about the FILEAREA structure.

Return value: -1 File area does not exist
0 Ok

void MenuFunction( int function, char *data );

Executes menu function <function> with <data>. For details, see the menu functions description in this file.

There are named constants declared for each function in the file PB_SDK.H. It is recommended that you use these constants instead of numbers.

void Log( int loglevel, char *fmt, ... );

With this function you can write information to the ProBoard logfile. The log entry will be written if the user has a loglevel that is greater than <loglevel> .

<loglevel> can be one of the following:

LOG_FRIEND, LOG_NORMAL, LOG_SUSPICIOUS, LOG_DANGEROUS

If you want a log entry to be written regardless of the user's loglevel, use LOG_FRIEND.

The Log() function works like the printf function: you can use format specifiers in the <fmt> string, and pass extra parameters.

Example:

Log(LOG_NORMAL,"User's name = %s",CurUser->name);

void HangUp();

Hangs up the phone, logging off the user. It is exactly the same as pressing Alt-H.

bool CheckAccess( int level, long flags );

Checks if the current user can access something that requires <level> and <flags>. Returns TRUE if the user has access, FALSE if not.

KEY ScanKey( void );

Checks the LOCAL keyboard for a key, and returns the scan code for that key. If no key is available, 0 will be returned.

For a list of defined values for scan codes, check the file PB_SDK.H.

bool GetFlag( long flags, char flagchar );

void SetFlag( long flags, char flagchar );

void ClearFlag( long flags, char flagchar );

Access flags are stored in a long integer (32 bits). You have 3 macros at your disposal to manipulate access flags:

GetFlag : Returns TRUE if flag <flagchar> is set
SetFlag : Turns flag <flagchar> on
ClearFlag : Turns flag <flagchar> off

<flagchar> must be a value from 1 to 32. 1-26 correspond to A-Z, while 27-32 are the same as 1-6.

int ErrorLevel( void );

Returns the errorlevel of the last executed shell command (Through MenuFunction(MENU_SHELL,…))

bool GetIniVar( char *fname, char *varname, char *value, int max );

bool SetIniVar( char *fname, char *varname, char *value );

These functions can be used to read and write to .INI files. These files are similar to the files used by MS Windows. They can be used to store settings for your application (PEX). An example of a .INI file:

DataPath = C:\PB\PEX\MYPEX\DATA
ProgPath = C:\PB\PEX\MYPEX
MaxUsers = 10

This is a standard ASCII file, with each line in the form:

<varname> = <value>

The value of a specific variable can be read by calling the function GetIniVar(). Setting a variable (writing to the .INI file or createing it if it doesn't exist yet) can be done by calling SetIniVar().

The parameters for the functions are:

<fname> Name of the .INI file. The extension of the file will
always be changed to .INI by ProBoard.
<varname> Name of the variable (case INsensitive)
<value> For GetIniVar() : a pointer to a buffer where the
variable's contents will be stored.
For SetIniVar() : a pointer to the value of the
variable.
<max> Maximum number of characters that can be copied in
<value> (including trailing '\0')

Return value: FALSE if the file could not be opened or the variable does not exist.

void exit( void );

Exits the current pex-program, and unloads it from memory.

void ExitTSR( void );

Exits the current pex-program, and leaves it resident. This has some important implications:

All global and static variables keep their values for subsequent executions.

When the same pex-file is run again through menu function 60, the resident copy will be executed. This will result in faster loading.

Any handlers that were installed will be called.

void InstallHandler( int handler, function );

This is probably the most advanced and complicated function in the ProBoard SDK. With this function you can set up a “handler” for a specific action. Right now, only two types of handlers are supported: a replacement for the sysopkey-handler and a handler to intercept loss of carrier. This way you can create your own sysopkeys, or change the behaviour of existing sysopkeys. You could create a handler that intercepts the Alt-J key, and write your own flavor. In future versions you will be able to set up handlers for low-level I/O operations. So you could replace all I/O routines by your own functions. This way you can support your own exotic hardware or something like that. Anything goes!

handler : Handler type. At this time, only HANDLER_SYSOPKEY and
HANDLER_HANGUP are supported.
function : A pointer to the handler function you created.

You can install as many handlers as you want. When the PEX is removed from memory (when the PEX exits), all handlers that were installed will be removed by ProBoard.

The handler function is a function that returns an integer. The parameters depend on the type of handler you are creating.

For HANDLER_SYSOPKEY the handler function has to be declared like this:

int sysopkeyhandler( KEY k )
{
...
}

A sysopkey handler intercepts any special key that is pressed by the sysop. (like F1,Alt-H,…). You can redefine any key, or add your own.

For HANDLER_HANGUP, the handler functions has to be declared like this:

int hanguphandler( void )
{
...
}

The hangup handler works a little different: it is called whenever ProBoard exits (carrier lost, sysop hung up,…). It can be used to perform some cleanup for your running PEX file (like closing files, writing data, etc..). You can install the handler at the start of your program and remove it before the program is finished.

If a handler function decides to do anything, it has to return HANDLED. If the handler wants to leave it up to ProBoard, it must return NOT_HANDLED.

This asks for an example I suppose:

int keyhandler( KEY k )
{
if ( k == KEY_ALTJ )
{
printf( "\7\rHang on %s! I'm shelling to DOS...",
UserFirstName );
MenuFunction( MENU_SHELL, "*N*Q*X*!" );
printf( "I'm back!!\n" );
return HANDLED;
}
else
{
return NOT_HANDLED;
}
}
main( int argc,
char *argv[] )
{
InstallHandler( HANDLER_SYSOPKEY, keyhandler );
ExitTSR(); /* IMPORTANT */
}

So what does it do? It intercepts the sysopkey-function, and checks if the key pressed is Alt-J. If it is, it shells to DOS with swapping ON, and it writes its own messages to the screen. When the sysop returns, the handler returns HANDLED to let ProBoard know that it does not have to process the key. You could use this example in an INIT.PEX file. Is this powerful or what?

void RemoveHandler( int handler, function );

Removes handler number <handler> which has been installed by InstallHandler(). <function> is the pointer to the handler that should be removed.

long MsgNum( int area, long id )

Returns the message number for message 'id', in area 'area'. For Hudson and *.MSG, this is identical to the message id (but DO NOT rely on that). Returns a value < 1 if there is no message number for 'id'.

long MsgId( int area, long n )

Returns the message id for message number 'n', in area 'area'. For Hudson and *.MSG, this is identical to the message number (but DO NOT rely on that). Returns a value < 1 if there is no message number 'n'.

long HighMsg( int area )

Returns the message id of the last message in the given area. Note: if the lastread pointer is higher than what this function returns, DO NOT use FirstMessage()! The FirstMessage() function does not support reading past the end of the area. (if you know what I mean

long NumMsgs( int area )

Returns the total number of active messages in the given area.

void LocalDisplay( bool showlocal )

Enables/Disables local echo of text. A parameter of TRUE means “enable local display”. FALSE means “disable local display”. See _GRAPH.CPP for an example.

void RemoteDisplay( bool showremote )

Enables/Disables remote echo of text. A parameter of TRUE means “enable remote display”. FALSE means “disable remote display”. See _GRAPH.CPP for an example.

bool RIP()

Returns TRUE if RIP was detected and enabled.
FALSE if not...

void ShowRIPscrip( char *name )

This will send a RIP file located in the RIP directory. No file extension should be given. (.RIP is assumed) The file will not be shown on the local screen.

void ResetInactivity( void )

Resets the internal inactivity timeout counter. This function can be used when returning from a shell or after a time-consuming function has been called. It will prevent the user from being logged off because of inactivity.

bool AddTaggedFile( TAGGED_FILE *tag )

Adds a file to the internal list of tagged files.

Returns TRUE if the was successfully added.
FALSE if the file was already tagged.

bool RemoveTaggedFile( TAGGED_FILE *tag )

Removes a file from the internal list of tagged files. Returns TRUE if the tagged file was found and deleted from the list, or FALSE if the tagged file was not in the list.

void ClearTaggedFiles( void )

Clears the internal list of tagged files (all tags are removed).

bool IsTagged( TAGGED_FILE *tag )

Returns TRUE if the given file is in the internal list of tagged files,
FALSE if not.

int GetTaggedFiles( TAGGED_FILE *tagarray, int maxitems )

Fills the given array <tagarray> with all the files in the internal list of tagged files (up to a maximum of <maxitems>). This function returns the number of tagged files copied to the array <tagarray> (⇐ maxitems).

bool PutTaggedFiles( TAGGED_FILE *tagarray, int nitems )

Fills the internal list of tagged files with the files in the given array <tagarray>. <nitems> is the number of items in the array.

Returns TRUE on success
FALSE on error

Global ProBoard Variables

You have access to some important ProBoard system variables through global variables defined in PB_SDK.H.

word PBVersion;

The version number of ProBoard. The high byte is the major version number (eg. 1). The low byte is the minor version number in hex (eg. 0x30). So if you're using ProBoard v1.30, PBVersion will be set to 0x0130 .

word Beta;

The beta version number of ProBoard. If this number is 0xFFFF, it means that the release version is running. Beta numbers start from 1.

For example, when running ProBoard 1.40 Beta/19, PBVersion will be set to 0x0140, and Beta will be set to 19.

long BaudRate

The current bps rate of the caller. 0 means local.

USER_REC *CurUser;

Pointer to the current user record. You can change any of the field values in the record, but this will not result in any immediate action by ProBoard. For example, if you change the user's level, ProBoard will not know that you changed it, so you will have to tell it by calling AdjustTime();

Check the file PB_SDK.H for a description of the USER_REC structure.

int UserRecNr;

The record number of the current user's record in the file USERS.BBS, starting from 0. This value cannot be changed.

int NumLimits;

The number of user levels defined in ProCFG. You can access the limit-values through the global array 'Limits'. This value cannot be changed.

LIMIT *Limits;

Is an array of all user levels defined, with download and time limits. Check the file PB_SDK.H for information on the LIMIT structure.

You are not allowed to change any values! (A good compiler should generate an error or warning if you try to do so)

char *LoginDate;

char *LoginTime;

This is the login date & time of the current user.

LoginDate[0] : Day portion of login date
LoginDate[1] : Month portion of login date
LoginDate[2] : Year portion of login date (00-99)
LoginTime[0] : Hour portion of login time
LoginTime[1] : Minute portion of login time
LoginTime[2] : Second portion of login time

bool NetEntered;

bool EchoEntered;

These READ-ONLY variables tell you if netmail and/or echomail has been entered during this session.

int NumUsers;

This READ-ONLY variable is the number of users currently available in the file USERS.BBS.

int NodeNumber;

This READ-ONLY variable is the current node number.

char *CurMenu;

char *UserFirstname;

char *PrevUser;

char *StartupPath;

char *SysPath;

char *PageReason;

CurMenu : Current menu name
UserFirstName : First name of current user
PrevUser : Name of previous user
StartupPath : Name of the directory where ProBoard was started from
(with trailing '\')
SysPath : Name of the ProBoard system directory (with trailing '\')
PageReason : Reason for paging the sysop (as entered by the user)

These are READ-ONLY strings! (except PageReason)

word *PageCount;

POINTER to the number of sysop pages done by the user. This value can be changed by changing the unsigned integer pointed to by 'PageCount'.

CONFIG *Config;

A pointer to the current ProBoard configuration structure. See the file PB_SDK.H for a description of the CONFIG structure.

Special-purpose PEX-files

Several pex-files will be loaded automatically (if present). They perform certain actions like edit a message, set up handlers, etc.

INIT.PEX : Will be loaded and executed before any I/O has been
done. Use this to set up any handlers (sysopkey
handlers, ...)
INIT_1.PEX -
INIT_9.PEX : Is the same as INIT.PEX, but will be loaded in the
order of the numbers. So you can have up to 10
initialization pex-files.
_LOGIN.PEX : Is run instead of the normal login procedure. See
the section explaining this PEX for more information
LOGIN.PEX : No longer supported!
BIRTHDAY.PEX : Is run after showing NEWS.ANS/ASC if today is the
user's birthday.
NEWUSER.PEX : Is run before the file NEWUSER.A?? is shown.
NEWUSER1.PEX : Is run before the file NEWUSER1.A?? is shown.
NEWUSER2.PEX : Is run before the file NEWUSER2.ANS/ASC is shown.
WELCOME.PEX : Is run before the file WELCOME.ANS/ASC is shown
WELCOMEx.PEX : Is run before the file WELCOMEx.ANS/ASC is shown
(x = 1 to 9)
SECxx.PEX : Executed when a user with security level xx logs in.
Is run before SECxx.ANS/ASC is shown.
EXPIRED.PEX : Is run before EXPIRED.ANS/ASC is shown, and after a
user's level is lowered because the subscription
date was reached. ProBoard will send one parameter
to this PEX: the original level, before it was
changed by ProBoard.
GOODBYE.PEX : Is run before GOODBYE.ANS is displayed.
GOODBYE2.PEX : Is run after GOODBYE.ANS is displayed.
MSGED.PEX : Is a replacement of the built-in message editor. It
will be executed with no parameters. The message
that you create has to be written to a file called
MSGTMP. ProBoard will then read this file and
create a message from it. To let ProBoard know that
the user has aborted a message, delete MSGTMP.
FSED.PEX : Is similar to MSGED.PEX, but will be executed if the
user has selected the fullsrceen editor. It works
the same way as MSGED.PEX, but ProBoard will create
a MSGTMP file with the original message if a user is
replying to a message.

Using the _LOGIN PEX

By writing a _LOGIN.PEX, ProBoard allows you to replace the normal login procedure (not including the new user procedure) with your own. It is the PEX's responsibility to check for validity of the name entered and to do password checking!

Once you determined the record number of the user, you have to call the function SetUser() with the record number as parameter, and exit the PEX immediately.

If the user is not in the user database yet, you should exit without calling SetUser(), and set the name that was entered by the user in a memory region supplied by ProBoard to your PEX as the only parameter. This parameter is a 'dword' in decimal form, so you have to convert it to a pointer using the following procedure:

/*----------------------------*/
char *pName;
dword dwName = 0;
char *s;
for ( s = argv[ 1 ]; *s; s++ )
{
dwName = l_mul( dwName, 10L ) + (dword) ( *s - '0' );
}
pName = (char *) dwName;
/*----------------------------*/