/*--------------------------------------------------------------------------*/
/* */
/* */
/* ------------ Bit-Bucket Software, Co. */
/* \ 10001101 / Writers and Distributors of */
/* \ 011110 / Freely Available<tm> Software. */
/* \ 1011 / */
/* ------ */
/* */
/* (C) Copyright 1987-96, Bit Bucket Software Co. */
/* */
/* This module was written by Tobias Burchhardt */
/* */
/* BinkleyTerm EMSI-Handshake Processor */
/* */
/* */
/* For complete details of the licensing restrictions, please refer */
/* to the License agreement, which is published in its entirety in */
/* the MAKEFILE and BT.C, and also contained in the file LICENSE.260. */
/* */
/* USE OF THIS FILE IS SUBJECT TO THE RESTRICTIONS CONTAINED IN THE */
/* BINKLEYTERM LICENSING AGREEMENT. IF YOU DO NOT FIND THE TEXT OF */
/* THIS AGREEMENT IN ANY OF THE AFOREMENTIONED FILES, OR IF YOU DO */
/* NOT HAVE THESE FILES, YOU SHOULD IMMEDIATELY CONTACT BIT BUCKET */
/* SOFTWARE CO. AT ONE OF THE ADDRESSES LISTED BELOW. IN NO EVENT */
/* SHOULD YOU PROCEED TO USE THIS FILE WITHOUT HAVING ACCEPTED THE */
/* TERMS OF THE BINKLEYTERM LICENSING AGREEMENT, OR SUCH OTHER */
/* AGREEMENT AS YOU ARE ABLE TO REACH WITH BIT BUCKET SOFTWARE, CO. */
/* */
/* */
/* You can contact Bit Bucket Software Co. at any one of the following */
/* addresses: */
/* */
/* Bit Bucket Software Co. FidoNet 1:104/501, 1:343/491 */
/* P.O. Box 460398 AlterNet 7:42/1491 */
/* Aurora, CO 80046 BBS-Net 86:2030/1 */
/* Internet f491.n343.z1.fidonet.org */
/* */
/* Please feel free to contact us at any time to share your comments about */
/* our software and/or licensing policies. */
/* */
/*--------------------------------------------------------------------------*/
/* Include this file before any other includes or defines! */
#include "includes.h"
static int LOCALFUNC Send_EMSI_Packet (int);
static int LOCALFUNC Recv_EMSI_Packet (int);
static int LOCALFUNC get_emsi (char *);
static char *LOCALFUNC b7strcat (char *, char *);
static int LOCALFUNC recode_from_b7 (char *, int);
static int LOCALFUNC match_aka (ADDRP);
static char *LOCALFUNC get_bracket (char *);
static char *LOCALFUNC cat_bracket (char *, char *);
static int LOCALFUNC get_level (ADDRP addr, ADDRP myaka);
static int LOCALFUNC Encode_EMSI_Header (char *, int);
static int LOCALFUNC Decode_EMSI_Header (char *, int, int);
static int highest_level, hl_aka; /* Used for passwording */
/*--------------------------------------------------------------------------*/
/* EMSI SENDER (used when I am the CALLING system) */
/*--------------------------------------------------------------------------*/
int
EMSI_Sender (void)
{
char *sptr;
highest_level = hl_aka = num_rakas = 0;
sptr = NULL;
if (un_attended && fullscreen)
{
sb_move (filewin, 2, 2);
sb_puts (filewin, MSG_TXT (M_EMXMIT));
sb_show ();
}
else
{
set_xy (MSG_TXT (M_EMSEND));
}
/*--------------------------------------------------------------------*/
/* Clean up any mess that may be around */
/*--------------------------------------------------------------------*/
CLEAR_INBOUND ();
XON_DISABLE ();
if (!Send_EMSI_Packet (1))
{
sptr = MSG_TXT (M_HE_HUNG_UP);
status_line (sptr);
return (0);
}
if (un_attended && fullscreen)
{
sb_move (filewin, 2, 2);
sb_puts (filewin, MSG_TXT (M_EMWAIT));
sb_show ();
}
else
{
set_xy (MSG_TXT (M_EMRECV));
}
return Recv_EMSI_Packet (1);
}
/*--------------------------------------------------------------------------*/
/* EMSI RECEIVER (Used when I am the CALLED system) */
/*--------------------------------------------------------------------------*/
int
EMSI_Receiver (void)
{
int i;
highest_level = hl_aka = num_rakas = 0;
if (un_attended && fullscreen)
{
sb_move (filewin, 2, 2);
sb_puts (filewin, MSG_TXT (M_EMWAIT));
sb_show ();
}
else
{
set_xy (MSG_TXT (M_EMRECV));
}
/*--------------------------------------------------------------------*/
/* Clean up any mess that may be around */
/*--------------------------------------------------------------------*/
CLEAR_OUTBOUND ();
XON_DISABLE ();
if (Recv_EMSI_Packet (0) == 0)
return (0);
if (un_attended && fullscreen)
{
sb_move (filewin, 2, 2);
sb_puts (filewin, MSG_TXT (M_EMXMIT));
sb_show ();
}
else
{
set_xy (MSG_TXT (M_EMSEND));
}
if ((i = Send_EMSI_Packet (0)) == 0)
b_init ();
return (i);
} /* EMSI Receiver */
/*--------------------------------------------------------------------------*/
/* SEND EMSI PACKET */
/*--------------------------------------------------------------------------*/
static int LOCALFUNC
Send_EMSI_Packet (int Sender)
{
int i;
char *sptr;
long T1, T2;
word crc, len;
word tries = 0;
char *junkbuff, *uni;
/*
* Txbuf is (8192+16) in length
* junkbuff wants to be 4096
* uni wants to be 256
* We reserve the last 1024+16 for lower level functions
*
* If you change this way of doing things, you have to change
* Encode_EMSI_Header as well!!!
*/
junkbuff = (char *) Txbuf;
uni = &junkbuff[4096];
/*--------------------------------------------------------------------*/
/* Setup EMSI structure */
/*--------------------------------------------------------------------*/
len = Encode_EMSI_Header (junkbuff, Sender);
/*--------------------------------------------------------------------*/
/* Disable handshaking and ^C/^K handling */
/*--------------------------------------------------------------------*/
XON_DISABLE ();
/*--------------------------------------------------------------------*/
/* Send the packet. */
/* Load outbound buffer quickly, and get modem busy sending. */
/*--------------------------------------------------------------------*/
tries = 0;
T1 = timerset (6000);
xmit_packet:
sprintf (uni, "%s%04X", &(emsistr[EMSI_DAT][2]), len);
crc = crc_block ((unsigned char *) uni, strlen (uni));
SENDCHARS ("**", 2, 1);
SENDCHARS (uni, strlen (uni), 1);
SENDCHARS (junkbuff, len, 1);
/*--------------------------------------------------------------------*/
/* Calculate CRC while modem is sending its buffer */
/*--------------------------------------------------------------------*/
for (i = 0; i < (int) len; i++)
crc = xcrc (crc, junkbuff[i]);
CLEAR_INBOUND ();
sprintf (uni, "%04X\r", crc);
SENDCHARS (uni, strlen (uni), 1);
if (tries++ > 6)
{
(void) sprintf (uni, "!%s", MSG_TXT (M_TIMEOUT));
sptr = uni;
goto no_response;
}
/* wait_response: */
T2 = timerset (2000);
while (!timeup (T1) && CARRIER)
{
if (timeup (T2))
goto xmit_packet;
if (!CHAR_AVAIL ())
{
if (got_ESC ())
{
LOWER_DTR ();
sptr = MSG_TXT (M_KBD_MSG);
goto no_response;
}
time_release ();
continue;
}
switch (i = TIMED_READ (0))
{
case '*':
strcpy (uni, "*");
if (!get_emsi (uni))
break;
if (!stricmp (uni, emsistr[EMSI_REQ]))
continue;
if (!stricmp (uni, emsistr[EMSI_ACK]))
return (1);
goto xmit_packet;
default:
if (i <= 0) /* MB *//* Could just be line noise if > 0*/
time_release ();/*PLF Sun 12-01-1991 04:21:14 */
break;
}
}
if (!CARRIER)
sptr = MSG_TXT (M_NO_CARRIER);
else
{
(void) sprintf (uni, "!%s", MSG_TXT (M_TIMEOUT));
sptr = uni;
}
no_response:
status_line (sptr);
return (0);
} /* Send EMSI */
/*--------------------------------------------------------------------------*/
/* RECEIVE EMSI PACKET */
/*--------------------------------------------------------------------------*/
static int LOCALFUNC
Recv_EMSI_Packet (int Sender)
{
int i;
int c;
int len;
char *sptr;
byte tries = 0;
word crc, crc2;
long T1, T2, T3;
char *junkbuff, *uni, *help;
/*
* Txbuf is (8192+16) in length
* junkbuff wants to be 4096
* uni wants to be 256
* help wants to be 256
* tmpstr wants to be 256
* We reserve the last 1024+16 for lower level functions
*
* If you change this way of doing things, you have to change
* Decode_EMSI_Header as well!!!
*/
junkbuff = (char *) Txbuf;
uni = &junkbuff[4096];
help = &uni[256];
/* tmpstr = &help[256]; */
/* strcpy (remote_sysop, "Sysop"); */
remote_password = NULL;
/*--------------------------------------------------------------------*/
/* Get the EMSI structure */
/*--------------------------------------------------------------------*/
if (un_attended && fullscreen)
{
sb_move (filewin, 2, 2);
sb_puts (filewin, MSG_TXT (M_EMWAIT));
sb_show ();
}
else
{
set_xy (MSG_TXT (M_EMRECV));
}
remote_pickup = 2; /* Pickup for all akas */
T1 = timerset (2000);
T2 = timerset (6000);
sptr = NULL;
request_it:
if (tries++ > 6)
goto timeout;
if (!Sender)
{
sprintf (uni, "%s\r", emsistr[EMSI_REQ]); /* EMSI_REQ if he called me */
}
else if (tries > 1)
{
sprintf (uni, "%s\r", emsistr[EMSI_NAK]); /* EMSI_NAK anytime after 1st*/
}
else
goto watch_for_header;
SENDCHARS (uni, strlen (uni), 1); /* Kick the other guy. */
new_timer:
T1 = timerset (2000);
watch_for_header:
while (!timeup (T2) && CARRIER)
{
if (sptr)
{
status_line (sptr);
sptr = NULL;
}
if (timeup (T1))
goto request_it;
if (!CHAR_AVAIL ())
{
if (got_ESC ())
{
LOWER_DTR ();
sptr = MSG_TXT (M_KBD_MSG);
goto receive_failed;
}
time_release ();
continue;
}
switch (i = TIMED_READ (0))
{
case '*':
strcpy (uni, "*");
if (!get_emsi (uni))
break;
if (!stricmp (uni, emsistr[EMSI_HBT]))
goto new_timer;
if (!stricmp (uni, emsistr[EMSI_DAT]))
goto receive_packet;
break;
default:
if (i <= 0) /* MB *//* Could just be line noise if > 0 */
time_release ();/*PLF Sun 12-01-1991 04:21:14 */
break;
}
}
if (timeup (T2))
goto timeout;
if (!CARRIER)
{
sptr = MSG_TXT (M_NO_CARRIER);
goto receive_failed;
}
receive_packet:
if (un_attended && fullscreen)
{
sb_move (filewin, 2, 2);
sb_puts (filewin, MSG_TXT (M_EMRCPT));
sb_show ();
}
T3 = timerset (6000);
if (((int) (uni[0] = (char) TIMED_READ (3)) < 0) ||
((int) (uni[1] = (char) TIMED_READ (3)) < 0) ||
((int) (uni[2] = (char) TIMED_READ (3)) < 0) ||
((int) (uni[3] = (char) TIMED_READ (3)) < 0))
{
sptr = MSG_TXT (M_EMSHORT);
goto emsi_error;
}
if (!CARRIER)
{
sptr = MSG_TXT (M_NO_CARRIER);
goto receive_failed;
}
uni[4] = '\0';
sscanf (uni, "%x", &len);
sprintf (help, "%s%s", &(emsistr[EMSI_DAT][2]), uni);
crc = crc_block ((unsigned char *) help, strlen (help));
sptr = junkbuff;
memset (junkbuff, 0, 4096);
for (i = 0; i < len; i++)
{
while (PEEKBYTE () < 0)
{
if (timeup (T2) || timeup (T3))
goto timeout;
if (got_ESC ())
{
sptr = MSG_TXT (M_KBD_MSG);
goto receive_failed;
}
if (!CARRIER)
{
sptr = MSG_TXT (M_NO_CARRIER);
goto receive_failed;
}
time_release ();
}
c = TIMED_READ (0);
*sptr++ = (char) c;
crc = xcrc (crc, (byte) c);
}
if (((int) (uni[0] = (char) TIMED_READ (3)) < 0) ||
((int) (uni[1] = (char) TIMED_READ (3)) < 0) ||
((int) (uni[2] = (char) TIMED_READ (3)) < 0) ||
((int) (uni[3] = (char) TIMED_READ (3)) < 0))
{
sptr = MSG_TXT (M_EMSHORT);
goto emsi_error;
}
TIMED_READ (1); /* What am I throwing away here? */
if (!CARRIER)
{
sptr = MSG_TXT (M_NO_CARRIER);
goto receive_failed;
}
uni[4] = '\0';
sscanf (uni, "%hx", &crc2);
if (crc == crc2)
goto process_packet;
(void) sprintf (junkbuff, "!%s", MSG_TXT (M_CRC_MSG));
sptr = junkbuff;
emsi_error:
if (timeup (T2))
goto timeout;
CLEAR_INBOUND ();
goto request_it;
process_packet:
if (strnicmp (junkbuff, "{EMSI}", 6))
{
sptr = MSG_TXT (M_EMSTART);
goto emsi_error;
}
if (!Decode_EMSI_Header (junkbuff, len, Sender))
goto receive_failed;
(void) n_getpassword (&remote_akas[hl_aka]); /* Updated 'assumed', 'CURRENT' to match remote */
CLEAR_INBOUND ();
CLEAR_OUTBOUND ();
sprintf (uni, "%s\r", emsistr[EMSI_ACK]);
SENDCHARS (uni, strlen (uni), 1); /* Let the other system know */
SENDCHARS (uni, strlen (uni), 1); /* we got it ! */
T3 = timerset (1000);
while (!OUT_EMPTY ()) /* Flush the buffer */
{
if (timeup (T3))
goto timeout;
if (!CARRIER)
goto receive_failed;
time_release ();
}
return (1);
timeout:
(void) sprintf (uni, "!%s", MSG_TXT (M_TIMEOUT));
sptr = uni;
receive_failed:
status_line (sptr);
b_init ();
return (0);
} /* Recv EMSI */
static int LOCALFUNC
get_emsi (char *s)
{
long T1;
char *sptr, c;
int i;
T1 = timerset (500);
sptr = s + 1;
memset (sptr, 0, EMSI_LEN + 1);
while (CARRIER)
{
while (PEEKBYTE () < 0)
{
if (timeup (T1))
goto timeout;
if (got_ESC ())
{
status_line (MSG_TXT (M_KBD_MSG));
goto receive_failed;
}
if (!CARRIER)
{
status_line (MSG_TXT (M_NO_CARRIER));
goto receive_failed;
}
time_release ();
}
c = (char) TIMED_READ (0);
if (c == '\r')
{
status_line (">EMSI: '%s'", s);
return (1);
}
*sptr++ = (char) c;
for (i = 0; i < EMSI_MAX; i++)
{
if (!strnicmp (s, emsistr[i], strlen (emsistr[i])))
{
status_line (">EMSI: '%s'", s);
return (1);
}
else
{
if ((int) strlen (s) > EMSI_LEN)
{
status_line (">EMSI: '%s'", s);
return (1);
}
}
}
}
timeout:
status_line ("!%s", MSG_TXT (M_TIMEOUT));
receive_failed:
return (0);
}
static char *LOCALFUNC
b7strcat (char *d, char *s)
{
int i;
int j = strlen (s);
char uni[4], *p, *c;
p = &d[strlen (d)];
c = s;
for (i = 0; i < j; c++, i++)
{
if (*c == '\\')
{
*p++ = '\\';
*p++ = '\\';
continue;
}
/*old if((*c>=0)&&(*c<=0x7F)) */
if (!(*c & 0x80))
{
*p++ = *c;
continue;
}
*p++ = '\\'; /* Do coding only for 8 bit chars */
sprintf (uni, "%02X", (unsigned) *c);
*p++ = uni[0];
*p++ = uni[1];
continue;
}
*p++ = '\0';
return (d);
}
static LOCALFUNC
recode_from_b7 (char *s, int len)
{
int i, j;
char *d, uni[4];
unsigned c;
d = s;
for (j = i = 0; i < len; j++)
{
if (*s != '\\')
{
*d++ = *s++;
i++;
continue;
}
if (*++s == '\\')
{
*d++ = *s++;
i += 2;
continue;
}
uni[0] = *s++;
uni[1] = *s++;
uni[2] = '\0';
sscanf (uni, "%hx", &c);
*d++ = (char) c;
i += 3;
}
*d++ = '\0';
return (j); /* New length */
}
static int LOCALFUNC
get_level (ADDRP addr, ADDRP myaka)
{
int level = -1;
if ((addr->Domain == myaka->Domain) || !addr->Domain || !myaka->Domain)
level++;
else
return (level);
if (addr->Zone == myaka->Zone)
level++;
else
return (level);
if (addr->Net == myaka->Net)
level++;
else
return (level);
if (addr->Node == myaka->Node)
level++;
return (level);
}
static int LOCALFUNC
match_aka (ADDRP addr)
{
int level = -1;
int i, j;
assumed = 0;
for (i = 0; i < num_addrs; i++)
{
j = get_level (addr, &alias[i]);
if (j > level)
{
assumed = i;
level = j;
}
}
return (0);
}
/*--------------------------------------------------------------------------*/
/* Find end of EMSI field */
/*--------------------------------------------------------------------------*/
static char *LOCALFUNC
get_bracket (char *p)
{
register char c;
register char x = *(p - 1); /* Save starting character */
char *q = p;
/* Convert starting bracket to expected ending bracket */
if (x == '{')
x = '}';
else if (x == '[')
x = ']';
while ((c = *p++) != '\0')
{
/* If this is an ending bracket */
if (c == '}' || c == ']')
{
/* And it's not escaped */
if (*p != c)
{
/* And it's the right one, get out. */
if (c == x)
break;
}
else
{
/* If it is escaped, copy the end of the string over the esc */
strcpy (q, p);
}
}
q = p;
}
return (q);
}
static char *LOCALFUNC
cat_bracket (char *d, char *c) /* MB 93-11-27 */
{
char x, *p, *q;
q = p = (char *) &Txbuf[7168];
while ((x = *c++) != '\0')
{
if (*c && (x == '}' || x == ']'))
*p++ = x; /* We have to escape } or ] by doing it twice */
*p++ = x;
}
*p++ = '\0';
return (b7strcat (d, q));
}
static int LOCALFUNC
Decode_EMSI_Header (char *junkbuff, int len, int Sender)
{
int i, akacnt = 0;
int prodcodeT, logit = TRUE;
int j, addonnr;
long lmoh = 0;
int cur = 0;
char *tmpstr, *sptr, *p;
char *uni, *help, *name, *loc, password[16];
ADDR addr[ALIAS_CNT], remote;
static char *addons[] = {"{IDENT}", "{TRX#}", "{MOH#}", NULL};
uni = &junkbuff[4096]; /* Look at Recv_EMSI_Packet to see */
help = &uni[256]; /* why this is OK */
tmpstr = &help[256];
recode_from_b7 (junkbuff, len);
sptr = &junkbuff[7];
memset (&remote_addr, 0, sizeof (remote_addr));
akacnt = i = 0;
while (*sptr != '}')
{
while (*sptr == ' ')
sptr++;
/* Copy the address string into temp string. */
p = tmpstr;
while (*sptr && *sptr != '}' && *sptr != ' ')
*p++ = *sptr++;
*p = '\0';
if (p == tmpstr)
break;
memset (&addr[i], 0, sizeof (ADDR));
status_line (">EMSI: parsing addr: '%s'", tmpstr);
(void) find_address (tmpstr, &addr[i]);
status_line (">EMSI: got addr: '%s'", Full_Addr_Str (&addr[i]));
/* sscanf(sptr,"%u:%u/%u.%u",&addr[i].Zone,&addr[i].Net,&addr[i].Node,&addr[i].Point); */
if (Sender && (addr[i].Zone == called_addr.Zone) && (addr[i].Net == called_addr.Net) && (addr[i].Node == called_addr.Node) && (addr[i].Point == called_addr.Point))
remote_addr = addr[i];
if (i < (ALIAS_CNT - 1))
i++;
}
akacnt = i;
if (!remote_addr.Zone || !remote_addr.Net)
remote_addr = addr[0];
while (*sptr++ != '{')
;
i = 0;
while (*sptr != '}')
password[i++] = *sptr++;
password[i] = '\0';
sptr++;
while (*sptr != '}')
{
i = 0;
while ((*sptr != ',') && (*sptr != '}'))
uni[i++] = *sptr++;
uni[i] = '\0';
if (*sptr != '}')
sptr++;
if (!stricmp (uni, "NPU"))
remote_pickup = 0;
else if (!stricmp (uni, "PUP"))
remote_pickup = 1;
else if (!stricmp (uni, "PUA"))
remote_pickup = 2;
}
sptr++;
sptr++;
remote_capabilities = WZ_FREQ;
while (*sptr != '}')
{
i = 0;
while ((*sptr != ',') && (*sptr != '}'))
uni[i++] = *sptr++;
uni[i] = '\0';
if (*sptr != '}')
sptr++;
if (!stricmp (uni, "JAN"))
remote_capabilities |= DOES_IANUS;
#ifdef HAVE_HYDRA
else if (!stricmp (uni, "HYD"))
remote_capabilities |= DOES_HYDRA;
#endif /* HAVE_HYDRA */
else if (!stricmp (uni, "ZAP"))
remote_capabilities |= ZED_ZAPPER;
else if (!stricmp (uni, "ZMO"))
remote_capabilities |= ZED_ZIPPER;
else if (!stricmp (uni, "NRQ"))
remote_capabilities &= ~WZ_FREQ;
}
sptr++;
sptr++;
sscanf (sptr, "%x", &prodcodeT);
/* remote_mailer=prodcode; */
while (*sptr++ != '{')
;
i = 0;
while (*sptr != '}')
uni[i++] = *sptr++;
sptr++;
sptr++;
uni[i++] = ' ';
while (*sptr != '}')
uni[i++] = *sptr++;
sptr++;
sptr++;
uni[i++] = '/';
while (*sptr != '}')
uni[i++] = *sptr++;
if (uni[--i] != '/')
i++;
uni[i] = '\0';
sptr++;
for (;;)
{
if (*sptr != '{')
break;
for (addonnr = 0; addons[addonnr] != NULL; addonnr++)
{
if (!strnicmp (sptr, addons[addonnr], strlen (addons[addonnr])))
break;
}
if (!addons[addonnr]) /* no known addon */
addonnr = 0;
else
addonnr++;
switch (addonnr)
{
case 1: /* {IDENT} system name */
sptr += 9;
name = sptr;
sptr = get_bracket (sptr);
*sptr = '\0';
(void) sprintf (help, "*%s (%s)", name, Full_Addr_Str (&remote_addr));
status_line ("%s", help);
if (akacnt > 1)
{
strcpy (help, ":Aka: ");
for (j = i = 0; i < akacnt; i++)
{
if (!memcmp (&addr[i], &remote_addr, sizeof (ADDR)))
continue;
strcat (help, Full_Addr_Str (&addr[i]));
strcat (help, " ");
if (++j == 3)
{
status_line ("%s", help);
strcpy (help, ": ");
j = 0;
}
}
if (j)
status_line ("%s", help);
}
sptr += 2;
status_line ("%s %s", MSG_TXT (M_REMOTE_USES), uni);
loc = sptr;
sptr = get_bracket (sptr);
*sptr = '\0';
*uni = '\0';
if (loc[0])
sprintf (uni, " from %s", loc);
sptr += 2;
name = sptr;
sptr = get_bracket (sptr);
*sptr = '\0';
if (name[0])
{
status_line (":SysOp: %s%s", name, uni);
/* strcpy (remote_sysop,name); */
}
sptr += 2; /* phone */
name = sptr;
sptr = get_bracket (sptr);
*sptr = '\0';
sptr += 2;
sptr = get_bracket (sptr); /* baud */
*sptr = '\0';
sptr += 2; /* flags */
loc = sptr;
sptr = get_bracket (sptr);
*sptr = '\0';
if (loc[0] && name[0] && strcmp (name, "-Unpublished-"))
{
status_line (" Phone: %s", name);
status_line (" Flags: %s", loc);
}
while (*sptr++ != '}')
;
break;
case 2: /* {TRX#} tranx */
sptr += 8;
name = sptr;
sptr = get_bracket (sptr);
*sptr = '\0';
#ifdef ANSI_TIME_T
status_line (":Tranx: %08lX / %s", etm - ANSI_TIME_T_DELTA, name);
#else
status_line (":Tranx: %08lX / %s", etm, name);
#endif
while (*sptr++ != '}')
;
break;
case 3: /* {MOH#} mail on hold */
sptr += 8;
name = sptr;
sptr = get_bracket (sptr);
*sptr = '\0';
sscanf (name, "%lX", &lmoh);
status_line (">Mail on Hold: %ldb", lmoh);
while (*sptr++ != '}')
;
break;
default: /* any other addon */
name = ++sptr;
while (*sptr != '}')
sptr++; /* goto end of addon string */
*sptr++ = '\0';
loc = ++sptr;
sptr = get_bracket (sptr); /* MB new */
*sptr++ = '\0';
status_line (">Unknown EMSI Addon: %s: {%s}", name, loc);
break;
}
}
remote = remote_addr;
if (!remote_pickup)
status_line (" Remote refused mail-pickup");
if (Sender)
remote_addr = called_addr;
CURRENT = DEFAULT;
for (i = 0; i <= akacnt; i++)
{
status_line (">EMSI: checking addr: '%s'", Full_Addr_Str (&remote_addr));
if ((j = n_getpassword (&remote_addr)) > 0)
{
if (Sender && *remote_password && !*password && (prodcodeT == isDBRIDGE))
j = 0; /* work-around for a D'Bridge(tm)-Bug */
else
j = n_password (password, remote_password, &logit);
status_line (">EMSI: result of pw check: '%d'", j);
if (j == 0)
{
if (highest_level < 2)
{
highest_level = 2;
hl_aka = num_rakas;
}
}
else
{
/*
* Password doesn't match.
*
* Result of 1 means both of us had one.
*
* Result of 2 means we had one and the other side didn't.
*
* If we are the sender we will accept this mismatch,
* but only on the first aka.
*
*/
if ((!Sender) || (num_rakas != 0))
goto next_one;
else
status_line (MSG_TXT (M_PASSWORD_OVERRIDE));
if (highest_level < 1)
{
highest_level = 1;
hl_aka = num_rakas;
}
}
}
else if (j < 0)
{
status_line (">EMSI: addr '%s' will be curmudgeoned", Full_Addr_Str (&remote_addr));
cur = 1;
goto next_one;
}
status_line (">EMSI: checking addr '%s' for dupe", Full_Addr_Str (&remote_addr));
for (j = 0; j < num_rakas; j++)
{
if (get_level (&remote_addr, &(remote_akas[j])) == 3)
goto next_one;
}
status_line (">EMSI: using addr: '%s'", Full_Addr_Str (&remote_addr));
remote_akas[num_rakas++] = remote_addr;
next_one:
remote_addr = addr[i];
}
if (!num_rakas)
{
if (cur)
sptr = MSG_TXT (M_NUISANCE_CALLER);
else
sptr = NULL;
LOWER_DTR (); /* He'll never get it right */
timer (2); /* Wait two secs */
return (0);
}
remote_addr = remote;
return (1);
}
static int LOCALFUNC
Encode_EMSI_Header (char *junkbuff, int Sender)
{
int i, capabilities = 0;
char *uni;
uni = &junkbuff[4096]; /* See why this is OK in Send_EMSI_Packet */
strcpy (junkbuff, "{EMSI}");
b7strcat (junkbuff, "{");
match_aka (&remote_addr); /* Update 'assumed' */
status_line (">Used Aka: %s", Full_Addr_Str (&alias[assumed]));
b7strcat (junkbuff, Full_Addr_Str (&alias[assumed]));
for (i = 0; i < num_addrs; i++)
{
if (i != assumed)
{
b7strcat (junkbuff, " ");
b7strcat (junkbuff, Full_Addr_Str (&alias[i]));
}
}
b7strcat (junkbuff, "}{");
remote_password = NULL;
if ((Sender && (n_getpassword (&remote_addr) > 0)) ||
(!Sender && (n_getpassword (&remote_akas[hl_aka]) > 0)))
{
if (remote_password)
{
(void) strncpy ((char *) uni, remote_password, 8);
uni[8] = '\0';
b7strcat (junkbuff, uni);
}
}
b7strcat (junkbuff, "}{8N1");
if (Sender)
{
if (!no_pickup)
{
if (pickup_all)
b7strcat (junkbuff, ",PUA");
else
b7strcat (junkbuff, ",PUP");
}
else
b7strcat (junkbuff, ",NPU");
}
else
{
if (matrix_mask & NO_TRAFFIC)
b7strcat (junkbuff, ",HAT");
if (!(matrix_mask & TAKE_REQ))
b7strcat (junkbuff, ",HRQ");
}
b7strcat (junkbuff, "}{");
/* At least one ZModem protocol must be available for FSC-0056 ! */
if (!my_capabilities & ZED_ZIPPER)
my_capabilities |= ZED_ZIPPER;
/*
* If we are the calling system, turn on all our capabilities.
* If we are the called system, choose from the set that the
* caller gave us, and only send the one we prefer.
*/
if (!Sender)
{
if (remote_capabilities & my_capabilities & DOES_IANUS)
capabilities = DOES_IANUS;
#ifdef HAVE_HYDRA
else if (remote_capabilities & my_capabilities & DOES_HYDRA)
capabilities = DOES_HYDRA;
#endif /* HAVE_HYDRA */
else if (remote_capabilities & my_capabilities & ZED_ZAPPER)
capabilities = ZED_ZAPPER;
else if (remote_capabilities & my_capabilities & ZED_ZIPPER)
capabilities = ZED_ZIPPER;
}
else
capabilities = my_capabilities;
#ifdef HAVE_HYDRA
if (!capabilities & (DOES_IANUS | DOES_HYDRA | ZED_ZAPPER | ZED_ZIPPER))
#else
if (!capabilities & (DOES_IANUS | ZED_ZAPPER | ZED_ZIPPER))
#endif /* HAVE_HYDRA */
b7strcat (junkbuff, "NCP,");
else if (Sender)
{
if (capabilities & DOES_IANUS)
b7strcat (junkbuff, "JAN,");
#ifdef HAVE_HYDRA
if (capabilities & DOES_HYDRA)
b7strcat (junkbuff, "HYD,");
#endif /* HAVE_HYDRA */
if (capabilities & ZED_ZAPPER)
b7strcat (junkbuff, "ZAP,");
if (capabilities & ZED_ZIPPER)
b7strcat (junkbuff, "ZMO,");
}
else
{
if (capabilities & DOES_IANUS)
b7strcat (junkbuff, "JAN,");
#ifdef HAVE_HYDRA
else if (capabilities & DOES_HYDRA)
b7strcat (junkbuff, "HYD,");
#endif /* HAVE_HYDRA */
else if (capabilities & ZED_ZAPPER)
b7strcat (junkbuff, "ZAP,");
else if (capabilities & ZED_ZIPPER)
b7strcat (junkbuff, "ZMO,");
}
if (!(matrix_mask & TAKE_REQ) || (Sender && !on_our_nickel))
{
b7strcat (junkbuff, "NRQ,");
}
else
capabilities |= WZ_FREQ;
b7strcat (junkbuff, "ARC,XMA");
b7strcat (junkbuff, ",FNC");
b7strcat (junkbuff, "}"); /* MB 93-11-27 */
sprintf (uni, "{%02X}", PRDCT_CODE);
b7strcat (junkbuff, uni);
sprintf (uni, "{%s}", PRDCT_PRTY);
cat_bracket (junkbuff, uni);
sprintf (uni, "{%d.%02d}",
BINK_MAJVERSION, /* vvv */
BINK_MINVERSION);
b7strcat (junkbuff, uni);
sprintf (uni, "{%s}", ((serial == -1) ? MSG_TXT (M_UNREGISTERED) : ""));
cat_bracket (junkbuff, uni);
b7strcat (junkbuff, "{IDENT}{");
sprintf (uni, "[%s]", system_name);
cat_bracket (junkbuff, uni);
sprintf (uni, "[%s]", location); /* vvv */
cat_bracket (junkbuff, uni);
sprintf (uni, "[%s]", sysop);
cat_bracket (junkbuff, uni);
sprintf (uni, "[%s]", myphone);
cat_bracket (junkbuff, uni);
sprintf (uni, "[%s]", mymaxbaud);
cat_bracket (junkbuff, uni);
sprintf (uni, "[%s]", myflags);
cat_bracket (junkbuff, uni); /* MB 93-11-27 */
b7strcat (junkbuff, "}{TRX#}");
#ifdef ANSI_TIME_T
sprintf (uni, "{[%08lX]}", etm - ANSI_TIME_T_DELTA);
#else
sprintf (uni, "{[%08lX]}", etm);
#endif
b7strcat (junkbuff, uni);
return (strlen (junkbuff));
}
/* END OF FILE: emsi.c */
