Versions Compared

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.

The Galacticomm Messaging Engine

The E-mail and Forums messaging system is divided into low-level and user interface subsections. The low-level section handles the details of storing and retrieving messages, forum management, access, credit charges, importing and exporting messages, etc. It is referred to as the Galacticomm Messaging Engine or GME.

The engine provides an API for messaging functions. The purpose of this API is to isolate developers from the details of the low-level architecture, provide a standard method for using the messaging system, increase system efficiency by cycling intensive tasks, and ensure backward compatibility for future messaging system enhancements. All functions and variables in this API are declared in the file GME.H. In order to use this API, #include "gme.h" in your source files, and link to GMEIMP.LIB.

Access and Credit Charges

Most messaging access restrictions and credit charges are applied by GME. It is also possible to circumvent these restrictions in many cases, particularly when writing messages.

Backwards Compatibility

While the vast majority of the old messaging system (for The Major BBS Version 6) can no longer be supported, a small suite of backward compatible functions are provided. These functions mimic the only previously existing semblance of an API: sendmsg(), sigtpc(), saxxok(), uidxst(), and the msgbyts variable.

Fundamental Architecture

GME Requests

Simple processes can usually be handled by a single function call. However, many messaging tasks are complex processes requiring multiple function calls and/or cycles to complete. To achieve this functionality, a request system is used.

...

void
dosomething(void)                  /* process a GME request                */
{
     int status;

     switch (status=gmefunc(mywrkbuf,myparm1,myparm2,...)) {
     case GMEAGAIN:
          /* do a cycle then call dosomething() again */
          break;
     default:
          if (status > GMEAGAIN) {
               /* everything's OK */
          }
          else {
               /* an error occurred */
          }
          break;
     }
}

...

GME Callbacks

...

Many things can be occurring while a GME function is being cycled (especially when writing a message, see page 203). To allow the caller to track the progress of particularly complex requests, a callback mechanism is provided. A callback handler may be associated with each (initialized) work area using the following function call:

...

Since callbacks occur while the engine is processing a request, they should do very little processing of their own — nothing more intensive than a prfmsg() and outprf() or a senddpk() should be done (be sure to do a rstmbk(), of course). In particular, you should never kick off another GME request from within a callback handler.

Addresses

Routing of messages when writing, copying, or forwarding is governed by two parameters: the forum ID and the address. For forum messages, the forum ID is the primary determining factor of where the message goes, and the address is far less important. However, for e-mail messages, the address is the determining factor of where the message goes.

...

Exporters and distribution lists are discussed in detail in later sections.

Forum Address Extension

Applies to: WG2+

An extension has been added to the forum address address type to allow users to write or forward messages to forums directed to a specific user (rather than ** ALL **). For the user this is quite simple, just add a space followed by the user-ID or user address to direct the message to after the forum name, like so:

...

Applies to: WG3.x

const CHAR * vs CHAR * hazard. In WG3.2 the GME read-only string results are const: getfnm, getftpc, tpcfnm, extAdrForNam, udlnam, ulname, dlname, accstr, gmexinf, exphlp, expasp return const CHAR * (GME.H:841,845,849,989,1085,1524,1528,1855,744,1926,1891) and the walkers getdefp, fiddefp, seqdefp, nxtdefp, prvdefp, tagmsg, expinf return const struct ...* (GME.H:1199-1235,1632,1922). The prototypes printed in this chapter show the WG2 char * / struct x * returns. Receive the result in a const CHAR *, or copy before editing; code that modified a returned fordef or message in place must copy it first. Every GME.H function also names its work area VOID *pWork (WG2 workb). See chapter 28.

Messages

Messages consist of a header part and a text or body part. The message header is a structure that contains all the fields necessary for proper control and routing of the message, and other fields describing the message. The header structure is as follows:

...

unsigned                           /*   returns max message text length    */
txtlen(void);                      /* init__ callable get-text-length     */

...

Message Pointers

...

There is a special type of message that is used strictly within the engine. It consists of just the header; the body is replaced by a special pointer that points to another message on the system. These are referred to as message pointers.

...

Regular message pointers cannot be modified (no error code is returned, but the changes do not take effect), so the sender cannot change the individual messages sent to a distribution list. However, the original message can be modified, and any changes to the text will be reflected in all the individual messages.

Error Notification Messages

Applies to: WG2+

If it is necessary to deliver a message that receives no special processing (usually an error message of some kind), you can set the following flag in the message header flags:

...

Right now, this flag only disables auto-forwarding. There may be other special processing added later that it disables.

Application-Defined Information

Applies to: WG2+

It is now possible to store and retrieve application-defined information associated with individual messages. This information is:

...

  • GMEAGAIN Do a cycle, then call gmeModAppInfo() again.
  • GMEOK The application-defined information was updated successfully.
  • GMENFND The message specified in the read context no longer exists.
  • GMEERR An I/O error occurred while updating the information.
Forums

The configuration information for forums is stored in a forum definition structure. This structure exists in two distinct forms: an on-disk format and an in-memory format. In addition to the obvious distinction, the two formats are used for different purposes. The on-disk format is used when creating a forum or getting “all info” about the forum. The in-memory format is used in all other contexts.

...

The rest of the info field is used for a long description/help message. This is a nul-terminated string for Sysops to provide additional information on a forum that they think would be useful to their users. This text is displayed when a C/S user requests details on a forum and when a terminal-mode user requests help from the main Forums menu. The length of this text is limited to MAXFDV-necho*MAXADR.

GME Initialization

Most initialization of GME is handled internally. However, there is some per-user information maintained by GME that must be initialized when a user logs on and closed when the user hangs up. These functions are as follows:

...

Applies to: WG2+

Header check (GME.H, GMEOFF.H): init__galme() is declared in GME.H. In WG1 GMEOFF.H the offline initializer was the function iniogme(); in WG2 GMEOFF.H it is #define iniogme init__galme, so existing offline code that calls iniogme() still compiles. clsogme(BOOL updfors) is unchanged.

System ID

Applies to: WG2+

The following function can be used to get the GME system ID:

long
gmeSysID(void); /* get current GME System-ID */

Sending Messages

Sending of messages is divided into two fundamentally different types:

...

messages sent on behalf of a user (e.g., Joe writes a message to Sysop)messages sent by processes (e.g., a Shopping Mall product sending a “Thank you for buying something” message) Sending a message is a multi-step process involving access and credit checks (when sending from a user), preparation of the message packet itself, and cycling the sending of the message. Both e-mail and forum messages use the same send-message functions.

Validation

To send a message on behalf of a user, you must first initialize a work area that will be used throughout the send-message request. Next, the address to which the message is to be sent and any features (e.g., attachments, return receipts, etc.) must be validated. The validation process checks whether the address to send to exists (or a given feature is available) and whether the user sending the message has enough access and credits to send the message (or use a particular feature).

...

This function will return VALYES if the user has access and enough credits to write e-mail, VALACC if the user doesn’t have access to write e-mail, or VALCRD if the user doesn’t have enough credits. As with the valxxx() functions, if the return code is VALCRD, the user does have access.

Forming the Message Packet

The message packet consists of the filled-out message header, message body text, file attachment (if any), and cc: address list (if any). This entire packet must be completed before the message can be sent.

...

You may use the above validation functions to check the cc: addresses but, if you do, you must not use the same work area to check a cc: address as you are using for the message itself.

Sending the Message

Once the message packet is complete, the message is sent by calling:

...

EVTCPYD Finished copying file attachment. gmexinf() returns the path and filename copied to.

Sending a Message From a Process

If you need to send a message that is not from a specific user (for example, a game module that sends a “Congratulations! You won last week’s lotto drawing...” message), you can use the following function:

...

You should avoid using simpsnd() whenever possible because it is much less efficient than gsndmsg() and there is a greater possibility that messages sent using simpsnd() will get “lost in transit” due to a system crash.

Reading Messages

Reading messages is done as an ongoing request. You set up a context in which you will read messages, then you can read multiple messages within that context. The work area is initialized once, and does not have to be closed or re-initialized when changing contexts. Both E-mail and Forums use the same function calls to read messages.

Setting the Context

The read context consists of the User-ID for whom the messages are being read, the current forum ID, message ID, thread ID, and message sequence.

...

void
thrctx(                            /* change thread of read context        */
void *workb,                       /*   work area in use                   */
long thrid);                       /*   thread ID to change to             */
Reading Messages

Once the read context has been initialized, messages can be read using several different functions. All of these functions return GME status codes and may require cycling. A special property of these functions is that the buffer the message is read into is only required on the last cycle. So a temporary buffer (like vdatmp) can be used.

...

Note: the msg and text buffers are not altered by the read-message functions unless a message is found. And as always, other error codes may be added later.

Formatted Text Messages

Applies to: WG2+

One of the major new features of the Worldgroup Major BBS mail system is the ability to send messages with formatting in the body text (fonts, colors, variable margins and tabs, etc.).

...

Applies to: WG2+

Header check (GME.H, GMELOC.H): the read direction codes RDLEGT, RDLTGE, RDGELT, RDGTLE, RDNEXT, RDPREV and RDEXCT now live in GME.H. The nearmsg() "style" codes shown above (LEGT, LTGE, GELT, GTLE) are still defined, but as aliases: #define LEGT RDLEGT etc., with the same values 0-3. The RD* values were renumbered in WG2: RDLEGT 3->0, RDLTGE 4->1, RDGELT 5->2, RDGTLE 6->3, RDNEXT 1->4, RDPREV 2->5, RDEXCT 0->6. Code that hard-coded the old numbers, or was compiled against the WG1 headers, must be rebuilt.

Reading by Global ID

Applies to: WG2+

The following function can be used to read a message given its global ID:

...

  • GMEAGAIN Do a cycle then call gmeGReadGlob() again.
  • GMEOK Found the requested message.
  • GMEERR The read context was not correctly initialized, or the forum ID in the read context is EMLID.
  • GMENFND Requested message could not be found.
After Reading a Message

After the user has read a message, the message should be marked as having been read. When a message is marked read, any per-message read charges are deducted from the user’s account, the highest message read in the current forum is updated if necessary, and return receipts are generated if necessary.

...

One thing to note is that this function will clear the return-receipt-requested flag (RECREQ) of the message after generating a return receipt. So if you need to know whether a return receipt was requested after calling markread(), you will need to save that information in your own format and not rely on the flags field of the message header.

While Reading Messages

Download Attachment

Since access restrictions and credit charges apply when downloading attachments, GME provides a set of functions to manage access, credit charges, and auditing attachment downloads. These functions can be used to tag an attachment then download it later. The actual transfer is not handled by GME: if terminal mode, download it via the File Transfer Service (page 169); if C/S mode, download it as a file dynapak (Agent Developer’s Guide).

...

unsigned
forintg(                           /* what's the forum ID associated       */
char *tag);                        /*   with this tag?                     */
Reply to Message

To reply to a message, the read context must be initialized and the message must be read. After reading the message, the process is very similar to writing a new message. The message packet must be formed and validated using the same functions, and the same fields in the message header must be filled in.

...

The arguments to this function have the same meaning and requirements as the arguments to sendmsg(). The status codes returned are the same as those returned by sendmsg(). When reply() finishes, it closes the work area, so you must re-initialize the work area and the read context before reading more messages.

Copy Message

To copy a message, you must initialize the read context and read the message. Then the address to which the message is to be copied (and any features associated with the message, e.g. file attachments) must be validated.

...

GMENCFL The address specified was a distribution list. Messages can not be copied to a distribution list.

Forward Message

Forwarding a message is very similar to copying a message. You first initialize the read context and read the message. Then validate the destination and call the forward-message function. The main difference is that special validation routines are provided for forwarding:

...

Like copymsg(), this function requires cycling, does not close the work area when finished, the msg and text buffers no longer contain the original message, and the same status codes are returned.

Delete Message

To delete a message, initialize the read context then call:

...

GMENDEL The message cannot be deleted (the NODEL flag is set).

Modify Message

To modify a message, initialize the read context, fill in the new topic (in the message header) and text, then call:

...

Note: message pointers that are not true copies of another message (see page 199) cannot be modified. The modmsg() function will return GMEOK, but the changes will not take effect.

Approve Attachment

To approve an attachment to a forum message, you must first read the message, then call:

...

This function currently does not require cycling, but may in the future.

Exempt Message

To exempt a forum message from auto-delete, first read the message, then call:

...

This function currently does not require cycling, but may in the future.

Thread Information

To get information about the thread a message belongs to, initialize the read context (be sure to initialize the thread ID context either explicitly by using inictx() or by reading a message) then call:

...

This function may require cycling.

Forum Information

A wide variety of information about forums is available. You can retrieve this information all at once, or just the bits you are most interested in.

General Information

One of the most basic pieces of information about Forums is:

...

void
getdesc(                           /* copy forum's desc into work buffer   */
unsigned forum,                    /*   forum ID to get                    */
char *desc);                       /*   pointer to work buffer             */
Access Information

An important subset of forum information is user access. This information is stored both in the forum definition (page 200) and in each user’s quickscan record (page 238).

...

It returns a string containing the English name of each access level: "Zero", "Read", "Download", "Write", "Upload", "Co-Op", "Forum-Op", "Sysop", or "<unassigned>" for NOTSET.

Forum Management

Forum management operations are performed by the Forum-Op or Sysop. These operations include creating, editing and deleting forums, and setting user access. Forum management also includes copying, forwarding, modifying, deleting and exempting messages, and approving attachments, but these operations are discussed in the “While Reading Messages” section, above.

Forum Definition Management

To create a forum, you must first fill in all of the fields of an on-disk format forum definition structure. The default values for most of the forum definition fields, as configured by the Sysop, are declared in GME.H:

...

One thing to note about deleting forums is that the forum definition and messages are not actually deleted when you call this function. The forum definition is removed from memory (so the messages can no longer be accessed either) and marked “deleted” on disk, but the definition record and messages are not actually deleted from disk until the next “deleted forum cleanup” occurs.

User Access Management

Two utilities are provided to manage a user’s forum access levels.

...

If there is not enough room in the destination user’s quickscan record to add all the new forums, no error code is returned, but not all the access levels will be copied.

Generic Functions

Applies to: WG2+

In Worldgroup 1.0x, there were many functions (such as creating or editing forums) that required a current user and/or applied access and credit checks. There are now generic versions of most of these functions, that do not require a current user and do no access or credit checks. In general, these functions take the same input parameters and return the same status codes (with the exception of GMEACC and GMECRD).

...

int                     /*   returns standard GME status codes  */
gmeGForward(            /* forward a message (not user-specific)*/
void *workb,            /*   GME work space (provided by caller)*/
BOOL delorig,           /*   delete original (forward vs. copy) */
struct message *msg,    /*   message header buffer              */
char *text);            /*   message text buffer                */

Quickscan

The quickscan configuration record (henceforth referred to as the qscfg) is the repository for most per-user information in E-mail and Forums. Its structure is as follows:

#define MAXSKWD  80                /* size of scan keyword string          */

struct qscfg {                     /* quickscan/config per-user data       */
     char userid[UIDSIZ];          /*   master key for lookups             */
     char fwdee[MAXADR];           /*   auto-forwardee for E-mail (if any) */
     unsigned fwdate;              /*   date that forwardee was chosen     */
     char kwds[MAXSKWD];           /*   quickscan keywords                 */
     unsigned curfor;              /*   current forum ID                   */
     int nforums;                  /*   number of forums in quickscan      */
     int flags;                    /*   preference and quickscan flags     */
     long stmsg;                   /*   quickscan starting message ID      */
     char spare[26];               /*   spare space                        */
     char accmsg[1];               /*   start of variable-len accmsg stuff */
};                                 /*   2 arrays: forumID+msgID, acclvl    */
                                   /*   msgID > 0 == "real" quickscan forum*/
User Preferences

One of the many bits of per-user information stored in the qscfg is the user’s personal preferences. These preferences primarily affect the user interface (and the terminal-mode user interface at that), but are stored and maintained by GME. The individual preferences are stored in the flags field of the qscfg as follows:

...

The preferences may be set by directly manipulating a user’s qscfg, but one general rule should be followed: when setting the “always” flag of an “ever/always” pair (e.g., P4NEWM/GORTIN, MSGQUO/ALWQUO, and CFWCMT/ALWCMT), be sure to set the “ever” flag as well.

Auto-Forwardee

The fwdee field of the qscfg specifies an address to which any e-mail addressed to the user will be forwarded. You should use the following function to set the auto-forwardee:

...

This function sets both the fwdee and fwdate fields of the qscfg. It will return VALYES if the specified forwardee is ok, VALNO if the auto-forward address is too long or is invalid (forum addresses and distribution lists are not considered valid auto-forward addresses), or VALACC if the user doesn’t have access to auto-forward to the specified address. The auto-forwardee can be cleared by passing an empty string as newfwde.

Per-Forum Information

The primary purpose of the qscfg is to record per-forum information for each user. The information stored per forum is the access level, the highest message read in the forum, and whether or not the forum is included in the user’s “quickscan” of forums. This per-forum information is stored in the variable-length accmsg field of the qscfg structure.

...

Again, setac() generally should not be used.

Quickscan Configuration

Finally, the use for the qscfg from which its name is derived is to quickly scan forum messages. This lets a user read messages in multiple forums without manually selecting each forum. The quickscan is traditionally used to read new messages in forums of interest. Our implementation also allows the user to take advantage of the full power of the One-Time Search service (page 245). In addition to the per-forum information, which specifies what forums are included in the quickscan, the following qscfg fields are used to save the user’s quickscan: kwds, stmsg, and the NEWMSG, WATONL, TOMEONL and FRMEONL flags.

...

Note: This function puts forums into the scan buffer in sequence-ID order, not alphabetical order (the two do not necessarily correspond). However, C/S-mode users require that the forums be in alphabetical order, so if this function is used for C/S-mode users, the forums must be re-sorted into alphabetical order.

One-Time Search

To search for messages in multiple forums, using keywords and other criteria, a one-time search (a.k.a. one-time scan) system is provided. To perform a search, first set up a buffer containing the search criteria to be used. Then initialize a work area, associate the search criteria buffer with the work area, and initialize the read context of the work area with the FSQSCN sequence. That work area can then be used to read messages selected by the search criteria.

...

It is important to note that the function nearmsg() does not support one-time searches. If you call nearmsg() with FSQSCN as the read context sequence, it will return GMEERR.

Distribution Lists

Distribution lists are an easy way to send the same message to a large group of people without having to type their addresses in every time you want to send a message to that group. Any type of address can be put in a list except for another list. A distribution list name has a unique format that distinguishes it from other types of addresses. It is either a ! or @ character followed by up to eight letters or numbers. Three types of distribution lists are supported by GME: mass mailing lists, personal lists, and Sysop-defined lists.

The mass mailing list is called !MASS. If a user writes a message to !MASS, a copy of the message will be sent to every User-ID on the system. This list is not configurable and there are no special functions or variables for dealing with it.

Personal Lists

Every User-ID on a system has a personal distribution list that can contain up to 40 addresses. When a user addresses a message to !QUICK, a copy of the message is sent to every address in their personal list.

...

void
savqik(                            /* save a !QUICK list to disk           */
struct qikdat *qikbuf);            /*   pointer to !QUICK buffer           */
Sysop Lists

Sysop-defined distribution lists have names beginning with an @ character. They are configurable (unlike !MASS) and available to the public (unlike individual !QUICK lists). Each list has its own key required for use and its own surcharge for use. Sysop lists are stored in text files with a filename of the list name (less the preceding @) and the extension .DIS, in the directory specified in the GALME.MSG CNF option DLSTPTH.

...

GMENFND The specified list does not exist.

New Distribution List File

Applies to: WG2+

It is now possible to modify a sysop-defined distribution list by supplying an entirely new list file. It is not possible to simply copy in a new file since they are read at startup and the access and credit information is stored in memory.

...

The lstnam argument is the name of the list being replaced (including preceding @), and the lstfil argument is the path and filename of the new list file (should be the return value from udlnam()).

Importers and Exporters

Messages addressed to (and sent by) users who are signed up on the local system are addressed by User-ID. The messaging engine exchanges messages with other mail systems using importers and exporters. These are special modules responsible for converting messages between Worldgroupthe Major BBS's format and other mail systems' formats. Messages are transferred between importers/exporters and the engine through a standard interface.

Exporters

Messages sent from the local system to a remote system are handled by exporters. Each exporter is identified by a unique address prefix — two or three alphanumeric characters (e.g., IN, MHS) that indicate which exporter should be used to send a given message.

...

*While it’s possible for a Worldgroup Major BBS server to verify the existence of a local address since that’s one and the same as a local User-ID, it is usually not possible to verify the existence of a remote address. There is no master User-ID list for the Internet, for example. The best that can be done is to verify the format of the address.

...

There are no provisions for cycling this vector, so it should do whatever processing it needs to do expeditiously. The att parameter used is an exact copy of what the attspc vector returned to the engine. Finally, the sndmsg vector should return one of the standard GME status codes to indicate the result of the operation. At a minimum, GMEOK should be used to indicate success and GMEERR to indicate failure.

...

Formatted Text, Application-Defined Information and Exporters

...

Applies to: WG2+

To maintain backward compatibility with existing exporters, messages with formatted body text will be automatically converted to plain ASCII text before being submitted to the exporter’s sndmsg vector unless the exporter explicitly indicates to the GME that it can handle formatted text. To indicate this capability, simply set the following flag in the exporter flags field:

...

Any application-defined information associated with a message is also available to exporters, whether the message is new or is being forwarded. Exporters can use gmeGetAppInfo() within their sndmsg() vectors to retrieve the information.

...

Auto-forwarding and Exporters

...

Applies to: WG2+

A couple of minor changes have been made to improve the exporter interface when messages are auto-forwarded.

...

Before, when a message was imported, then auto-forwarded back out to an exporter, the prefix on the from address was stripped off. This did not occur, however, when the message was manually forwarded to an exporter. Now, whenever a message with an exported from address is sent through an exporter, it will always have the prefix on the from address. This gives exporters all the information they need to route any replies to the message back through the Worldgroup Major BBS system, to the original sender.

Importers

An importer is simpler from the engine’s point of view, but a bit more complex to implement than an exporter.

...

GMENOAT The file attached to the message could not be imported for some reason (file not found, couldn’t rename, I/O error, etc.).

Hookable Notifications

Applies to: WG2+

In order to facilitate synchronization between the GME and outside processes, a system of hookable notifications has been implemented. To set a hook, simply call the following function:

...

Applies to: WG2+

Header check (GME.H, GMEUTL.H): GME.H also defines GMEHOOK_NONE (0, "no hook set (internal use only)") and the update-type codes UPDMSG_APINF, UPDMSG_APRV, UPDMSG_EXMT, UPDMSG_MODFY and UPDMSG_REPLY, all currently 0, consistent with "Currently it is always zero." Internally the engine keeps the hooks in struct gmehook (GMEUTL.H: hooktype, hookfunc) and dispatches with notnwm(), notnwml(), notnwf(), notudm(), notmdf(), notdlm(), notdlml(), notdlf(), notdlfl() and nexthook(); these are engine internals, not API.

Conflict Checking

Because all information about a GME request is stored in the work area, and the work area is owned by the caller, not the engine, GME relies on a system of cooperative conflict checking to avoid problems. Modules that use GME to read or write messages (including importers) should register conflict checking functions. Before a message or forum is deleted or modified, GME polls all registered conflict checking functions to see if anyone is currently using that message or forum. If anyone is using it, GME rejects the modify or delete request.

...

Note: You should always pass a valid (though not necessarily initialized) work area to this function.

GALTEXT Formatted Text Handler

Applies to: WG2+

Formatted text is now supported in e-mail and forum message body text. However, some interfaces cannot properly display such text. To facilitate the conversion of formatted text from one format to another, an extensible generic formatted text handling API has been developed.

...

All structures and functions used for this process are declared in galtext.h and exported in galtext.lib.

Registering Format Handlers

To provide a new format handler, you must provide a defined set of functions, fill in a certain structure, and register the new text handler with GALTEXT. The structure to fill in is as follows:

...

Note that there is currently no standard way to replace an existing format handler and that no attempt is made to detect collisions between format handlers (handlers with the same name or for the same format).

Using the Formatted Text Handler

The purpose of GALTEXT is to provide processes with a single mechanism for dealing with formatted text, regardless what format is used. The four function vectors of the format handler structure are genericized into the following functions.

...

Applies to: WG2+

Header check (GALTEXT.H, new in WG2): the prototypes and the struct fmthlr agree with the text above. GALTEXT.H also declares RTFSTKSZ (10, RTF reader stack size), int nfmthlr(void) (number of registered format handlers) and struct fmthlr **fharr(void) (array of pointers to the handlers); the addendum does not describe these.

Changes to Internal GME Routines and Structures (WG1 to WG2)

Applies to: WG3.x

Header check (3.2): of the internals listed here only the entry points in GME.H remain public. gmework and gmehook are removed (callers pass an opaque VOID *pWork; GMEWRKSZ is 518 under GCDOS and 1536 otherwise, GME.H:38-42: use the macro, never a literal size), and cscflchk, hdlntfy, nextcc, sndexp, updmsg, uplinf, clsogme, evt and the notnwm/notudm... hooks are not declared in WGDEV/INC. iniogme is init__galme as in WG2. hdlfmtxt (GMEUTL.H) is likewise gone; the STATIC in the list below is the WG2 keyword macro (chapter 2).

...