APPENDIX

B. System Identifiers (SID)

C. The Forward Protocols

D. Presence of Letter D in SID

E. Compressed Forward Protocol Description

 F6FBB                          FC1GHV
 ----------------------------------------------------------------

 Connects FC1GHV

                                Connected

                                [FBB-5.11-FHM$]
                                Bienvenue a Poitiers, Jean-Paul.
                                >

 [FBB-5.11-FHM$]     (F6FBB has the F flag in the SID)
 FB P F6FBB FC1GHV.FFPC.FRA.EU FC1MVP 24657_F6FBB 1345
 FB P FC1CDC F6ABJ F6AXV 24643_F6FBB 5346
 FB B F6FBB FRA FBB 22_456_F6FBB 8548
 F> HH

                                FS +-+ (accepts the 1st and the 3rd).

 Title 1st message
 Text 1st message
 ......
 ^Z
 Title 3rd message
 Text 3rd message
 ......
 ^Z

                                 FB P FC1GHV F6FBB F6FBB 2734_FC1GHV 234
                                 FB B FC1GHV F6FBB FC1CDC 2745_FC1GHV 3524
                                 F> HH

 FS -- (Don't need them, and send immediately the proposal).
 FB P FC1CDC F6ABJ F6AXV 24754_F6FBB 345
 F> HH

                                 FS + (Accepts the message)

 Title message
 Text message
 ......
 ^Z

                                 FF (no more message)

 FB B F6FBB TEST FRA 24654_F6FBB 145
 F> HH

                                 FS + (Accepts the message)

 Title message
 Text message
 ......
 ^Z

                                 FF (still no message)

 FQ (No more message)

 Disconnection of the link.

 FD B DL8HBS ALL ATARI 564323DL8HBS 3456 60 
 ^  ^ ^      ^    ^     ^            ^   ^ 
 I  I I      I    I     I            I   Lifetime (optional)
 I  I I      I    I     Bulletin-ID  Size in Bytes of unpacked 
 I  I I      I    I                                   file
 I  I I      I    board (or callsign)
 I  I I      I
 I  I I       @mbx-field
 I  I  Sender
 I  Type, [B]ulletin or [P]rivate or [A]cknowledge or N[T]S
 I
 Flag

static char checksum(char *s)
{
	char	chck = 0;

	while (*s)
	{
		chck += *s;
		++s;
	}
	return(chck);
}


send_proposals(void)
{
	char	chck = 0;
	int	...

	for (p=0 ....
	{
		sprintf(s, "F%c %c %s %s %s %s %ld\r", ...
		chck += checksum(s);
		out_ascii(s);
	}
	sprintf(s, "F> %02X\r", (-chck) & 0xff) ;
	out_ascii(s);
}

F. The Message Base Format

typedef struct indexstruct {
  uchar header_version;      /* is 20 in this version   */
  Char bulletin_id[13];      /* BID                     */
  Char destination[9];       /* board                   */
  Char originator[7];        /* sender                  */
  Char mbx[41];              /* @mbx                    */
  Char subject[81];          /* subject                 */
  long rxdate;               /* locally received at     */
  long txdate;               /* originally created at   */
  unsigned short lifetime;   /* local liftetime         */
  unsigned short txlifetime; /* original lifetime       */
  Char msgtype;              /* A/B/P/T                 */
  uchar r0;                  /* not to be changed       */
  long start;                /* start position in file  */
  long packsize;             /* packed message size     */
  long size;                 /* unpacked message size   */
  long rxqrg;                /* received on qrg (unused)*/
  Char rxfrom[7];            /* received from bbs       */
  boolean deleted;           /* logically deleted       */
  uchar content_type;        /* content encoding        */
  uchar level;               /* access level            */
  uchar fwdct;               /* forward counter         */
  unsigned short msgflags;   /* msgflags (see MSGFLAGS) */
  long erasetime;            /* erased at               */
  long lastread;             /* last read at            */
  unsigned short readcount;  /* readout counter         */
  Char read_by[141];         /* reader field            */
  uchar erased_by;           /* erased by (see EBFLAGS) */
  Char sendbbs[7];           /* originating bbs         */
  uchar reserved;            /* zeroed in this version  */
  long msgnum;               /* message number          */
  unsigned short r1, r2, r3; /* not to be changed       */
} indexstruct;

/* MSGFLAGS */
#define MSG_SFWAIT      1
#define MSG_PROPOSED    2
#define MSG_SFRX        4
#define MSG_SFTX        8
#define MSG_SFERR       16
#define MSG_SFNOFOUND   32
#define MSG_CUT         64
#define MSG_MINE        128
#define MSG_REJECTED    256
#define MSG_DOUBLE      512
#define MSG_BROADCAST   1024
#define MSG_BROADCAST_RX 2048
#define MSG_OWNHOLD     4096
#define MSG_LOCALHOLD   8192
#define MSG_SFHOLD      16384
#define MSG_OUTDATED    32768

/* bit values for content_type  */
#define PM_HUFF         4    /* LZH compression         */
#define TTEXT           0    /* ASCII mail              */
#define TBIN            32   /* binary mail             */
#define T7PLUS          64   /* 7PLUS mail              */
#define THTML           128  /* HTML mail               */

/* EBFLAGS (erased_by in indexstruct) */
#define EB_NONE         0
#define EB_SENDER       1
#define EB_RECEIVER     2
#define EB_SYSOP        4
#define EB_RSYSOP       5
#define EB_DOUBLESYSOP  6
#define EB_LIFETIME     8
#define EB_SF           16
#define EB_REMOTE       32
#define EB_SFERR        64
#define EB_RETMAIL      66
#define EB_TRANSFER     128

G. The Check List Format

typedef struct boxlogstruct {
  long msgnum;               /* message number          */
  long rxdate;               /* rxdate                  */
  unsigned short idxnr;      /* #nr in index/board      */
  unsigned short lifetime;   /* local lifetime          */
  unsigned short msgflags;   /* msgflags (see MSGFLAGS) */
  long size;                 /* unpacked message size   */
  boolean deleted;           /* logically deleted       */
  Char msgtype;              /* A/B/P/T                 */
  uchar content_type;        /* content encoding        */
  uchar level;               /* access level            */
  Char destination[9];       /* board                   */
  Char obrett[9];            /* original board          */
  Char bulletin_id[13];      /* BID                     */
  Char originator[7];        /* sender                  */
  Char mbx[7];               /* @mbx (shortened)        */
  Char subject[41];          /* subject (shortened)     */
} boxlogstruct;

/* MSGFLAGS */
#define MSG_SFWAIT      1
#define MSG_PROPOSED    2
#define MSG_SFRX        4
#define MSG_SFTX        8
#define MSG_SFERR       16
#define MSG_SFNOFOUND   32
#define MSG_CUT         64
#define MSG_MINE        128
#define MSG_REJECTED    256
#define MSG_DOUBLE      512
#define MSG_BROADCAST   1024
#define MSG_BROADCAST_RX 2048
#define MSG_OWNHOLD     4096
#define MSG_LOCALHOLD   8192
#define MSG_SFHOLD      16384
#define MSG_OUTDATED    32768

/* bit values for content_type  */
#define PM_HUFF         4    /* LZH compression         */
#define TTEXT           0    /* ASCII mail              */
#define TBIN            32   /* binary mail             */
#define T7PLUS          64   /* 7PLUS mail              */
#define THTML           128  /* HTML mail               */

H. The Auto Router Data Base

typedef struct hboxtyp {
  Char call[7];              /* BBS-Call                */
  Char hpath[41];            /* hierarchical path       */
  Char bestvia[7];           /* best rx via             */
  Char rxfrom[7];            /* best path received from */
  Char desc[41];             /* BBS info                */
  long lasttx;               /* last TX date            */
  long msgct;                /* count of messages       */
  long best;                 /* fastest runtime of msg  */
  long average;              /* average runtime of msgs */
  long bytect;               /* count of received bytes */
  long change_date;          /* best path changed at    */
} hboxtyp;

I. The HomeBBS Data Base

typedef struct mybbstyp {
  Char call[7];              /* Call                    */
  Char bbs[7];               /* MyBBS                   */
  long updatetime;           /* last updated at         */
} mybbstyp;

J. The DPBOX Socket Interface Specification

Description of Socket-Interface-Protocol Rev.2



Mark Wahl, DL4YBG
Created: 26.11.94
Last Update: 13.04.96


0. General Layout



Indicator (1 Byte)
Channel   (2 Byte)
Usernr    (2 Byte)
Length    (2 Byte)
Data      (Length Bytes)

1. Commands



1.1 Activate Program


(PR->Program)
On the specified channel the linked program (defined by used socket)
shall be activated (the interface will be opened).
If channel is 0, the activation is started from the operator console
instead of a packet channel.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  NO_USERNR
Length    (2 Byte)
  LEN_SIMPLE + (strlen(callsign) + 1)
Command   (4 Byte)
  CMD_ACTIVATE
Callsign  ((strlen(callsign) + 1) Byte)
  char callsign[]


1.2 Deactivate Program


(PR->Program)
On the specified channel the linked program (defined by used socket)
shall be deactivated (the interface will be closed).

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SIMPLE
Command   (4 Byte)
  CMD_DEACTIVATE


1.3 Connect


(Program->PR)
A free channel shall be used to build up a connection. QRG, Source call, 
Destination call and a connection-build-up-time-out must be specified.
The connection will be build up using xconnect-feature, therefore no
digipeaterpath is allowed.
The user 'usernr' will be informed about the result of the connect,
successful or not.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_CONNECT + (strlen(sourcecall) + 1) + (strlen(destcall) + 1)
Command   (4 Byte)
  CMD_CONNECT
Timeout   (4 Byte)
  int timeout
Qrg       (20 Byte)
  char qrg[20]
Sourcecall (strlen(sourcecall) + 1)
  char sourcecall[]
Destcall (strlen(destcall) + 1)
  char destcall[]


1.4 Disconnect


(Program->PR)
The connection on the specified channel shall be disconnected.

Indicator (2 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SIMPLE
Command   (4 Byte)
  CMD_DISCONNECT


1.5 Finish Program


(Program->PR)
If the program was started directly (using special SSID), the connection
will be disconnected.
Otherwise a reconnection to the last used command processor will occur
(reconnect to terminal/node-software).

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SIMPLE
Command   (4 Byte)
  CMD_FINISH


1.6 Channel Status


(PR->Program)
If the number of frames in the TX-buffer (Program and TNC) has changed
on a channel linked to a program, a channel status message with the
new number of frames in TX-buffer will be sent.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_CSTATUS
Command   (4 Byte)
  CMD_CSTATUS
Number of frames in TX-buffer (4 Bytes)
  int snd_frames
  

1.7 Blocking


(Program->PR, PR->Program)
If blocking is received, the sending side has reached maximum byte count
and is waiting for an unblocking message. Otherwise no data will be
transmitted.
This is a simple handshake to avoid an overrun of the socket.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  NO_USERNR
Length    (2 Byte)
  LEN_SIMPLE
Command   (4 Byte)
  CMD_BLOCK


1.8 Unblocking


(Program->PR, PR->Program)
unblock restarts the transmitter on the other side of the interface.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  NO_USERNR
Length    (2 Byte)
  LEN_SIMPLE
Command   (1 Byte)
  CMD_UNBLOCK


1.9 Sort new mail


(PR->DPBox)
A mail was collected from monitor or during connect with a mailbox.
Pattern is the filename of the used file, Rcall is the callsign of
the mailbox where this file was fetched (or an empty string). Not
used for S&F connects, only for monitoring features.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SIMPLE + (strlen(pattern_) + 1) + (strlen(rcall) + 1)
Command   (4 Byte)
  CMD_SORT_NEW_MAIL
Pattern   ((strlen(pattern_) + 1) Bytes)
  char pattern_[]
Rcall     ((strlen(rcall) + 1) Bytes)
  char rcall[]


1.10 SF Rx EMT


(PR->DPBox)
A mail for folder 'E', 'M' or 'T' was received. These mails consist only
of one line. This line will be sent directly in Eingabe. Not used for
S&F connects, only for monitoring features.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SIMPLE + (strlen(eingabe_) + 1)
Command   (4 Byte)
  CMD_SF_RX_EMT
Eingabe   ((strlen(eingabe_) + 1) Bytes)
  char eingabe_[]


1.11 Connect for Store and Forward


(DPBox->PR)
A free channel shall be used to build up a connection for Store and
Forward. Sourcecall, Destinationcall and a connection-build-up-timeout
must be specified.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  NO_USERNR
Length    (2 Byte)
  LEN_BOXPBOXSF + (strlen(sourcecall) + 1) + (strlen(destcall) + 1)
Command   (4 Byte)
  CMD_BOXPBOXSF
Timeout   (4 Byte)
  int timeout
Sourcecall (strlen(sourcecall) + 1)
  char sourcecall[]
Destcall (strlen(destcall) + 1)
  char destcall[]


1.12 Disconnect


(DPBox->PR)
The connection on the specified channel shall be disconnected.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SIMPLE
Command   (4 Byte)
  CMD_BOXPRDISC


1.13 Abort Store and Forward


(DPBox->PR)
Store and Forward shall be cancelled. If Immediate is not 0, outstanding
TX-Packet must be cancelled, too.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (4 Byte)
  LEN_BOXPABORTSF
Command   (4 Byte)
  CMD_BOXPABORTSF
Immediate (4 Byte)
  int immediate


1.14 Abort Routing


(PR->DPBox)
A Connect command for Store and Forward sent by DPBox (CMD_BOXPBOXSF) was
not successful.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  NO_USERNR
Length    (2 Byte)
  LEN_SIMPLE + (strlen(callsign) + 1)
Command   (4 Byte)
  CMD_ABORT_ROUTING
Callsign  ((strlen(callsign) + 1) Byte)
  char callsign[]


1.15 Start Store and Forward


(PR->DPBox)
A Connect command for Store and Forward sent by DPBox (CMD_BOXPBOXSF) was
successful and S&F can begin.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  NO_USERNR
Length    (2 Byte)
  LEN_SIMPLE + (strlen(callsign) + 1)
Command   (4 Byte)
  CMD_START_SF
Callsign  ((strlen(callsign) + 1) Byte)
  char callsign[]


1.16 Finish Program


(PR->Program)
The Program connected to the socket shall terminate the execution.
This is used to kill daemon-processes.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  NO_USERNR
Length    (2 Byte)
  LEN_SIMPLE
Command   (4 Byte)
  CMD_FINISH_PRG


1.17 Activation Response


(Program->PR)
If a program was activated via CMD_ACTIVATE or CMD_START_SF, the resulting
usernr will be returned in this message. If the usernumber is equal 0,
then the activation was not successful.
In the response string additional information about the activation can
be transferred.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SIMPLE + (strlen(response) + 1)
Command   (4 Byte)
  CMD_FINISH_PRG
Response  ((strlen(response) + 1) Byte)
  char response[]


1.18 AutoBIN-File to Box


(PR->Program)
On the current channel a file was received with AutoBIN-protocol.
Erase defines if the file shall be deleted afterwards, error indicates
a wrong CRC-checksum and buffer contains the filename of the file.
No more supported by DPBOX, DPBOX handles AutoBIN itself.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_ABINFILETOBOX + (strlen(buffer) + 1)
Command   (4 Byte)
  CMD_ABINFILETOBOX
Erase     (4 Byte)
  int erase
Error     (4 Byte)
  int error
Buffer    ((strlen(buffer) + 1) Byte)
  char buffer[]  
  

1.19 Huffman Status


(PR->Program) (Program->PR)
If huffman coding is enabled or disabled this message will inform the other
side about the new status. 1 means huffman coding is active, 0 means
inactive. Huffman encoding/decoding has to be done by PR.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_HUFFSTAT
Command   (4 Byte)
  CMD_HUFFSTAT
Huffstat  (4 Byte)
  int huffstat
  

1.20 Frequency Information


(PR->Program)
With this message all frequencies handled by the PR-program are sent to
the program. This information is used to find the right interface for
S&F by DPBox.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_QRGINFO
Command   (4 Byte)
  CMD_QRGINFO
Frequency  (220 Byte)
  char qrg[MAXQRGS+1][20] (MAXQRGS = 10)
  

1.21 Bulletin-ID query and answer


(PR->DPBox)(DPBox->PR)
With this message the program can query if a mail is already available
in the DPBox by checking the bulletin ID. DPBox will answer in 'Found'
(0: not found, 1: found) and will return the bullid, too. Not used for
S&F connects, only for monitoring features and similar.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_BULLID
Command   (4 Byte)
  CMD_BULLID
Found     (4 Byte)
  int found
Bullid    (13 Byte)
  char bullid[BULLIDLEN+1] (BULLIDLEN = 12)
 

1.22 Start AutoBIN-receive


(DPBox->PR)
This message instructs TNT to prepare AutoBIN reception on the current
channel. The filename of the file to open will be given as parameter
(null-terminated string in buffer).
No more supported by DPBOX, DPBOX handles AutoBIN itself.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SIMPLE + (strlen(buffer) + 1)
Command   (4 Byte)
  CMD_STARTABIN
Buffer    ((strlen(buffer) + 1) Byte)
  char buffer[]  
  

1.23 Update Box-timeout


(PR->DPBox)
During AutoBIN-receive TNT informs DPBox by this message that the user is
still active.
No more supported by DPBOX.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SIMPLE
Command   (4 Byte)
  CMD_BOXTOUCH


1.24 Set Read/write Mode


(DPBox->PR)
This message informs TNT if during a boxconnect the AutoBIN-header shall be
analysed (rwmode = 0) or not (rwmode = 1). 
No more supported by DPBOX, DPBOX handles AutoBIN itself.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SETRWMODE
Command   (4 Byte)
  CMD_SETRWMODE
Rwmode    (4 Byte)
  int rwmode
  

1.25 Box Is Busy


(DPBox->PR)
This message informs TNT if DPBox is busy and connects shall be rejected.
(boxisbusy = 0, connects allowed; boxisbusy = 1, no connects allowed)

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  NO_USERNR
Length    (2 Byte)
  LEN_BOXISBUSY
Command   (4 Byte)
  CMD_BOXISBUSY
Boxisbusy (4 Byte)
  int boxisbusy

  
1.26 Start Box Broadcast


(DPBox->PR)
This message instructs TNT to start a broadcast transmission of a file.
The broadcast-header is contained in a file, the filename of this file is
stored in buffer.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  NO_USERNR
Length    (2 Byte)
  LEN_SIMPLE + (strlen(buffer) + 1)
Command   (4 Byte)
  CMD_STARTBOXBC
Buffer    ((strlen(buffer) + 1) Byte)
  char buffer[]  


1.27 Broadcast Callback


(PR->DPBox)
If the broadcast transmission of a file is finished, DPBox will be informed
by this message. The file is identified by the file_id contained in the
message.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  NO_USERNR
Length    (2 Byte)
  LEN_BCCALLBACK
Command   (4 Byte)
  CMD_BCCALLBACK
File_id   (4 Byte)
  long file_id


1.28 Set Unproto Destination


(DPBox->PR)
This message sets the unproto destination for the following unproto data.
The destination is stored independently for every interface.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  NO_USERNR
Length    (2 Byte)
  LEN_SETUNPROTO + (strlen(buffer) + 1)
Command   (4 Byte)
  CMD_SETUNPROTO
Qrg       (20 Byte)
  char qrg[20]
Address   ((strlen(address) + 1) Byte)
  char address[]  


1.29 Connect Not Successful


(PR->Program)
A connect, initiated by user 'usernr' was not successful.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SIMPLE
Command   (4 Byte)
  CMD_NOSUCCESSCON


1.30 Connect Successful


(PR->Program)
A connect, initiated by user 'usernr' was successful and the link between
the two connects shall be established. The channel of the new connection is
contained in channel.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SIMPLE + (strlen(callsign) + 1)
Command   (4 Byte)
  CMD_SUCCESSCON
Callsign  ((strlen(callsign) + 1) Byte)
  char callsign[]


1.31 TNT-Command


(Program->PR)
This command contains a command string, which shall be parsed and executed
by the TNT command processor. 'channel' is used as channel used for the
command. 'usernr' is the user, which must be informed about the result.
Only used in DPBOX for the TNTCOMM command.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SIMPLE + (strlen(buffer) + 1)
Command   (4 Byte)
  CMD_TNTCOMMAND
Buffer    ((strlen(buffer) + 1) Byte)
  char buffer[]  


1.32 TNT-Response


(PR->Program)
This message contains the response to the command given by CMD_TNTCOMMAND
(1.31 TNT-Command). 'follows' indicates, if other responses to the command
will follow, 'follows' == 0 indicates the last response.
'channel' is the given channel for the command and 'usernr' is the user,
who requested the command.
Only used in DPBOX for the TNTCOMM command.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SIMPLE + (strlen(buffer) + 1)
Command   (4 Byte)
  CMD_TNTRESPONSE
Follows   (4 Byte)
  follows
Buffer    ((strlen(buffer) + 1) Byte)
  char buffer[]  


1.33 Abort Connect


(Program->PR)
A connect request started by 'usernr' shall be aborted.

Indicator (1 Byte)
  IF_COMMAND
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  LEN_SIMPLE
Command   (4 Byte)
  CMD_ABORTCON



2. Data



Indicator (1 Byte)
  IF_DATA
Channel   (2 Byte)
  channel
Usernr    (2 Byte)
  usernr
Length    (2 Byte)
  1 - 256
Data      (Length Bytes)
  char data[]



3. Unproto


The data will be sent to the destination last defined by CMD_SETUNPROTO.

Indicator (1 Byte)
  IF_UNPROTO
Channel   (2 Byte)
  NO_CHANNEL
Usernr    (2 Byte)
  NO_USERNR
Length    (2 Byte)
  1 - 256
Data      (Length Bytes)
  char data[]

#define MAXQRGS 10
#define BULLIDLEN 12
#define LEN_SIMPLE sizeof(int)
#define LEN_CSTATUS (LEN_SIMPLE + sizeof(int))
#define LEN_BOXPBOXSF (LEN_SIMPLE + sizeof(int))
#define LEN_BOXPABORTSF (LEN_SIMPLE + sizeof(int))
#define LEN_HUFFSTAT (LEN_SIMPLE + sizeof(int))
#define LEN_ABINFILETOBOX (LEN_SIMPLE + sizeof(int) + sizeof(int))
#define DAT_QRGINFO (20 * (MAXQRGS + 1))
#define LEN_QRGINFO (LEN_SIMPLE + DAT_QRGINFO)
#define LEN_BULLID (LEN_SIMPLE + sizeof(int) + BULLIDLEN + 1)
#define LEN_SETRWMODE (LEN_SIMPLE + sizeof(int))
#define LEN_BOXISBUSY (LEN_SIMPLE + sizeof(int))
#define LEN_BCCALLBACK (LEN_SIMPLE + sizeof(long))
#define LEN_SETUNPROTO (LEN_SIMPLE + 20)
#define LEN_CONNECT (LEN_SIMPLE + sizeof(int) + 20)
#define LEN_TNTRESPONSE (LEN_SIMPLE + sizeof(int))

/* special definitions */
#define NO_CHANNEL -1
#define NO_USERNR -1

/* states for iface_list.active (0 = inactive) */
#define IF_NOTACTIVE 0
#define IF_ACTIVE 1
#define IF_TRYING 2

/* states of iface_list.indicator and first byte of iface-packet */
#define IF_COMMAND 1
#define IF_DATA 2
#define IF_UNPROTO 3

/* commands if IF_COMMAND */
#define CMD_ACTIVATE 1
#define CMD_DEACTIVATE 2
#define CMD_CONNECT 3
#define CMD_DISCONNECT 4
#define CMD_FINISH 5
#define CMD_CSTATUS 6
#define CMD_BLOCK 7
#define CMD_UNBLOCK 8
#define CMD_SORT_NEW_MAIL 9
#define CMD_SF_RX_EMT 10
#define CMD_BOXPBOXSF 11
#define CMD_BOXPRDISC 12
#define CMD_BOXPABORTSF 13
#define CMD_ABORT_ROUTING 14
#define CMD_START_SF 15
#define CMD_FINISH_PRG 16
#define CMD_ACT_RESP 17
#define CMD_ABINFILETOBOX 18
#define CMD_HUFFSTAT 19
#define CMD_QRGINFO 20
#define CMD_BULLID 21
#define CMD_STARTABIN 22
#define CMD_BOXTOUCH 23
#define CMD_SETRWMODE 24
#define CMD_BOXISBUSY 25
#define CMD_STARTBOXBC 26
#define CMD_BCCALLBACK 27
#define CMD_SETUNPROTO 28
#define CMD_NOSUCCESSCON 29
#define CMD_SUCCESSCON 30
#define CMD_TNTCOMMAND 31
#define CMD_TNTRESPONSE 32
#define CMD_ABORTCON 33

K. The AutoBIN Protocol

#BIN#nnnnn#|ccccc#$dddddddd?#ssss\r
     -----  -----  --------  ----
       !      !       !      file name without path
       !      !       file date and time in 'struct ftime' format (BCC 3.x)
       !      !       in hexadecimal notation (32 bits)
       !      The CRC of the whole file in decimal. Standard CCITT
       !      polynomial.
       file length in decimal bytes.

#OK#ssss#$nnnnn#ccccc\r (3)
    ----  ----- -----
     !      !   CRC of received file fragment
     !      number of bytes in received fragment
     file name without path

/*
 *      crctab calculated by Mark G. Mendel, Network Systems Corporation
 */
unsigned short crctab[256] = {
    0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
    0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
    0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,
    0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,
    0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,
    0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d,
    0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,
    0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,
    0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,
    0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b,
    0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,
    0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,
    0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,
    0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49,
    0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,
    0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,
    0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,
    0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067,
    0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,
    0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,
    0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,
    0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,
    0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,
    0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634,
    0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,
    0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,
    0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,
    0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92,
    0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,
    0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,
    0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,
    0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0
};

/*
 * updcrc macro derived from article Copyright (C) 1986 Stephen Satchell.
 *  NOTE: First argument must be in range 0 to 255.
 *        Second argument is referenced twice.
 *
 * Programmers may incorporate any or all code into their programs,
 * giving proper credit within the source. Publication of the
 * source routines is permitted so long as proper credit is given
 * to Stephen Satchell, Satchell Evaluations and Chuck Forsberg,
 * Omen Technology.
 */
#define updcrc(cp,crc) (crctab[((crc >> 8) & 255)] ^ (crc << 8) ^ cp)

L. Calculating CRCs

/* four different methods of CRCing:

    crc_16 is the CRC16 as used for SMACK KISS (init crc with 0),
    crcfcs is the FCS of AX.25 (init crc with 0xFFFF),
    crcthp is the AutoBIN-CRC (init crc with 0),
      (thp represents TurboHostPacket, the forefather of all german hostmode
       programs, written by DL1BHO in mid-80s)
    crcfbb is the f6fbb-forward-CRC (init crc with 0).

 */

extern void crc_16(uchar Data, unsigned short *crc);
extern void crcfcs(uchar Data, unsigned short *crc);
extern void crcthp(uchar Data, unsigned short *crc);
extern void crcfbb(uchar Data, unsigned short *crc);

#include "crc.h"

typedef unsigned short crctabtype[256];

Static crctabtype crc16_table = {
  0, 0xc0c1, 0xc181, 0x140, 0xc301, 0x3c0, 0x280, 0xc241, 0xc601, 0x6c0,
  0x780, 0xc741, 0x500, 0xc5c1, 0xc481, 0x440, 0xcc01, 0xcc0, 0xd80,
  0xcd41, 0xf00, 0xcfc1, 0xce81, 0xe40, 0xa00, 0xcac1, 0xcb81, 0xb40,
  0xc901, 0x9c0, 0x880, 0xc841, 0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00,
  0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0,
  0x1c80, 0xdc41, 0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680,
  0xd641, 0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040,
  0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240, 0x3600,
  0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441, 0x3c00, 0xfcc1,
  0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41, 0xfa01, 0x3ac0, 0x3b80,
  0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840, 0x2800, 0xe8c1, 0xe981, 0x2940,
  0xeb01, 0x2bc0, 0x2a80, 0xea41, 0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00,
  0xedc1, 0xec81, 0x2c40, 0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1,
  0xe681, 0x2640, 0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080,
  0xe041, 0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240,
  0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441, 0x6c00,
  0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41, 0xaa01, 0x6ac0,
  0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, 0x7800, 0xb8c1, 0xb981,
  0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 0xbe01, 0x7ec0, 0x7f80, 0xbf41,
  0x7d00, 0xbdc1, 0xbc81, 0x7c40, 0xb401, 0x74c0, 0x7580, 0xb541, 0x7700,
  0xb7c1, 0xb681, 0x7640, 0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0,
  0x7080, 0xb041, 0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280,
  0x9241, 0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440,
  0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40, 0x5a00,
  0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841, 0x8801, 0x48c0,
  0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 0x4e00, 0x8ec1, 0x8f81,
  0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540,
  0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100,
  0x81c1, 0x8081, 0x4040
};

Static crctabtype ccitt_table = {
  0, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129,
  0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, 0x1231, 0x210, 0x3273,
  0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 0x9339, 0x8318, 0xb37b, 0xa35a,
  0xd3bd, 0xc39c, 0xf3ff, 0xe3de, 0x2462, 0x3443, 0x420, 0x1401, 0x64e6,
  0x74c7, 0x44a4, 0x5485, 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee,
  0xf5cf, 0xc5ac, 0xd58d, 0x3653, 0x2672, 0x1611, 0x630, 0x76d7, 0x66f6,
  0x5695, 0x46b4, 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe,
  0xd79d, 0xc7bc, 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x840, 0x1861, 0x2802,
  0x3823, 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a,
  0xb92b, 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0xa50, 0x3a33, 0x2a12,
  0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
  0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0xc60, 0x1c41, 0xedae,
  0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49, 0x7e97,
  0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0xe70, 0xff9f, 0xefbe,
  0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, 0x9188, 0x81a9,
  0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, 0x1080, 0xa1, 0x30c2,
  0x20e3, 0x5004, 0x4025, 0x7046, 0x6067, 0x83b9, 0x9398, 0xa3fb, 0xb3da,
  0xc33d, 0xd31c, 0xe37f, 0xf35e, 0x2b1, 0x1290, 0x22f3, 0x32d2, 0x4235,
  0x5214, 0x6277, 0x7256, 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e,
  0xe54f, 0xd52c, 0xc50d, 0x34e2, 0x24c3, 0x14a0, 0x481, 0x7466, 0x6447,
  0x5424, 0x4405, 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e,
  0xc71d, 0xd73c, 0x26d3, 0x36f2, 0x691, 0x16b0, 0x6657, 0x7676, 0x4615,
  0x5634, 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a,
  0xa9ab, 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x8e1, 0x3882, 0x28a3,
  0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
  0x4a75, 0x5a54, 0x6a37, 0x7a16, 0xaf1, 0x1ad0, 0x2ab3, 0x3a92, 0xfd2e,
  0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 0x7c26,
  0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0xcc1, 0xef1f, 0xff3e,
  0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, 0x6e17, 0x7e36,
  0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0xed1, 0x1ef0
};

void crc_16(uchar Data, unsigned short *crc)
{
  *crc = ((*crc) >> 8) ^ crc16_table[((*crc) ^ Data) & 0xff];
}

void crcfcs(uchar Data, unsigned short *crc)
{
  *crc = ((*crc) >> 8) ^ ccitt_table[((*crc) ^ Data) & 0xff];
}

void crcthp(uchar Data, unsigned short *crc)
{
  *crc = ((*crc) << 8) ^ Data ^ ccitt_table[(*crc) >> 8];
}

void crcfbb(uchar Data, unsigned short *crc)
{
  *crc = ((*crc) << 8) ^ ccitt_table[((*crc) >> 8) ^ Data];
}

M. LZHuf Compression

/**************************************************************
    lzhuf.c
    written by Haruyasu Yoshizaki 11/20/1988
    some minor changes 4/6/1989
    comments translated by Haruhiko Okumura 4/7/1989
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

FILE  *infile, *outfile;
unsigned long int  textsize = 0, codesize = 0, printcount = 0;

char wterr[] = "Can't write.";

void Error(char *message)
{
    printf("\n%s\n", message);
    exit(EXIT_FAILURE);
}

/********** LZSS compression **********/

#define N       4096    /* buffer size */
/* Attention: When using this file for f6fbb-type compressed data exchange,
   set N to 2048 ! (DL8HBS) */
#define F       60  /* lookahead buffer size */
#define THRESHOLD   2
#define NIL     N   /* leaf of tree */

unsigned char
        text_buf[N + F - 1];
int     match_position, match_length,
        lson[N + 1], rson[N + 257], dad[N + 1];

void InitTree(void)  /* initialize trees */
{
    int  i;

    for (i = N + 1; i <= N + 256; i++)
        rson[i] = NIL;          /* root */
    for (i = 0; i < N; i++)
        dad[i] = NIL;           /* node */
}

void InsertNode(int r)  /* insert to tree */
{
    int  i, p, cmp;
    unsigned char  *key;
    unsigned c;

    cmp = 1;
    key = &text_buf[r];
    p = N + 1 + key[0];
    rson[r] = lson[r] = NIL;
    match_length = 0;
    for ( ; ; ) {
        if (cmp >= 0) {
            if (rson[p] != NIL)
                p = rson[p];
            else {
                rson[p] = r;
                dad[r] = p;
                return;
            }
        } else {
            if (lson[p] != NIL)
                p = lson[p];
            else {
                lson[p] = r;
                dad[r] = p;
                return;
            }
        }
        for (i = 1; i < F; i++)
            if ((cmp = key[i] - text_buf[p + i]) != 0)
                break;
        if (i > THRESHOLD) {
            if (i > match_length) {
                match_position = ((r - p) & (N - 1)) - 1;
                if ((match_length = i) >= F)
                    break;
            }
            if (i == match_length) {
                if ((c = ((r - p) & (N - 1)) - 1) < match_position) {
                    match_position = c;
                }
            }
        }
    }
    dad[r] = dad[p];
    lson[r] = lson[p];
    rson[r] = rson[p];
    dad[lson[p]] = r;
    dad[rson[p]] = r;
    if (rson[dad[p]] == p)
        rson[dad[p]] = r;
    else
        lson[dad[p]] = r;
    dad[p] = NIL;  /* remove p */
}

void DeleteNode(int p)  /* remove from tree */
{
    int  q;

    if (dad[p] == NIL)
        return;         /* not registered */
    if (rson[p] == NIL)
        q = lson[p];
    else
    if (lson[p] == NIL)
        q = rson[p];
    else {
        q = lson[p];
        if (rson[q] != NIL) {
            do {
                q = rson[q];
            } while (rson[q] != NIL);
            rson[dad[q]] = lson[q];
            dad[lson[q]] = dad[q];
            lson[q] = lson[p];
            dad[lson[p]] = q;
        }
        rson[q] = rson[p];
        dad[rson[p]] = q;
    }
    dad[q] = dad[p];
    if (rson[dad[p]] == p)
        rson[dad[p]] = q;
    else
        lson[dad[p]] = q;
    dad[p] = NIL;
}

/* Huffman coding */

#define N_CHAR      (256 - THRESHOLD + F)
                /* kinds of characters (character code = 0..N_CHAR-1) */
#define T       (N_CHAR * 2 - 1)    /* size of table */
#define R       (T - 1)         /* position of root */
#define MAX_FREQ    0x8000      /* updates tree when the */
                    /* root frequency comes to this value. */
typedef unsigned char uchar;


/* table for encoding and decoding the upper 6 bits of position */

/* for encoding */
uchar p_len[64] = {
    0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05,
    0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06,
    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08
};

uchar p_code[64] = {
    0x00, 0x20, 0x30, 0x40, 0x50, 0x58, 0x60, 0x68,
    0x70, 0x78, 0x80, 0x88, 0x90, 0x94, 0x98, 0x9C,
    0xA0, 0xA4, 0xA8, 0xAC, 0xB0, 0xB4, 0xB8, 0xBC,
    0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE,
    0xD0, 0xD2, 0xD4, 0xD6, 0xD8, 0xDA, 0xDC, 0xDE,
    0xE0, 0xE2, 0xE4, 0xE6, 0xE8, 0xEA, 0xEC, 0xEE,
    0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
    0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
};

/* for decoding */
uchar d_code[256] = {
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
    0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
    0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
    0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
    0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
    0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
    0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
    0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B,
    0x0C, 0x0C, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D,
    0x0E, 0x0E, 0x0E, 0x0E, 0x0F, 0x0F, 0x0F, 0x0F,
    0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11,
    0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13,
    0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15,
    0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17,
    0x18, 0x18, 0x19, 0x19, 0x1A, 0x1A, 0x1B, 0x1B,
    0x1C, 0x1C, 0x1D, 0x1D, 0x1E, 0x1E, 0x1F, 0x1F,
    0x20, 0x20, 0x21, 0x21, 0x22, 0x22, 0x23, 0x23,
    0x24, 0x24, 0x25, 0x25, 0x26, 0x26, 0x27, 0x27,
    0x28, 0x28, 0x29, 0x29, 0x2A, 0x2A, 0x2B, 0x2B,
    0x2C, 0x2C, 0x2D, 0x2D, 0x2E, 0x2E, 0x2F, 0x2F,
    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
    0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
};

uchar d_len[256] = {
    0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
    0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
    0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
    0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
};

unsigned freq[T + 1];   /* frequency table */

int prnt[T + N_CHAR];   /* pointers to parent nodes, except for the */
            /* elements [T..T + N_CHAR - 1] which are used to get */
            /* the positions of leaves corresponding to the codes. */

int son[T];     /* pointers to child nodes (son[], son[] + 1) */

unsigned getbuf = 0;
uchar getlen = 0;

int GetBit(void)    /* get one bit */
{
    int i;

    while (getlen <= 8) {
        if ((i = getc(infile)) < 0) i = 0;
        getbuf |= i << (8 - getlen);
        getlen += 8;
    }
    i = getbuf;
    getbuf <<= 1;
    getlen--;
    return (i < 0);
}

int GetByte(void)   /* get one byte */
{
    unsigned i;

    while (getlen <= 8) {
        if ((i = getc(infile)) < 0) i = 0;
        getbuf |= i << (8 - getlen);
        getlen += 8;
    }
    i = getbuf;
    getbuf <<= 8;
    getlen -= 8;
    return i >> 8;
}

unsigned putbuf = 0;
uchar putlen = 0;

void Putcode(int l, unsigned c)     /* output c bits of code */
{
    putbuf |= c >> putlen;
    if ((putlen += l) >= 8) {
        if (putc(putbuf >> 8, outfile) == EOF) {
            Error(wterr);
        }
        if ((putlen -= 8) >= 8) {
            if (putc(putbuf, outfile) == EOF) {
                Error(wterr);
            }
            codesize += 2;
            putlen -= 8;
            putbuf = c << (l - putlen);
        } else {
            putbuf <<= 8;
            codesize++;
        }
    }
}


/* initialization of tree */

void StartHuff(void)
{
    int i, j;

    for (i = 0; i < N_CHAR; i++) {
        freq[i] = 1;
        son[i] = i + T;
        prnt[i + T] = i;
    }
    i = 0; j = N_CHAR;
    while (j <= R) {
        freq[j] = freq[i] + freq[i + 1];
        son[j] = i;
        prnt[i] = prnt[i + 1] = j;
        i += 2; j++;
    }
    freq[T] = 0xffff;
    prnt[R] = 0;
}


/* reconstruction of tree */

void reconst(void)
{
    int i, j, k;
    unsigned f, l;

    /* collect leaf nodes in the first half of the table */
    /* and replace the freq by (freq + 1) / 2. */
    j = 0;
    for (i = 0; i < T; i++) {
        if (son[i] >= T) {
            freq[j] = (freq[i] + 1) / 2;
            son[j] = son[i];
            j++;
        }
    }
    /* begin constructing tree by connecting sons */
    for (i = 0, j = N_CHAR; j < T; i += 2, j++) {
        k = i + 1;
        f = freq[j] = freq[i] + freq[k];
        for (k = j - 1; f < freq[k]; k--);
        k++;
        l = (j - k) * 2;
        memmove(&freq[k + 1], &freq[k], l);
        freq[k] = f;
        memmove(&son[k + 1], &son[k], l);
        son[k] = i;
    }
    /* connect prnt */
    for (i = 0; i < T; i++) {
        if ((k = son[i]) >= T) {
            prnt[k] = i;
        } else {
            prnt[k] = prnt[k + 1] = i;
        }
    }
}


/* increment frequency of given code by one, and update tree */

void update(int c)
{
    int i, j, k, l;

    if (freq[R] == MAX_FREQ) {
        reconst();
    }
    c = prnt[c + T];
    do {
        k = ++freq[c];

        /* if the order is disturbed, exchange nodes */
        if (k > freq[l = c + 1]) {
            while (k > freq[++l]);
            l--;
            freq[c] = freq[l];
            freq[l] = k;

            i = son[c];
            prnt[i] = l;
            if (i < T) prnt[i + 1] = l;

            j = son[l];
            son[l] = i;

            prnt[j] = c;
            if (j < T) prnt[j + 1] = c;
            son[c] = j;

            c = l;
        }
    } while ((c = prnt[c]) != 0);   /* repeat up to root */
}

unsigned code, len;

void EncodeChar(unsigned c)
{
    unsigned i;
    int j, k;

    i = 0;
    j = 0;
    k = prnt[c + T];

    /* travel from leaf to root */
    do {
        i >>= 1;

        /* if node's address is odd-numbered, choose bigger brother node */
        if (k & 1) i += 0x8000;

        j++;
    } while ((k = prnt[k]) != R);
    Putcode(j, i);
    code = i;
    len = j;
    update(c);
}

void EncodePosition(unsigned c)
{
    unsigned i;

    /* output upper 6 bits by table lookup */
    i = c >> 6;
    Putcode(p_len[i], (unsigned)p_code[i] << 8);

    /* output lower 6 bits verbatim */
    Putcode(6, (c & 0x3f) << 10);
}

void EncodeEnd(void)
{
    if (putlen) {
        if (putc(putbuf >> 8, outfile) == EOF) {
            Error(wterr);
        }
        codesize++;
    }
}

int DecodeChar(void)
{
    unsigned c;

    c = son[R];

    /* travel from root to leaf, */
    /* choosing the smaller child node (son[]) if the read bit is 0, */
    /* the bigger (son[]+1} if 1 */
    while (c < T) {
        c += GetBit();
        c = son[c];
    }
    c -= T;
    update(c);
    return c;
}

int DecodePosition(void)
{
    unsigned i, j, c;

    /* recover upper 6 bits from table */
    i = GetByte();
    c = (unsigned)d_code[i] << 6;
    j = d_len[i];

    /* read lower 6 bits verbatim */
    j -= 2;
    while (j--) {
        i = (i << 1) + GetBit();
    }
    return c | (i & 0x3f);
}

/* compression */

void Encode(void)  /* compression */
{
    int  i, c, len, r, s, last_match_length;

    fseek(infile, 0L, 2);
    textsize = ftell(infile);
    if (fwrite(&textsize, sizeof textsize, 1, outfile) < 1)
        Error(wterr);   /* output size of text */
    if (textsize == 0)
        return;
    rewind(infile);
    textsize = 0;           /* rewind and re-read */
    StartHuff();
    InitTree();
    s = 0;
    r = N - F;
    for (i = s; i < r; i++)
        text_buf[i] = ' ';
    for (len = 0; len < F && (c = getc(infile)) != EOF; len++)
        text_buf[r + len] = c;
    textsize = len;
    for (i = 1; i <= F; i++)
        InsertNode(r - i);
    InsertNode(r);
    do {
        if (match_length > len)
            match_length = len;
        if (match_length <= THRESHOLD) {
            match_length = 1;
            EncodeChar(text_buf[r]);
        } else {
            EncodeChar(255 - THRESHOLD + match_length);
            EncodePosition(match_position);
        }
        last_match_length = match_length;
        for (i = 0; i < last_match_length &&
                (c = getc(infile)) != EOF; i++) {
            DeleteNode(s);
            text_buf[s] = c;
            if (s < F - 1)
                text_buf[s + N] = c;
            s = (s + 1) & (N - 1);
            r = (r + 1) & (N - 1);
            InsertNode(r);
        }
        if ((textsize += i) > printcount) {
            printf("%12ld\r", textsize);
            printcount += 1024;
        }
        while (i++ < last_match_length) {
            DeleteNode(s);
            s = (s + 1) & (N - 1);
            r = (r + 1) & (N - 1);
            if (--len) InsertNode(r);
        }
    } while (len > 0);
    EncodeEnd();
    printf("In : %ld bytes\n", textsize);
    printf("Out: %ld bytes\n", codesize);
    printf("Out/In: %.3f\n", (double)codesize / textsize);
}

void Decode(void)  /* recover */
{
    int  i, j, k, r, c;
    unsigned long int  count;

    if (fread(&textsize, sizeof textsize, 1, infile) < 1)
        Error("Can't read");  /* read size of text */
    if (textsize == 0)
        return;
    StartHuff();
    for (i = 0; i < N - F; i++)
        text_buf[i] = ' ';
    r = N - F;
    for (count = 0; count < textsize; ) {
        c = DecodeChar();
        if (c < 256) {
            if (putc(c, outfile) == EOF) {
                Error(wterr);
            }
            text_buf[r++] = c;
            r &= (N - 1);
            count++;
        } else {
            i = (r - DecodePosition() - 1) & (N - 1);
            j = c - 255 + THRESHOLD;
            for (k = 0; k < j; k++) {
                c = text_buf[(i + k) & (N - 1)];
                if (putc(c, outfile) == EOF) {
                    Error(wterr);
                }
                text_buf[r++] = c;
                r &= (N - 1);
                count++;
            }
        }
        if (count > printcount) {
            printf("%12ld\r", count);
            printcount += 1024;
        }
    }
    printf("%12ld\n", count);
}

int main(int argc, char *argv[])
{
    char  *s;

    if (argc != 4) {
        printf("'lzhuf e file1 file2' encodes file1 into file2.\n"
               "'lzhuf d file2 file1' decodes file2 into file1.\n");
        return EXIT_FAILURE;
    }
    if ((s = argv[1], s[1] || strpbrk(s, "DEde") == NULL)
     || (s = argv[2], (infile  = fopen(s, "rb")) == NULL)
     || (s = argv[3], (outfile = fopen(s, "wb")) == NULL)) {
        printf("??? %s\n", s);
        return EXIT_FAILURE;
    }
    if (toupper(*argv[1]) == 'E')
        Encode();
    else
        Decode();
    fclose(infile);
    fclose(outfile);
    return EXIT_SUCCESS;
}

N. RSA Data Security, Inc. MD2 Message Digest Algorithm

/* ------- start of RSA copyrighted code --------- */

/* some changes were made by Joachim Schurig 28/04/96 to encapsulate
   the code in PASCAL */

/*  Copyright (C) 1990-2, RSA Data Security, Inc. Created 1990. All
    rights reserved.

    License to copy and use this software is granted for
    non-commercial Internet Privacy-Enhanced Mail provided that it is
    identified as the "RSA Data Security, Inc. MD2 Message Digest
    Algorithm" in all material mentioning or referencing this software
    or this function.

    RSA Data Security, Inc. makes no representations concerning either
    the merchantability of this software or the suitability of this
    software for any particular purpose. It is provided "as is"
    without express or implied warranty of any kind.

    These notices must be retained in any copies of any part of this
    documentation and/or software.
  */


typedef uchar MD2barr16[16];

typedef struct MD2_CTX {
  MD2barr16 state, checksum;
  long count;
  MD2barr16 buffer;
} MD2_CTX;


/*
 *  Permutation of 0..255 constructed from the digits of pi. It gives a
 *  "random" nonlinear byte substitution operation.
 */


typedef uchar PI_SUBSTTYPE[256];


typedef MD2barr16 PADDINGTYPE[17];


Static PI_SUBSTTYPE PI_SUBST = {
  41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6, 19, 98,
  167, 5, 243, 192, 199, 115, 140, 152, 147, 43, 217, 188, 76, 130, 202, 30,
  155, 87, 60, 253, 212, 224, 22, 103, 66, 111, 24, 138, 23, 229, 18, 190, 78,
  196, 214, 218, 158, 222, 73, 160, 251, 245, 142, 187, 47, 238, 122, 169,
  104, 121, 145, 21, 178, 7, 63, 148, 194, 16, 137, 11, 34, 95, 33, 128, 127,
  93, 154, 90, 144, 50, 39, 53, 62, 204, 231, 191, 247, 151, 3, 255, 25, 48,
  179, 72, 165, 181, 209, 215, 94, 146, 42, 172, 86, 170, 198, 79, 184, 56,
  210, 150, 164, 125, 182, 118, 252, 107, 226, 156, 116, 4, 241, 69, 157, 112,
  89, 100, 113, 135, 32, 134, 91, 207, 101, 230, 45, 168, 2, 27, 96, 37, 173,
  174, 176, 185, 246, 28, 70, 97, 105, 52, 64, 126, 15, 85, 71, 163, 35, 221,
  81, 175, 58, 195, 92, 249, 206, 186, 197, 234, 38, 44, 83, 13, 110, 133, 40,
  132, 9, 211, 223, 205, 244, 65, 129, 77, 82, 106, 220, 55, 200, 108, 193,
  171, 250, 36, 225, 123, 8, 12, 189, 177, 74, 120, 136, 149, 139, 227, 99,
  232, 109, 233, 203, 213, 254, 59, 0, 29, 57, 242, 239, 183, 14, 102, 88,
  208, 228, 166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237,
  31, 26, 219, 153, 141, 51, 159, 17, 131, 20
};

Static PADDINGTYPE PADDING;
Static boolean PADDINGOK;
/* must be initialized with FALSE at program startup (Joachim Schurig) */

/*
 *  initializes the padding tab, cannot be assigned directly in PASCAL code
 *  added by Joachim Schurig
 */

Static void init_padding(void)
{
  short x, y;

  PADDING[0][0] = 0;

  for (x = 1; x <= 16; x++) {
    for (y = 0; y < x; y++)
      PADDING[x][y] = x;
  }

  PADDINGOK = true;
}

/* MD2 initialization. Begins an MD2 operation, writing a new context. */

Static void MD2Init(MD2_CTX *context)
{
  if (!PADDINGOK)   /* added for PASCAL */
    init_padding();
  context->count = 0;
  memset(context->state, 0, sizeof(MD2barr16));
  memset(context->checksum, 0, sizeof(MD2barr16));
}

/* MD2 basic transformation. Transforms state and updates checksum based on block. */

Static void MD2Transform(uchar *state, uchar *checksum, uchar *block)
{
  long i, j, t;
  uchar x[48];

  /* Form encryption block from state, block, state ^ block. */
  memcpy(x, state, 16);
  memcpy(&x[16], block, 16);
  for (i = 0; i <= 15; i++)
    x[i + 32] = state[i] ^ block[i];

  /* Encrypt block (18 rounds). */
  t = 0;
  for (i = 0; i <= 17; i++) {
    for (j = 0; j <= 47; j++) {
      t = x[j] ^ PI_SUBST[t];
      x[j] = t;
    }
    t = (t + i) & 0xff;
  }

  /* Save new state */
  memcpy(state, x, 16);

  /* Update checksum. */
  t = checksum[15];
  for (i = 0; i <= 15; i++) {
    t = checksum[i] ^ PI_SUBST[block[i] ^ t];
    checksum[i] = t;
  }

  /* Zeroize sensitive information. */
  memset(x, 0, sizeof(uchar) * 48);
}

/*
 *  MD2 block update operation. Continues an MD2 message-digest
 *  operation, processing another message block, and updating the
 *  context.
 */

Static void MD2Update(MD2_CTX *context, uchar *input, long inputLen)
{
  long i, index, partLen;

  /* Update number of bytes mod 16 */
  index = context->count;
  context->count = (index + inputLen) & 0xf;

  partLen = 16 - index;

  /* Transform as many times as possible. */
  if (inputLen >= partLen) {
    memcpy(&context->buffer[index], input, partLen);
    MD2Transform(context->state, context->checksum, context->buffer);

    i = partLen;
    while (i + 15 < inputLen) {
      MD2Transform(context->state, context->checksum, (uchar *)(&input[i]));
      i += 16;
    }

    index = 0;
  } else
    i = 0;

  /* Buffer remaining input */
  memcpy(&context->buffer[index], (uchar *)(&input[i]), inputLen - i);
}

/*
 *  MD2 finalization. Ends an MD2 message-digest operation, writing the
 *  message digest and zeroizing the context.
 */

Static void MD2Final(uchar *digest, MD2_CTX *context)
{
  long index, padLen;

  /* Pad out to multiple of 16 */
  index = context->count;
  padLen = 16 - index;
  MD2Update(context, PADDING[padLen], padLen);

  /* Extend with checksum */
  MD2Update(context, context->checksum, 16);

  /* Store state in digest */
  memcpy(digest, context->state, 16);

  /* Zeroize sensitive information */
  memset((uchar *)context, 0, sizeof(MD2_CTX));
}

/* ------- end of RSA copyrighted code ------- */



void calc_MD2_pw(Char *MD2prompt, Char *MD2pw, Char *MD2result)
{
  MD2_CTX context;
  MD2barr16 digest;
  short i, n, len;
  long bc;
  Char c1, c2;
  uchar *buffp;
  Char buff[256];
  short FORLIM;

  buffp = buff;
  bc = 0;
  FORLIM = strlen(MD2prompt);
  for (i = 0; i < FORLIM; i++) {
    buffp[bc] = MD2prompt[i];
    bc++;
  }
  FORLIM = strlen(MD2pw);
  for (i = 0; i < FORLIM; i++) {
    buffp[bc] = MD2pw[i];
    bc++;
  }

  buffp[bc] = 0;

  MD2Init(&context);
  len = bc;

  i = 0;

  while (i < len) {
    if (len - i > 16)
      n = 16;
    else
      n = len - i;
    MD2Update(&context, (uchar *)(&buffp[i]), n);
    i += 16;
  }
  MD2Final(digest, &context);

  MD2result[0] = '\0';
  for (i = 0; i <= 15; i++) {
    int2hchar(digest[i], &c1, &c2);
    sprintf(MD2result + strlen(MD2result), "%c%c", c1, c2);
  }
  lower(MD2result);
}


void calc_MD2_prompt(Char *MD2prompt)
{
  short x;
  Char c;

  MD2prompt[0] = '\0';
  for (x = 1; x <= 10; x++) {
    do {
      c = dp_randomize(48, 122);
    } while (!isalnum(c));
    sprintf(MD2prompt + strlen(MD2prompt), "%c", c);
  }
}