//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
/* $Header: /CounterStrike/IPX.CPP 1 3/03/97 10:24a Joe_bostic $ */
/***************************************************************************
** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S **
***************************************************************************
* *
* Project Name : Command & Conquer *
* *
* File Name : IPX.CPP *
* *
* Programmer : Barry Nance *
* from Client/Server LAN Programming *
* Westwood-ized by Bill Randolph *
* *
* Start Date : December 14, 1994 *
* *
* Last Update : December 15, 1994 [BR] *
* *
*-------------------------------------------------------------------------*
* Pitfalls: *
* - Never try to use a closed socket; always check the return code from *
* IPX_Open_Socket(). *
* - Always give IPX an outstanding ECB for listening, before you send. *
* - It turns out that IPX is pretty bad about saving registers, so if *
* you have any register variables in your program, they may get *
* trashed. To circumvent this, all functions in this module save & *
* restore the registers before invoking any IPX or NETX function. *
* *
*-------------------------------------------------------------------------*
* Functions: *
* IPX_SPX_Installed -- checks for installation of IPX/SPX *
* IPX_Open_Socket -- opens an IPX socket for sending or receiving *
* IPX_Close_Socket -- closes an open socket *
* IPX_Get_Connection_Number -- gets local Connection Number *
* IPX_Get_1st_Connection_Num -- gets 1st Connect Number for given user *
* IPX_Get_Internet_Address -- gets Network Number & Node Address *
* IPX_Get_User_ID -- gets user ID from Connection Number *
* IPX_Listen_For_Packet -- commands IPX to listen for a packet *
* IPX_Send_Packet -- commands IPX to send a packet *
* IPX_Get_Local_Target -- fills in ImmediateAddress field of ECB *
* IPX_Cancel_Event -- cancels an operation in progress *
* Let_IPX_Breath -- gives IPX some CPU time *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "function.h"
#include <stdio.h>
//#include <mem.h>
//#include <i86.h>
#include "ipx.h"
#ifdef WIN32
#include "ipx95.h"
#endif //WIN32
// Turn off "expression is not meaningful".
//#pragma warning 628 9
/***************************************************************************
* IPX_SPX_Installed -- checks for installation of IPX/SPX *
* *
* INPUT: *
* none. *
* *
* OUTPUT: *
* 0 = not installed; 1 = IPX only, 2 = IPX and SPX are installed *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 12/14/1994 BR : Created. *
*=========================================================================*/
int IPX_SPX_Installed(void)
{
return false;
#ifdef WIN32
#ifdef TIBERIAN_SUN
return(false);
#else
#if (0)//PG
if ( Load_IPX_Dll () ){
return ( IPX_Initialise() );
}else{
return(false);
}
#endif
#endif
#else //WIN32
union REGS regs;
struct SREGS sregs;
RMIType rmi;
//------------------------------------------------------------------------
// Init all registers to 0's
//------------------------------------------------------------------------
memset (®s, 0, sizeof(regs));
segread (&sregs);
memset (&rmi, 0, sizeof(rmi));
//------------------------------------------------------------------------
// Fill in registers for the DPMI call, function 0x300
//------------------------------------------------------------------------
regs.w.ax = DPMI_CALL_REAL_INT; // DPMI function to call
regs.w.bx = 0x002f; // interrupt # to invoke
sregs.es = FP_SEG(&rmi); // tell DPMI where the RMI is
regs.x.edi = FP_OFF(&rmi);
//------------------------------------------------------------------------
// Fill in registers for the real-mode interrupt handler.
// To test for the presence of IPX, set AH to 0x7a, AL to 0, and invoke
// interrupt 0x2f (the "multiplex" interrupt). If IPX is installed,
// AL will be 0xff, and ES:DI will contain the IPX/SPX function address.
//------------------------------------------------------------------------
rmi.eax = 0x00007a00;
//------------------------------------------------------------------------
// call DPMI
//------------------------------------------------------------------------
int386x(DPMI_INT, ®s, ®s, &sregs);
//------------------------------------------------------------------------
// If IPX isn't there, return 0
//------------------------------------------------------------------------
if ( (rmi.eax & 0x00ff) != 0xff) {
return(0);
}
//------------------------------------------------------------------------
// Test for SPX by invoking the IPX_SPX function with BX = 0x10, and AL = 0.
// If SPX is present, AL will be 0xff.
//------------------------------------------------------------------------
//........................................................................
// Fill in registers for the DPMI call
//........................................................................
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
memset (&rmi, 0 ,sizeof(rmi));
regs.w.ax = DPMI_CALL_REAL_INT; // DPMI function to call
regs.w.bx = IPX_INT; // interrupt # to invoke
sregs.es = FP_SEG(&rmi); // tell DPMI where the RMI is
regs.x.edi = FP_OFF(&rmi);
//........................................................................
// Fill in registers for the interrupt call
//........................................................................
rmi.ebx = 0x00000010;
//........................................................................
// call DPMI
//........................................................................
int386x(DPMI_INT, ®s, ®s, &sregs);
//------------------------------------------------------------------------
// SPX is installed; return '2'
//------------------------------------------------------------------------
if ( (rmi.eax & 0x00ff) == 0xff) {
return(2);
}
//------------------------------------------------------------------------
// SPX is not installed; return '1'
//------------------------------------------------------------------------
return(1);
#endif //WIN32
} /* end of IPX_SPX_Installed */
/***************************************************************************
* IPX_Open_Socket -- opens an IPX socket for sending or receiving *
* *
* INPUT: *
* socket the socket number to open *
* *
* OUTPUT: *
* 0 = OK *
* -1 = IPX not installed *
* 0xfe = socket table is full *
* 0xff = socket is already open *
* *
* WARNINGS: *
* The application must define its socket number carefully. Use *
* values from 0x4000 to 0x8000 for custom socket numbers. The app *
* must know its own socket number as well as the socket number of *
* a destination workstation. *
* *
* HISTORY: *
* 12/15/1994 BR : Created. *
*=========================================================================*/
#ifndef WIN32 // WIN32 version is in IPX95.CPP
int IPX_Open_Socket(unsigned short socket)
{
union REGS regs;
struct SREGS sregs;
RMIType rmi;
int rc;
//------------------------------------------------------------------------
// Open the socket:
// DX = socket number
// AL = 0 for short-lived socket, 0xff for long-lived socket
//------------------------------------------------------------------------
//........................................................................
// Fill in registers for the DPMI call
//........................................................................
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
memset (&rmi, 0 ,sizeof(rmi));
regs.w.ax = DPMI_CALL_REAL_INT; // DPMI function to call
regs.w.bx = IPX_INT; // interrupt # to invoke
sregs.es = FP_SEG (&rmi); // tell DPMI where the RMI is
regs.x.edi = FP_OFF (&rmi);
//........................................................................
// Fill in registers for the interrupt call
//........................................................................
rmi.ebx = IPX_OPEN_SOCKET; // function code
rmi.edx = socket; // desired socket #
rmi.eax = 0x00ff; // make this a long-lived socket
//........................................................................
// call DPMI
//........................................................................
int386x (DPMI_INT, ®s, ®s, &sregs);
rc = (rmi.eax & 0xff);
return(rc);
} /* end of IPX_Open_Socket */
#endif //WIN32
/***************************************************************************
* IPX_Close_Socket -- closes an open socket *
* *
* INPUT: *
* socket socket number to close *
* *
* OUTPUT: *
* 0 = ok, -1 = error *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 12/15/1994 BR : Created. *
*=========================================================================*/
#ifndef WIN32 // WIN32 version is in IPX95.CPP
int IPX_Close_Socket(unsigned short socket)
{
union REGS regs;
struct SREGS sregs;
RMIType rmi;
//------------------------------------------------------------------------
// Close the socket:
// DX = socket number
//------------------------------------------------------------------------
//........................................................................
// Fill in registers for the DPMI call
//........................................................................
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
memset (&rmi, 0 ,sizeof(rmi));
regs.w.ax = DPMI_CALL_REAL_INT; // DPMI function to call
regs.w.bx = IPX_INT; // interrupt # to invoke
sregs.es = FP_SEG(&rmi); // tell DPMI where the RMI is
regs.x.edi = FP_OFF(&rmi);
//........................................................................
// Fill in registers for the interrupt call
//........................................................................
rmi.ebx = IPX_CLOSE_SOCKET;
rmi.edx = socket;
//........................................................................
// call DPMI
//........................................................................
int386x(DPMI_INT, ®s, ®s, &sregs);
return(0);
} /* end of IPX_Close_Socket */
#endif //WIN32
/***************************************************************************
* IPX_Get_Connection_Number -- gets local Connection Number *
* *
* This Novell call will the return the user's local "Connection Number". *
* This value will be 0 if the user isn't logged into Novell, so this *
* routine can be used to detect if other calls (such as Get_Local_Target) *
* will be OK. *
* *
* INPUT: *
* none. *
* *
* OUTPUT: *
* Connection Number, 0 = none *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 12/15/1994 BR : Created. *
*=========================================================================*/
#ifndef WIN32 // WIN32 version is in IPX95.CPP
int IPX_Get_Connection_Number(void)
{
union REGS regs;
struct SREGS sregs;
RMIType rmi;
int num;
//------------------------------------------------------------------------
// Call Interrupt 0x21, with AH = 0xdc. This tells Novell to put the local
// connection number into AL.
//------------------------------------------------------------------------
//........................................................................
// Fill in registers for the DPMI call
//........................................................................
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
memset (&rmi, 0 ,sizeof(rmi));
regs.w.ax = DPMI_CALL_REAL_INT; // DPMI function to call
regs.w.bx = 0x21; // interrupt # to invoke
sregs.es = FP_SEG(&rmi); // tell DPMI where the RMI is
regs.x.edi = FP_OFF(&rmi);
//........................................................................
// Fill in registers for the interrupt call
//........................................................................
rmi.eax = 0x0000dc00;
//........................................................................
// call DPMI
//........................................................................
int386x(DPMI_INT, ®s, ®s, &sregs);
num = rmi.eax & 0x00ff;
return(num);
} /* end of IPX_Get_Connection_Number */
#endif //WIN32
/***************************************************************************
* IPX_Get_1st_Connection_Num -- gets 1st Connect Number for given user *
* *
* This gets the Connection Number for the given User ID. Since a user *
* may be logged in more than once, this just returns the first connection *
* found and ignores the others. *
* *
* INPUT: *
* username name of the user to get the Connection Number for *
* *
* OUTPUT: *
* first-found Connection Number for that user, 0 if user not logged in *
* *
* WARNINGS: *
* *
* HISTORY: *
* 12/15/1994 BR : Created. *
*=========================================================================*/
#ifndef WIN32 // WIN32 version is in IPX95.CPP
int IPX_Get_1st_Connection_Num (char * username)
{
struct request_buffer {
unsigned short len; // username length + 5
unsigned char buffer_type; // ConnectionNum = 0x15
unsigned short object_type; // set ot 0x0100
unsigned char name_len; // length of username
char name [48]; // copy of username
unsigned short reserved;
};
struct reply_buffer {
unsigned short len;
unsigned char number_connections; // will be 0 - 100
unsigned char connection_num [100]; // array of connection numbers
unsigned short reserved[2];
};
union REGS regs;
struct SREGS sregs;
RMIType rmi;
struct request_buffer * reqbuf;
struct reply_buffer * replybuf;
unsigned short segment; // for DOS allocation
unsigned short selector; // for DOS allocation
int num_conns; // # connections returned
int conn_num; // connection number
int rc;
//------------------------------------------------------------------------
// Allocate DOS memory to store the buffers passed to the interrupt
//------------------------------------------------------------------------
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
regs.x.eax = DPMI_ALLOC_DOS_MEM; // DPMI function to call
regs.x.ebx = (sizeof(struct request_buffer) + // # paragraphs to allocate
sizeof(struct reply_buffer) + 15) >> 4;
int386x (DPMI_INT, ®s, ®s, &sregs); // allocate the memory
//------------------------------------------------------------------------
// If the carry flag is set, DPMI is indicating an error.
//------------------------------------------------------------------------
if (regs.x.cflag) {
return(0);
}
//------------------------------------------------------------------------
// Get pointers to allocated memory.
// 'reqbuf' is just the returned real-mode segment, multiplied by 16.
// 'replybuf' is an offset from 'reqbuf'.
//------------------------------------------------------------------------
segment = regs.w.ax;
selector = regs.w.dx;
reqbuf = (struct request_buffer *)(segment << 4);
replybuf = (struct reply_buffer *)
(((char *)reqbuf) + sizeof (struct request_buffer));
//------------------------------------------------------------------------
// Init the contents of the request & reply buffers
//------------------------------------------------------------------------
reqbuf->len = (unsigned short)(strlen(username) + 5);
reqbuf->buffer_type = 0x15;
reqbuf->object_type = 0x0100;
reqbuf->name_len = (unsigned char) strlen(username);
strcpy(reqbuf->name, username);
reqbuf->reserved = reqbuf->reserved; // prevent compiler warning
replybuf->len = 101;
replybuf->reserved[0] = replybuf->reserved[0]; // prevent compiler warning
replybuf->reserved[0] = replybuf->reserved[1]; // prevent compiler warning
//------------------------------------------------------------------------
// Invoke Int 21 with AH=0xe3, DS:SI=&request_buffer, ES:DI=&reply_buffer
//------------------------------------------------------------------------
//........................................................................
// Fill in registers for the DPMI call
//........................................................................
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
memset (&rmi, 0 ,sizeof(rmi));
regs.w.ax = DPMI_CALL_REAL_INT; // DPMI function to call
regs.w.bx = 0x21; // interrupt # to invoke
sregs.es = FP_SEG(&rmi); // tell DPMI where the RMI is
regs.x.edi = FP_OFF(&rmi);
//........................................................................
// Fill in registers for the interrupt call
//........................................................................
rmi.eax = 0x0000e300;
rmi.ds = segment;
rmi.esi = 0;
rmi.es = segment;
rmi.edi = sizeof(struct request_buffer);
//........................................................................
// call DPMI
//........................................................................
int386x(DPMI_INT, ®s, ®s, &sregs);
//------------------------------------------------------------------------
// Stash the 1st connection number
//------------------------------------------------------------------------
rc = (rmi.eax & 0x00ff); // if AL !=0, error
num_conns = replybuf->number_connections; // # times user is logged in
conn_num = (int )replybuf->connection_num[0]; // 1st connection #
//------------------------------------------------------------------------
// Free DOS memory
//------------------------------------------------------------------------
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
regs.x.eax = DPMI_FREE_DOS_MEM; // DPMI function to call
regs.x.edx = selector; // ptr to free
int386x (DPMI_INT, ®s, ®s, &sregs); // allocate the memory
//------------------------------------------------------------------------
// Return error if function failed, or user not logged in
//------------------------------------------------------------------------
if (rc != 0 || num_conns==0) {
return(0);
}
else {
return(conn_num);
}
} /* end of IPX_Get_1st_Connection_Num */
#endif //WIN32
/***************************************************************************
* IPX_Get_Internet_Address -- gets Network Number & Node Address *
* *
* Once you've obtained a Connection Number from IPX_Get_Connection_Number *
* or IPX_Get_1st_Connection_Num, use this function to translate it into *
* a Network Number and Node Address; then, place those numbers in the *
* IPX header for outgoing packets. *
* *
* INPUT: *
* connection_number Connection Number to translate *
* network_number ptr: will hold Network Number *
* physical_node ptr: will hold Node Address *
* *
* OUTPUT: *
* 0 = OK, -1 = error *
* *
* WARNINGS: *
* If connection_number is 0 and NETX isn't running, this routine *
* will just put garbage into the network_number and physical_node. *
* *
* HISTORY: *
* 12/15/1994 BR : Created. *
*=========================================================================*/
#ifndef WIN32 // WIN32 version is in IPX95.CPP
int IPX_Get_Internet_Address(int connection_number,
unsigned char * network_number, unsigned char * physical_node)
{
struct request_buffer {
unsigned short len;
unsigned char buffer_type; // Internet = 0x13
unsigned char connection_number; // Conn. Number to translate
};
struct reply_buffer {
unsigned short len;
unsigned char network_number [4]; // filled in by IPX
unsigned char physical_node [6]; // filled in by IPX
unsigned short server_socket; // filled in by IPX, but don't use!
};
union REGS regs;
struct SREGS sregs;
RMIType rmi;
struct request_buffer * reqbuf;
struct reply_buffer * replybuf;
unsigned short segment; // for DOS allocation
unsigned short selector; // for DOS allocation
//------------------------------------------------------------------------
// Error if invalid connection is given
//------------------------------------------------------------------------
if (connection_number==0) {
return(-1);
}
//------------------------------------------------------------------------
// Allocate DOS memory to store the buffers passed to the interrupt
//------------------------------------------------------------------------
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
regs.x.eax = DPMI_ALLOC_DOS_MEM; // DPMI function to call
regs.x.ebx = (sizeof(struct request_buffer) + // # paragraphs to allocate
sizeof(struct reply_buffer) + 15) >> 4;
int386x (DPMI_INT, ®s, ®s, &sregs); // allocate the memory
//------------------------------------------------------------------------
// If the carry flag is set, DPMI is indicating an error.
//------------------------------------------------------------------------
if (regs.x.cflag) {
return(-1);
}
//------------------------------------------------------------------------
// Get pointers to allocated memory.
// 'reqbuf' is just the returned real-mode segment, multiplied by 16.
// 'replybuf' is an offset from 'reqbuf'.
//------------------------------------------------------------------------
segment = regs.w.ax;
selector = regs.w.dx;
reqbuf = (struct request_buffer *)(segment << 4);
replybuf = (struct reply_buffer *)
(((char *)reqbuf) + sizeof (struct request_buffer));
//------------------------------------------------------------------------
// Init the contents of the request & reply buffers
//------------------------------------------------------------------------
reqbuf->len = 2;
reqbuf->buffer_type = 0x13;
reqbuf->connection_number = (unsigned char)connection_number;
replybuf->len = 12;
replybuf->network_number[0] = replybuf->network_number[0]; // suppress warning
replybuf->physical_node[0] = replybuf->physical_node[0]; // suppress warning
replybuf->server_socket = replybuf->server_socket; // suppress warning
//------------------------------------------------------------------------
// Invoke Int 21 with AH=0xe3, DS:SI=&request_buffer, ES:DI=&reply_buffer
//------------------------------------------------------------------------
//........................................................................
// Fill in registers for the DPMI call
//........................................................................
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
memset (&rmi, 0 ,sizeof(rmi));
regs.w.ax = DPMI_CALL_REAL_INT; // DPMI function to call
regs.w.bx = 0x21; // interrupt # to invoke
sregs.es = FP_SEG(&rmi); // tell DPMI where the RMI is
regs.x.edi = FP_OFF(&rmi);
//........................................................................
// Fill in registers for the interrupt call
//........................................................................
rmi.eax = 0x0000e300;
rmi.ds = segment;
rmi.esi = 0;
rmi.es = segment;
rmi.edi = sizeof(struct request_buffer);
//........................................................................
// call DPMI
//........................................................................
int386x(DPMI_INT, ®s, ®s, &sregs);
memcpy(network_number, replybuf->network_number, 4);
memcpy(physical_node, replybuf->physical_node, 6);
//------------------------------------------------------------------------
// Free DOS memory
//------------------------------------------------------------------------
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
regs.x.eax = DPMI_FREE_DOS_MEM; // DPMI function to call
regs.x.edx = selector; // ptr to free
int386x (DPMI_INT, ®s, ®s, &sregs); // allocate the memory
return(0);
} /* end of IPX_Get_Internet_Address */
#endif //WIN32
/***************************************************************************
* IPX_Get_User_ID -- gets user ID from Connection Number *
* *
* INPUT: *
* connection_number Connection Number to get User ID for *
* user_id ptr to buffer to put User ID into; *
* size must be >= 48 chars *
* *
* OUTPUT: *
* 0 = OK, -1 = error *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 12/15/1994 BR : Created. *
*=========================================================================*/
#ifndef WIN32 // WIN32 version is in IPX95.CPP
int IPX_Get_User_ID(int connection_number, char * user_id)
{
struct request_buffer {
unsigned short len;
unsigned char buffer_type; // 0x16 = UserID buffer type
unsigned char connection_number; // Connection Number to get ID for
};
struct reply_buffer {
unsigned short len;
unsigned char object_id[4];
unsigned char object_type[2];
char object_name[48];
char login_time[7];
unsigned short reserved;
};
union REGS regs;
struct SREGS sregs;
RMIType rmi;
struct request_buffer * reqbuf;
struct reply_buffer * replybuf;
unsigned short segment; // for DOS allocation
unsigned short selector; // for DOS allocation
//------------------------------------------------------------------------
// Error if invalid connection is given
//------------------------------------------------------------------------
if (connection_number==0) {
return(-1);
}
//------------------------------------------------------------------------
// Allocate DOS memory to store the buffers passed to the interrupt
//------------------------------------------------------------------------
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
regs.x.eax = DPMI_ALLOC_DOS_MEM; // DPMI function to call
regs.x.ebx = (sizeof(struct request_buffer) + // # paragraphs to allocate
sizeof(struct reply_buffer) + 15) >> 4;
int386x (DPMI_INT, ®s, ®s, &sregs); // allocate the memory
//------------------------------------------------------------------------
// If the carry flag is set, DPMI is indicating an error.
//------------------------------------------------------------------------
if (regs.x.cflag) {
return(-1);
}
//------------------------------------------------------------------------
// Get pointers to allocated memory.
// 'reqbuf' is just the returned real-mode segment, multiplied by 16.
// 'replybuf' is an offset from 'reqbuf'.
//------------------------------------------------------------------------
segment = regs.w.ax;
selector = regs.w.dx;
reqbuf = (struct request_buffer *)(segment << 4);
replybuf = (struct reply_buffer *)
(((char *)reqbuf) + sizeof (struct request_buffer));
//------------------------------------------------------------------------
// Init the contents of the request & reply buffers
//------------------------------------------------------------------------
reqbuf->len = 2;
reqbuf->buffer_type = 0x16;
reqbuf->connection_number = (unsigned char)connection_number;
replybuf->len = sizeof(struct reply_buffer) - 2;
replybuf->object_id[0] = replybuf->object_id[0]; // suppress warnings
replybuf->object_type[0] = replybuf->object_type[0]; // suppress warnings
replybuf->login_time[0] = replybuf->login_time[0]; // suppress warnings
replybuf->reserved = replybuf->reserved; // suppress warnings
//------------------------------------------------------------------------
// Invoke Int 21 with AH=0xe3, DS:SI=&request_buffer, ES:DI=&reply_buffer
//------------------------------------------------------------------------
//........................................................................
// Fill in registers for the DPMI call
//........................................................................
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
memset (&rmi, 0 ,sizeof(rmi));
regs.w.ax = DPMI_CALL_REAL_INT; // DPMI function to call
regs.w.bx = 0x21; // interrupt # to invoke
sregs.es = FP_SEG(&rmi); // tell DPMI where the RMI is
regs.x.edi = FP_OFF(&rmi);
//........................................................................
// Fill in registers for the interrupt call
//........................................................................
rmi.eax = 0x0000e300;
rmi.ds = segment;
rmi.esi = 0;
rmi.es = segment;
rmi.edi = sizeof(struct request_buffer);
//........................................................................
// call DPMI
//........................................................................
int386x(DPMI_INT, ®s, ®s, &sregs);
//------------------------------------------------------------------------
// Fill in the caller's buffer with the user name
//------------------------------------------------------------------------
strncpy(user_id, replybuf->object_name, 48);
//------------------------------------------------------------------------
// Free DOS memory
//------------------------------------------------------------------------
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
regs.x.eax = DPMI_FREE_DOS_MEM; // DPMI function to call
regs.x.edx = selector; // ptr to free
int386x (DPMI_INT, ®s, ®s, &sregs); // allocate the memory
return(0);
} /* end of IPX_Get_User_ID */
#endif //WIN32
/***************************************************************************
* IPX_Listen_For_Packet -- commands IPX to listen for a packet *
* *
* Before calling this function, you must fill in an ECB: *
* SocketNumber: must contain the socket you've opened, *
* and are "listening" on *
* Event_Service_Routine: optionally points to a callback routine *
* PacketCount: set to 2, to tell IPX there are 2 areas to *
* store the incoming data in *
* Packet[0].Address: set to the address of an IPXHeaderType *
* Packet[0].Length: sizeof(IPXHeaderType) *
* Packet[1].Address: address of data buffer, for the packet *
* Packet[1].Length: size of the data buffer *
* *
* When the packet is received, ECBType.CompletionCode will be 0 if *
* successful. Otherwise, some error occurred. *
* *
* You should initialize the ECB to 0's before filling it in. *
* *
* INPUT: *
* ecb_ptr pointer to a filled-in ECB; MUST be real-mode memory *
* *
* OUTPUT: *
* 0 = OK, IPX error otherwise *
* *
* WARNINGS: *
* The ECB must be located in real-mode memory, as well as the values *
* pointed to in the ECB (the IPX Header, the buffer to send, etc.) *
* *
* HISTORY: *
* 12/15/1994 BR : Created. *
*=========================================================================*/
#ifndef WIN32 // WIN32 version is in IPX95.CPP
int IPX_Listen_For_Packet(struct ECB *ecb_ptr)
{
union REGS regs;
struct SREGS sregs;
RMIType rmi;
//------------------------------------------------------------------------
// Call IPX with ES:SI=ecb_ptr
//------------------------------------------------------------------------
//........................................................................
// Fill in registers for the DPMI call
//........................................................................
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
memset (&rmi, 0 ,sizeof(rmi));
regs.w.ax = DPMI_CALL_REAL_INT; // DPMI function to call
regs.w.bx = IPX_INT; // interrupt # to invoke
sregs.es = FP_SEG(&rmi); // tell DPMI where the RMI is
regs.x.edi = FP_OFF(&rmi);
//........................................................................
// Fill in registers for the interrupt call
//........................................................................
rmi.ebx = IPX_LISTEN_FOR_PACKET;
rmi.es = (short)((long)ecb_ptr >> 4);
rmi.esi = (long)((long)ecb_ptr & 0x000f);
//........................................................................
// call DPMI
//........................................................................
int386x(DPMI_INT, ®s, ®s, &sregs);
return(rmi.eax & 0x00ff);
} /* end of IPX_Listen_For_Packet */
#endif //WIN32
/***************************************************************************
* IPX_Send_Packet -- commands IPX to send a packet *
* *
* Before calling this function, you must fill in an ECB: *
* SocketNumber: must contain the socket you've opened, *
* and are sending on *
* Event_Service_Routine: optionally points to a callback routine *
* PacketCount: set to 2, to tell IPX there are 2 areas the *
* outgoing data is stored in *
* Packet[0].Address: set to the address of an IPXHeaderType *
* Packet[0].Length: sizeof(IPXHeaderType) *
* Packet[1].Address: address of buffer containing data to send *
* Packet[1].Length: size of the data buffer *
* ImmediateAddress: must be filled in with the node address of *
* the bridge that will route the message; *
* fill this in by calling IPX_Get_Local_Target *
* *
* Also, you must fill in the IPXHeaderType with certain values: *
* PacketType: set to 4 for IPX *
* DestNetworkNumber: Network Number of the destination system *
* DestNetworkNode: Node Address of the destination system *
* DestNetworkSocket: the destination system's socket to send to; *
* this doesn't have to be the same as the *
* socket opened on the local machine. *
* *
* You should initialize the ECB & IPXHeader to 0's before filling them in.*
* *
* INPUT: *
* ecb_ptr pointer to a filled-in ECB *
* *
* OUTPUT: *
* none. This function doesn't return anything; the caller must check *
* its ECB.CompletionCode for: 0 = OK, IPX Error otherwise. *
* *
* WARNINGS: *
* The ECB must be located in real-mode memory, as well as the values *
* pointed to in the ECB (the IPX Header, the buffer to send, etc.) *
* *
* HISTORY: *
* 12/15/1994 BR : Created. *
*=========================================================================*/
#ifndef WIN32 // WIN32 version is in IPX95.CPP
void IPX_Send_Packet(struct ECB *ecb_ptr)
{
union REGS regs;
struct SREGS sregs;
RMIType rmi;
//------------------------------------------------------------------------
// Call IPX with ES:SI=ecb_ptr
//------------------------------------------------------------------------
//........................................................................
// Fill in registers for the DPMI call
//........................................................................
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
memset (&rmi, 0 ,sizeof(rmi));
regs.w.ax = DPMI_CALL_REAL_INT; // DPMI function to call
regs.w.bx = IPX_INT; // interrupt # to invoke
sregs.es = FP_SEG(&rmi); // tell DPMI where the RMI is
regs.x.edi = FP_OFF(&rmi);
//........................................................................
// Fill in registers for the interrupt call
//........................................................................
rmi.ebx = IPX_SEND_PACKET;
rmi.es = (short)((long)ecb_ptr >> 4);
rmi.esi = (long)((long)ecb_ptr & 0x000f);
//........................................................................
// call DPMI
//........................................................................
int386x(DPMI_INT, ®s, ®s, &sregs);
} /* end of IPX_Send_Packet */
#endif //WIN32
/***************************************************************************
* IPX_Get_Local_Target -- fills in ImmediateAddress field of ECB *
* *
* Use this function to fill in the ECB's ImmediateAddress field when *
* sending a packet. The Immediate Address is the node address of the *
* bridge that must route the message. If there is no bridge, it's *
* filled in with the destination Node Address. In either case, it *
* will contain the proper value for sending. *
* *
* INPUT: *
* dest_network destination Network Number *
* dest_node destination Node Address *
* dest_socket destination Socket Number *
* bridge_address field to fill in with Immediate Address *
* *
* OUTPUT: *
* 0 = OK, error otherwise *
* *
* WARNINGS: *
* If the Connection Number is 0 (user not logged in), dest_network *
* and dest_node will be garbage, and this routine will probably crash. *
* *
* HISTORY: *
* 12/15/1994 BR : Created. *
*=========================================================================*/
#ifndef WIN32 // WIN32 version is in IPX95.CPP
int IPX_Get_Local_Target(unsigned char *dest_network, unsigned char *dest_node,
unsigned short dest_socket, unsigned char *bridge_address)
{
struct request_buffer {
unsigned char network_number [4];
unsigned char physical_node [6];
unsigned short socket;
};
struct reply_buffer {
unsigned char local_target [6];
};
unsigned int rc;
union REGS regs;
struct SREGS sregs;
RMIType rmi;
struct request_buffer *reqbuf;
struct reply_buffer *replybuf;
unsigned short segment; // for DOS allocation
unsigned short selector; // for DOS allocation
//------------------------------------------------------------------------
// Allocate DOS memory to store the buffers passed to the interrupt
//------------------------------------------------------------------------
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
regs.x.eax = DPMI_ALLOC_DOS_MEM; // DPMI function to call
regs.x.ebx = (sizeof(struct request_buffer) + // # paragraphs to allocate
sizeof(struct reply_buffer) + 15) >> 4;
int386x (DPMI_INT, ®s, ®s, &sregs); // allocate the memory
//------------------------------------------------------------------------
// If the carry flag is set, DPMI is indicating an error.
//------------------------------------------------------------------------
if (regs.x.cflag) {
return(-1);
}
//------------------------------------------------------------------------
// Get pointers to allocated memory.
// 'reqbuf' is just the returned real-mode segment, multiplied by 16.
// 'replybuf' is an offset from 'reqbuf'.
//------------------------------------------------------------------------
segment = regs.w.ax;
selector = regs.w.dx;
reqbuf = (struct request_buffer *)(segment << 4);
replybuf = (struct reply_buffer *)
(((char *)reqbuf) + sizeof (struct request_buffer));
//------------------------------------------------------------------------
// Init the contents of the request & reply buffers
//------------------------------------------------------------------------
memcpy(reqbuf->network_number, dest_network, 4);
memcpy(reqbuf->physical_node, dest_node, 6);
reqbuf->socket = dest_socket;
//------------------------------------------------------------------------
// Invoke IPX with DS:SI=&request_buffer, ES:DI=&reply_buffer
//------------------------------------------------------------------------
//........................................................................
// Fill in registers for the DPMI call
//........................................................................
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
memset (&rmi, 0 ,sizeof(rmi));
regs.w.ax = DPMI_CALL_REAL_INT; // DPMI function to call
regs.w.bx = IPX_INT; // interrupt # to invoke
sregs.es = FP_SEG(&rmi); // tell DPMI where the RMI is
regs.x.edi = FP_OFF(&rmi);
//........................................................................
// Fill in registers for the interrupt call
//........................................................................
rmi.ebx = IPX_GET_LOCAL_TARGET;
rmi.ds = segment;
rmi.esi = 0;
rmi.es = segment;
rmi.edi = sizeof(struct request_buffer);
//........................................................................
// call DPMI
//........................................................................
int386x(DPMI_INT, ®s, ®s, &sregs);
rc = (rmi.eax & 0x00ff);
memcpy(bridge_address, replybuf->local_target, 6);
//------------------------------------------------------------------------
// Free DOS memory
//------------------------------------------------------------------------
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
regs.x.eax = DPMI_FREE_DOS_MEM; // DPMI function to call
regs.x.edx = selector; // ptr to free
int386x (DPMI_INT, ®s, ®s, &sregs); // allocate the memory
return(rc);
} /* end of IPX_Get_Local_Target */
#endif //WIN32
/***************************************************************************
* IPX_Cancel_Event -- cancels an operation in progress *
* *
* INPUT: *
* ecb_ptr pointer to ECB event to cancel *
* *
* OUTPUT: *
* ??? *
* *
* WARNINGS: *
* The ECB must be located in real-mode memory, as well as the values *
* pointed to in the ECB (the IPX Header, the buffer to send, etc.) *
* *
* HISTORY: *
* 12/15/1994 BR : Created. *
*=========================================================================*/
#ifndef WIN32 // WIN32 version is in IPX95.CPP
int IPX_Cancel_Event(struct ECB *ecb_ptr)
{
union REGS regs;
struct SREGS sregs;
RMIType rmi;
unsigned int rc;
//------------------------------------------------------------------------
// Fill in registers for the DPMI call
//------------------------------------------------------------------------
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
memset (&rmi, 0 ,sizeof(rmi));
regs.w.ax = DPMI_CALL_REAL_INT; // DPMI function to call
regs.w.bx = IPX_INT; // interrupt # to invoke
sregs.es = FP_SEG(&rmi); // tell DPMI where the RMI is
regs.x.edi = FP_OFF(&rmi);
//------------------------------------------------------------------------
// Fill in registers for the interrupt call
//------------------------------------------------------------------------
rmi.ebx = IPX_CANCEL_EVENT;
rmi.es = (short)((long)ecb_ptr >> 4);
rmi.esi = (long)((long)ecb_ptr & 0x000f);
//------------------------------------------------------------------------
// call DPMI
//------------------------------------------------------------------------
int386x(DPMI_INT, ®s, ®s, &sregs);
rc = (rmi.eax & 0x00ff);
return(rc);
} /* end of IPX_Cancel_Event */
#endif //WIN32
/***************************************************************************
* Let_IPX_Breath -- gives IPX some CPU time *
* *
* Use this function if you're polling the ECB's InUse flag, waiting *
* for it to go to 0: *
* *
* while ECBType.InUse *
* Let_IPX_Breath(); *
* *
* INPUT: *
* none. *
* *
* OUTPUT: *
* none. *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 12/15/1994 BR : Created. *
*=========================================================================*/
#ifndef WIN32 // WIN32 version is in IPX95.CPP
void Let_IPX_Breath(void)
{
union REGS regs;
struct SREGS sregs;
RMIType rmi;
//------------------------------------------------------------------------
// Fill in registers for the DPMI call
//------------------------------------------------------------------------
memset (®s, 0 ,sizeof(regs));
segread (&sregs);
memset (&rmi, 0 ,sizeof(rmi));
regs.w.ax = DPMI_CALL_REAL_INT; // DPMI function to call
regs.w.bx = IPX_INT; // interrupt # to invoke
sregs.es = FP_SEG(&rmi); // tell DPMI where the RMI is
regs.x.edi = FP_OFF(&rmi);
//------------------------------------------------------------------------
// Fill in registers for the interrupt call
//------------------------------------------------------------------------
rmi.ebx = IPX_RELINQUISH_CONTROL;
//------------------------------------------------------------------------
// call DPMI
//------------------------------------------------------------------------
int386x(DPMI_INT, ®s, ®s, &sregs);
} /* end of Let_IPX_Breath */
#endif //WIN32
/**************************** end of ipx.cpp *******************************/