Mail Archives: djgpp/2000/04/04/20:54:31
| Message-ID: | <38EA73A3.9EF2D357@hotmail.com>
|
| From: | Andrew Hakman <hakmana AT hotmail DOT com>
|
| X-Mailer: | Mozilla 4.7 [en] (WinNT; I)
|
| X-Accept-Language: | en
|
| MIME-Version: | 1.0
|
| Newsgroups: | comp.os.msdos.djgpp
|
| Subject: | How to distinguish a DS register being used
|
| Lines: | 1118
|
| Date: | Tue, 04 Apr 2000 22:58:54 GMT
|
| NNTP-Posting-Host: | 142.13.16.203
|
| X-Trace: | typhoon.mbnet.mb.ca 954889134 142.13.16.203 (Tue, 04 Apr 2000 17:58:54 CDT)
|
| NNTP-Posting-Date: | Tue, 04 Apr 2000 17:58:54 CDT
|
| Organization: | MBnet Networking Inc.
|
| To: | djgpp AT delorie DOT com
|
| DJ-Gateway: | from newsgroup comp.os.msdos.djgpp
|
| Reply-To: | djgpp AT delorie DOT com
|
This is a multi-part message in MIME format.
--------------F29025F971749F34679C5972
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
I'll post this again (just wondering if you missed it because of the RE
in the subject line!?) If you can't for whatever reason, just let me
know.
Hi!
Thanks for the help. I sort of understand what you mean (just beginning
to learn assembly - just finished implementing a "teaching" asember
language with only 53 opcodes, 4 registers, and 1000 memory locations in
DJGPP for discrete structures and programming course I'm taking), but
can't seem to find anything related in the code. Would you be kind
enough to look at it for me
(the source isn't TOO big and I re-spaced and reindented it so it is
actually readable!!) or tell me how I could find where the DS register
is referenced? (I have searched the file for "DS" but can't find any
references) I see some of the other registers like ES, but can't find
any mention of DS.
If you could do this for me, that would be awesome!
Thanks so much
Andrew Hakman
Eli Zaretskii wrote:
> On Mon, 3 Apr 2000, Andrew Hakman wrote:
>
> > Now that I got 387 emulation working, I get the following page fault
> > (only when the program is run on a computer that requires 387
emulation
> > - run the exact same exe on a 486 and it runs great!):
> >
> > Page Fault cr2=10000002 in RMCB at eip=0; flags=3006 eax=0 ebx=4f
ecx=0
> > edx=34868 esi=3ebbc edi=34808 ebp=7 esp=c4044 cs=2b ds=b7 es=b7
fs=b7
> > gs=b7 ss=b7 error=0004
>
> The cr2 value is the address where the Page Fault happened. It means
> that the program tried to dereference a NULL pointer (value of 2
instead
> of zero, actually).
>
> Since this happens only under emulation, I suspect that the IPX
library
> uses the DS selector inside some interrupt handler. The problem with
> that is that the FP emulator works by triggering an exception, which
it
> does by invalidating the DS selector. So any interrupt handler should
> use the alias selector stored in the __djgpp_ds_alias variable instead
> of DS. The alias selector points to the same memory, but it is always
> valid.
--------------F29025F971749F34679C5972
Content-Type: text/plain; charset=us-ascii;
name="jonipx.h"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
filename="jonipx.h"
#ifndef JONIPX_H
#define JONIPX_H
#include <dos.h> /* For delay */
#define MY_SOCKET 0x869C /* Socket used by these routines */
#define MAX_PACKETS_IN_BUFFER 100
/* Amount we delay between sending packets */
#define IPX_DELAY 3
#define WAITING_FOR_NODES_PACKET 10
#define PLAYER_NUMBER_ASSIGNMENT_PACKET 11
#define HERE_I_AM_PACKET 12
#define GAME_INIT_PACKET 13
#define BIG_ASS_GAME_INFO_PACKET 14
#define READY_PACKET 15 /* Indicates we are ready to move on */
#define SERVER_INPUT_TABLE_PACKET 16
#define CLIENT_INPUT_TABLE_PACKET 17
#define WAITING_FOR_INPUT_TABLE_PACKET 18
#define TEAM_REQUEST_PACKET 19
#define TEAM_ASSIGNMENT_PACKET 20
#define WAITING_FOR_TEAM_REQUEST_PACKET 21
#define PLAYER_INFO_PACKET 22
#define CYLINDER_FILENAME_PACKET 23
#define TERMINATE_IPX_CONNECTION_PACKET 24
#define END_IPX_GAME_PACKET 25
#define TRUE 1
#define FALSE 0
typedef unsigned char boolean;
typedef unsigned char net_type[4];
typedef unsigned char node_address_type[6];
typedef char string_type[80];
typedef unsigned short address_type[2];
typedef struct
{
net_type net __attribute__((packed)); /* Network address */
node_address_type node_address __attribute__((packed)); /* Node address */
unsigned short socket __attribute__((packed)); /* Big endian socket number */
} net_address_type;
typedef struct
{
net_type net __attribute__((packed)); /* My network address */
node_address_type node_address __attribute__((packed)); /* My node address */
} local_address_type;
typedef struct
{
address_type link __attribute__((packed)); /* Pointer to next ECB */
unsigned long ESR __attribute__((packed)); /* Event service routine 00000000h if none */
unsigned char in_use __attribute__((packed)); /* In use flag */
unsigned char complete __attribute__((packed)); /* Completing flag */
unsigned short socket __attribute__((packed)); /* Big endian socket number */
unsigned char IPX_work[4] __attribute__((packed)); /* IPX work space */
unsigned char D_work[12] __attribute__((packed)); /* Driver work space */
node_address_type immediate_address __attribute__((packed)); /* Immediate local node address */
unsigned short fragment_count __attribute__((packed)); /* Fragment count */
unsigned long fragment_data __attribute__((packed)); /* Pointer to data fragment */
unsigned short fragment_size __attribute__((packed)); /* Size of data fragment */
} ECB_type;
typedef struct
{
unsigned short checksum __attribute__((packed)); /* Big endian checksum */
unsigned short length __attribute__((packed)); /* Big endian length in bytes */
unsigned char transport_control __attribute__((packed)); /* Transport control */
unsigned char packet_type __attribute__((packed)); /* Packet type */
net_address_type destination __attribute__((packed)); /* Destination network address */
net_address_type source __attribute__((packed)); /* Source network address */
} IPX_header_type;
/* Used internally */
typedef struct
{
ECB_type ecb __attribute__((packed));
IPX_header_type ipx_header __attribute__((packed));
string_type string __attribute__((packed));
double data1 __attribute__((packed));
double data2 __attribute__((packed));
double data3 __attribute__((packed));
} packet_type;
/* Generally the user will use this for packets */
typedef struct
{
double data1;
double data2;
double data3;
string_type string;
node_address_type source_node;
} game_packet_type;
/* This is used by the pop_packet routines...packets are placed here
by a callback whenever a packet is recieved by the driver */
typedef struct
{
game_packet_type packets[MAX_PACKETS_IN_BUFFER]; /* Array of packets */
unsigned short buffer_start; /* The last packet we read */
unsigned short buffer_pos; /* The most recent packet */
} packet_buffer_type;
int Compare_Nodes (node_address_type node_one, node_address_type node_two);
unsigned short Endian_Swap (unsigned short old_short);
int IPX_Open_Socket (unsigned char longetivity, unsigned short *socket_number);
void IPX_Close_Socket (unsigned short *socket_number);
void Get_Local_Address();
void IPX_Send_Packet (ECB_type *ecb);
int IPX_Listen_For_Packet (ECB_type *ecb);
void Im_Idle ();
void Init_Send_Packet (ECB_type *ecb, IPX_header_type *ipx_header, unsigned short size, unsigned short sock);
void Init_Recieve_Packet (ECB_type *ecb, IPX_header_type *ipx_header, unsigned short size, unsigned short sock);
int Init_IPX (void);
//int Jon_Get_Packet (string_type string, double data1, double data2, double data3, node_address_type source_node);
/* These are the functions you will most likely use */
int Init_Jonipx ();
void Close_Jonipx ();
int Packet_Ready ();
int Pop_Packet (game_packet_type *packet);
int Jon_Send_Packet (string_type string, int length, double data1, double data2, double data3, node_address_type dest_node);
/* */
#endif
--------------F29025F971749F34679C5972
Content-Type: text/plain; charset=us-ascii;
name="DOSBUFF.H"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
filename="DOSBUFF.H"
#ifndef DOSBUFF_H
#define DOSBUFF_H
#define DOS_BUFFER_SIZE 200 /* 300 bytes */
#define DOS_BUFFER_TEST 100 /* The amount we REALLY need for the dos buffer */
void Allocate_Dos_Buffers (void);
void Copy_Into_Dos_Buffer (void *block, short length);
void Copy_From_Dos_Buffer (void *block, short length);
void Copy_Into_Dos_Buffer_Two (void *block, short length);
void Copy_From_Dos_Buffer_Two (void *block, short length);
void Copy_Into_Send_Buffer (void *block, short length);
void Copy_From_Send_Buffer (void *block, short length);
void Copy_Into_Recieve_Buffer (void *block, short length);
void Copy_From_Recieve_Buffer (void *block, short length);
void Copy_Into_Ecb_Send_Buffer (void *block, short length);
void Copy_From_Ecb_Send_Buffer (void *block, short length);
void Copy_Into_Ecb_Recieve_Buffer (void *block, short length);
void Copy_From_Ecb_Recieve_Buffer (void *block, short length);
void Test_Dos_Buffers (void);
unsigned long Make_Far_Pointer (unsigned short segment, unsigned short offset);
#endif
--------------F29025F971749F34679C5972
Content-Type: text/plain; charset=us-ascii;
name="jonipx.c"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
filename="jonipx.c"
//carnival overture
#include "jonipx.h"
#include "dosbuff.h"
#include <dpmi.h>
#include <go32.h>
#include <string.h>
#include <dpmi.h>
#include <stdio.h>
#include <stdlib.h>
/* These are from dosbuff.c...should be done differently!!!! */
extern unsigned short segment_of_dos_buffer, offset_of_dos_buffer;
extern unsigned long address_of_dos_buffer;
extern unsigned long linear_address_of_dos_buffer;
extern unsigned short segment_of_dos_buffer_two, offset_of_dos_buffer_two;
extern unsigned long address_of_dos_buffer_two;
extern unsigned long linear_address_of_dos_buffer_two;
extern unsigned short segment_of_ecb_send_buffer, offset_of_ecb_send_buffer;
extern unsigned long address_of_ecb_send_buffer;
extern unsigned long linear_address_of_ecb_send_buffer;
extern unsigned short segment_of_ecb_recieve_buffer, offset_of_ecb_recieve_buffer;
extern unsigned long address_of_ecb_recieve_buffer;
extern unsigned long linear_address_of_ecb_recieve_buffer;
extern unsigned short segment_of_send_buffer, offset_of_send_buffer;
extern unsigned long address_of_send_buffer;
extern unsigned long linear_address_of_send_buffer;
extern unsigned short segment_of_recieve_buffer, offset_of_recieve_buffer;
extern unsigned long address_of_recieve_buffer;
extern unsigned long linear_address_of_recieve_buffer;
/* End of EXTERNS */
/* Globals */
/* If this is ever true...connection should be terminated
set in pop_packet */
boolean terminate_connection = FALSE;
local_address_type local_address;
unsigned short socket = MY_SOCKET;
packet_type send_packet, recieve_packet;
unsigned long address_of_callback;
unsigned short segment_of_callback;
unsigned short offset_of_callback;
_go32_dpmi_registers callback_regs;
_go32_dpmi_seginfo callback_info;
unsigned long recieve_count = 0;
packet_buffer_type packet_buffer;
/* End of Globals */
/* This function should get called every time a packet is revieved */
void Packet_Recieve_Callback (_go32_dpmi_registers *callback_regs)
{
int i;
callback_regs->d.eax = 4; /* Doing this cuz I saw it in the dox */
recieve_count++;
/* This should copy the packet into the recieve buffer */
IPX_Listen_For_Packet (&recieve_packet.ecb);
/* Copy packet from recieve buffer into ipx header and buffer */
Copy_From_Recieve_Buffer (&recieve_packet.ipx_header, sizeof (IPX_header_type) + sizeof (string_type) + (sizeof(double)*3));
/* Ignore all packets from ourselves */
if (!Compare_Nodes (local_address.node_address, recieve_packet.ipx_header.source.node_address))
{
/* Copy from there into the packet buffer, we skip the header */
for (i=0; i < sizeof(string_type); i++)
{
packet_buffer.packets[packet_buffer.buffer_pos].string[i] = recieve_packet.string[i];
}
packet_buffer.packets[packet_buffer.buffer_pos].data1=recieve_packet.data1;
packet_buffer.packets[packet_buffer.buffer_pos].data2=recieve_packet.data2;
packet_buffer.packets[packet_buffer.buffer_pos].data3=recieve_packet.data3;
for (i = 0; i < sizeof(node_address_type); i++)
packet_buffer.packets[packet_buffer.buffer_pos].source_node[i] = recieve_packet.ipx_header.source.node_address[i];
packet_buffer.buffer_pos++;
if (packet_buffer.buffer_pos >= MAX_PACKETS_IN_BUFFER)
packet_buffer.buffer_pos = 0;
}
}
void Allocate_Recieve_Callback (void)
{
memset (&callback_info, 0, sizeof(_go32_dpmi_seginfo));
memset (&callback_regs, 0, sizeof(_go32_dpmi_registers));
callback_info.pm_offset = (unsigned int)Packet_Recieve_Callback;
_go32_dpmi_allocate_real_mode_callback_retf (&callback_info, &callback_regs);
segment_of_callback = callback_info.rm_segment;
offset_of_callback = callback_info.rm_offset;
address_of_callback = Make_Far_Pointer (segment_of_callback, offset_of_callback);
}
/* Return 1 if the nodes are the same, 0 if they are not */
int Compare_Nodes( node_address_type node_one, node_address_type node_two )
{
int i;
for( i = 0; i < sizeof(node_address_type); i++)
if( node_one[i] != node_two[i] )
return(0);
return(1);
}
unsigned short Endian_Swap (unsigned short old_short)
{
unsigned short temp_short;
unsigned short swap_short;
unsigned char *char_ptr;
unsigned char *char_ptr_two;
temp_short = old_short;
char_ptr = (unsigned char *)&temp_short;
char_ptr_two = (unsigned char *)&swap_short;
char_ptr_two[0] = char_ptr[1];
char_ptr_two[1] = char_ptr[0];
return(swap_short);
}
int Init_IPX ()
{
_go32_dpmi_registers r;
/* Clear out the registers */
memset (&r, 0, sizeof(r));
r.x.ax = 0x7A00;
_go32_dpmi_simulate_int (0x2f, &r);
if (r.h.al != 255)
{
/* printf("Error in installing IPX %x \n", r.h.al ); */
return(0);
}
Get_Local_Address();
return(1);
}
void Get_Local_Address()
{
_go32_dpmi_registers r;
/* Clear out the registers */
memset (&r, 0, sizeof(r));
memset (&local_address, 0, sizeof(local_address));
r.x.bx = 0x0009; /* Subfunction 0x0009, get internetwork address */
r.x.es = segment_of_dos_buffer;
r.x.si = offset_of_dos_buffer;
Copy_Into_Dos_Buffer (&local_address, sizeof(local_address));
_go32_dpmi_simulate_int (0x7a, &r);
Copy_From_Dos_Buffer (&local_address, sizeof(local_address));
/* printf("net %x %x %x %x \n", local_address.net[0], local_address.net[1],local_address.net[2],local_address.net[3] );
printf("node %x %x %x %x %x %x \n", local_address.node_address[0], local_address.node_address[1],local_address.node_address[2],local_address.node_address[3],local_address.node_address[4],local_address.node_address[5] );*/
}
/*
Open a socket...
longetivity == 0x00 for open till close or terminate
== 0xff for open till close use for tsr
socket_number == 0 for dynamic allocation
== anything else
returns 0x0 == success
0xfe == socket table full
0xff == socket already open
*/
int IPX_Open_Socket (unsigned char longetivity, unsigned short *socket_number)
{
_go32_dpmi_registers r;
/* Clear out the registers */
memset (&r, 0, sizeof(r));
r.x.bx = 0x0000; /* Function open socket till close or terminate? */
r.h.al = longetivity;
r.x.dx = Endian_Swap (*socket_number);
/* Call the interrupt */
_go32_dpmi_simulate_int (0x7A, &r);
if (*socket_number == 0x0000)
*socket_number = Endian_Swap (r.x.dx);
return (r.h.al);
}
void IPX_Close_Socket (unsigned short *socket_number)
{
_go32_dpmi_registers r;
/* Clear out the registers */
memset (&r, 0, sizeof(r));
r.x.bx = 0x0001;
r.x.dx = Endian_Swap (*socket_number);
_go32_dpmi_simulate_int (0x7A, &r);
}
void IPX_Send_Packet (ECB_type *ecb)
{
_go32_dpmi_registers r;
/* Clear out the registers */
memset (&r, 0, sizeof(r));
r.x.bx = 0x0003; /* Function 3 is send packet? */
r.x.es = segment_of_ecb_send_buffer;
r.x.si = offset_of_ecb_send_buffer;
Copy_Into_Ecb_Send_Buffer (ecb, sizeof(ECB_type));
_go32_dpmi_simulate_int (0x7a, &r);
Copy_From_Ecb_Send_Buffer (ecb, sizeof(ECB_type));
}
int IPX_Listen_For_Packet (ECB_type *ecb)
{
_go32_dpmi_registers r;
/* Clear out the registers */
memset (&r, 0, sizeof(r));
r.x.bx = 0x0004; /* Subfunction 4 is listen for packet? */
r.x.es = segment_of_ecb_recieve_buffer;
r.x.si = offset_of_ecb_recieve_buffer;
_go32_dpmi_simulate_int (0x7A, &r);
Copy_From_Ecb_Recieve_Buffer (ecb, sizeof(ECB_type));
return(r.h.al);
}
/* Tell driver we are idle */
void Im_Idle( void )
{
_go32_dpmi_registers r;
/* Clear out the registers */
memset (&r, 0, sizeof(r));
r.x.bx = 0x000A;
_go32_dpmi_simulate_int (0x7A, &r);
}
/* Initialize all the basic shizit we need to send packets...store the
pointer to memory where we will put packets */
void Init_Send_Packet (ECB_type *ecb, IPX_header_type *ipx_header, unsigned short size, unsigned short sock)
{
int i;
memset (ipx_header, 0, sizeof (IPX_header_type));
memset (ecb, 0, sizeof (ECB_type));
ecb->socket = Endian_Swap (sock); /* Big endian socket number */
ecb->fragment_count = 1; /* Fragment count?? */
ecb->ESR = NULL;
/* Pointer to data fragment(ipx header) */
ecb->fragment_data = address_of_send_buffer;
ecb->fragment_size = sizeof (IPX_header_type) + size;
for (i=0; i < 6; i++)
ecb->immediate_address[i] = 0xff; /* Broadcast */
ipx_header->checksum = 0xffff; /* No checksum */
ipx_header->packet_type = 0; /* Packet exchange packet */
for (i=0; i < 4; i++ )
ipx_header->destination.net[i] = local_address.net[i]; /* Send to this network */
for (i=0; i < 6; i++)
ipx_header->destination.node_address[i] = 0xff; /* Send to everybody! */
/* USE A DEFINE FOR THE WRITE SOCKET!!! */
ipx_header->destination.socket = Endian_Swap (sock); /* Send to my socket */
for (i=0; i < 4; i++)
ipx_header->source.net[i] = local_address.net[i];
for (i=0; i < 6; i++)
ipx_header->source.node_address[i] = local_address.node_address[i]; /* From me */
ipx_header->source.socket = Endian_Swap (sock); /* From my socket */
}
/* Initialize all the basic shizit we need to recieve packets...store the
pointer to memory where we will put packets */
void Init_Recieve_Packet (ECB_type *ecb, IPX_header_type *ipx_header, unsigned short size, unsigned short sock)
{
int error_code;
memset (ecb, 0, sizeof (ECB_type));
memset (ipx_header, 0, sizeof (IPX_header_type));
ecb->in_use = 0x1D; /* ?? */
ecb->socket = Endian_Swap (sock);
ecb->fragment_count = 1;
/* Set a real mode callback for my ESR function */
Allocate_Recieve_Callback();
ecb->ESR = address_of_callback;
ecb->fragment_data = address_of_recieve_buffer;
ecb->fragment_size = sizeof (IPX_header_type) + size;
Copy_Into_Recieve_Buffer (ipx_header, sizeof (IPX_header_type) + size);
Copy_Into_Ecb_Recieve_Buffer (ecb, sizeof(ECB_type));
if ((error_code = IPX_Listen_For_Packet(ecb)) == 0xFF)
{
/* printf("Error in listen for packet function (in init recieve) 0x%x \n", error_code); */
exit(0);
}
Copy_From_Recieve_Buffer (ipx_header, sizeof (IPX_header_type) + size);
}
int Init_Jonipx ()
{
int temp_int;
int i;
if (!Init_IPX())
{
/* printf("No IPX driver detected! \n"); */
return(0);
}
/* printf("Opening socket at %x!! \n", socket); */
/* longetivity == 0x00 for open till close or terminate , 0xff for open till close */
if ((temp_int = IPX_Open_Socket (0x00, &socket)))
{
/* printf("Error 0x%x opening socket \n", temp_int ); */
return(0);
}
for (i = 0; i < sizeof (string_type); i++)
send_packet.string[i] = '\0';
send_packet.data1=0.0;
send_packet.data2=0.0;
send_packet.data3=0.0;
Init_Send_Packet (&send_packet.ecb, &send_packet.ipx_header, sizeof (string_type) + (sizeof(double)*3), socket);
Copy_Into_Send_Buffer (&send_packet.ipx_header, sizeof (IPX_header_type));
Copy_Into_Ecb_Send_Buffer (&send_packet.ecb, sizeof (ECB_type));
Init_Recieve_Packet (&recieve_packet.ecb, &recieve_packet.ipx_header, sizeof (string_type) + (sizeof(double)*3), socket);
packet_buffer.buffer_pos = 0;
packet_buffer.buffer_start = 0;
return(1);
}
/*int Jon_Get_Packet (string_type string, double data1, double data2, double data3, node_address_type source_node)
{
int i;
int from_local = 1; /* Is this packet from the local computer? */
/*Im_Idle();
Copy_From_Ecb_Recieve_Buffer (&recieve_packet.ecb, sizeof(ECB_type));
if (recieve_packet.ecb.in_use == 0)
{
Copy_From_Recieve_Buffer (&recieve_packet.ipx_header, sizeof (IPX_header_type) + sizeof (string_type) + (sizeof(double)*3));
/*
fprintf(stderr,"recieving");
fprintf(stderr, "%s", recieve_packet.string );
*/
/*if (IPX_Listen_For_Packet (&recieve_packet.ecb))
{
/* printf("Error in loop listening for packets... \n"); */
/*exit(0);
}
Copy_From_Recieve_Buffer (&recieve_packet.ipx_header, sizeof (IPX_header_type) + sizeof (string_type) + (sizeof(double)*3));
/* Ignore stuff that I sent */
/*for (i = 0; i < 6; i++)
if (recieve_packet.ipx_header.source.node_address[i] != local_address.node_address[i])
from_local = 0;
/* Copy the source node address of the packet */
/*for (i = 0; i < 6; i++)
source_node[i] = recieve_packet.ipx_header.source.node_address[i];
if (from_local)
return(0);
for (i = 0; i < sizeof(string_type); i++)
string[i] = recieve_packet.string[i];
data1=recieve_packet.data1;
data2=recieve_packet.data2;
data3=recieve_packet.data3;
return(1);
}
else
return(0);
}*/
int Jon_Send_Packet (string_type string, int length, double data1, double data2, double data3, node_address_type dest_node)
{
int i;
Im_Idle();
Copy_From_Ecb_Send_Buffer (&send_packet.ecb, sizeof(ECB_type));
for (i = 0; i < 6; i++)
send_packet.ecb.immediate_address[i] = dest_node[i]; /* 0xff; */ /* Broadcast */
for( i = 0; i < 6; i++ )
send_packet.ipx_header.destination.node_address[i] = dest_node[i]; /* 0xff; */ /* Broadcast */
for (i = 0; i < length; i++)
send_packet.string[i] = string[i];
send_packet.data1=data1;
send_packet.data2=data2;
send_packet.data3=data3;
Copy_Into_Send_Buffer (&send_packet.ipx_header, sizeof (IPX_header_type) + sizeof (string_type) + (sizeof(double)*3));
IPX_Send_Packet (&send_packet.ecb);
Im_Idle(); /* HACK?? */
delay (IPX_DELAY);
return(1);
}
void Close_Jonipx (void)
{
/* printf("Closing socket \n"); */
IPX_Close_Socket (&socket);
}
/* Is there a packet ready in the packet buffer? */
int Packet_Ready (void)
{
if (packet_buffer.buffer_start != packet_buffer.buffer_pos)
return(1);
else
return(0);
}
/* Copy the next available packet into string */
int Pop_Packet (game_packet_type *packet)
{
int i;
if (!Packet_Ready())
return(0);
for (i=0; i < sizeof(string_type); i++)
packet->string[i] = packet_buffer.packets[packet_buffer.buffer_start].string[i];
packet->data1=packet_buffer.packets[packet_buffer.buffer_start].data1;
packet->data2=packet_buffer.packets[packet_buffer.buffer_start].data2;
packet->data3=packet_buffer.packets[packet_buffer.buffer_start].data3;
for (i = 0; i < sizeof(node_address_type); i++)
packet->source_node[i] = packet_buffer.packets[packet_buffer.buffer_start].source_node[i];
packet_buffer.buffer_start++;
if (packet_buffer.buffer_start >= MAX_PACKETS_IN_BUFFER)
packet_buffer.buffer_start = 0;
return(1);
}
--------------F29025F971749F34679C5972
Content-Type: text/plain; charset=us-ascii;
name="DOSBUFF.C"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
filename="DOSBUFF.C"
#include "dosbuff.h"
#include <dpmi.h>
#include <go32.h>
#include <string.h>
#include <conio.h>
#include <stdio.h>
unsigned short segment_of_dos_buffer, offset_of_dos_buffer;
unsigned long address_of_dos_buffer;
unsigned long linear_address_of_dos_buffer;
unsigned short segment_of_dos_buffer_two, offset_of_dos_buffer_two;
unsigned long address_of_dos_buffer_two;
unsigned long linear_address_of_dos_buffer_two;
unsigned short segment_of_ecb_send_buffer, offset_of_ecb_send_buffer;
unsigned long address_of_ecb_send_buffer;
unsigned long linear_address_of_ecb_send_buffer;
unsigned short segment_of_ecb_recieve_buffer, offset_of_ecb_recieve_buffer;
unsigned long address_of_ecb_recieve_buffer;
unsigned long linear_address_of_ecb_recieve_buffer;
unsigned short segment_of_send_buffer, offset_of_send_buffer;
unsigned long address_of_send_buffer;
unsigned long linear_address_of_send_buffer;
unsigned short segment_of_recieve_buffer, offset_of_recieve_buffer;
unsigned long address_of_recieve_buffer;
unsigned long linear_address_of_recieve_buffer;
void Allocate_Dos_Buffers( void )
{
_go32_dpmi_seginfo info;
unsigned int address, page; /* Address is linear */
unsigned int new_segment, new_offset;
info.size = (DOS_BUFFER_SIZE + 15) / 16;
if (_go32_dpmi_allocate_dos_memory(&info))
{
printf("ERROR Allocate dos buffer Alloc failed \n");
exit(0);
}
/* What is the 20 bit address? */
address = info.rm_segment << 4;
/* Does it cross a 64K boundary? */
page = address & 0xffff;
if ((page + DOS_BUFFER_TEST) > 0xffff)
address = (address - page) + 0x10000;
new_segment = address / 16;
new_offset = address % 16;
segment_of_dos_buffer = new_segment;
offset_of_dos_buffer = new_offset;
linear_address_of_dos_buffer = address;
address_of_dos_buffer = ((unsigned long)new_segment << 16) | new_offset;
/* Do the same for buffer two */
memset (&info, 0, sizeof(info));
info.size = (DOS_BUFFER_SIZE + 15) / 16;
if (_go32_dpmi_allocate_dos_memory(&info))
{
printf("ERROR Allocate dos buffer Alloc failed \n");
exit(0);
}
/* What is the 20 bit address? */
address = info.rm_segment << 4;
/* Does it cross a 64K boundary? */
page = address & 0xffff;
if ((page + DOS_BUFFER_TEST) > 0xffff)
address = (address - page) + 0x10000;
new_segment = address / 16;
new_offset = address % 16;
segment_of_dos_buffer_two = new_segment;
offset_of_dos_buffer_two = new_offset;
linear_address_of_dos_buffer_two = address;
address_of_dos_buffer_two = ((unsigned long)new_segment << 16) | new_offset;
/* Do the same for send buffer */
info.size = (DOS_BUFFER_SIZE + 15) / 16;
if (_go32_dpmi_allocate_dos_memory(&info))
{
printf("ERROR Allocate dos buffer Alloc failed \n");
exit(0);
}
/* What is the 20 bit address? */
address = info.rm_segment << 4;
/* Does it cross a 64K boundary? */
page = address & 0xffff;
if ((page + DOS_BUFFER_TEST) > 0xffff)
address = (address - page) + 0x10000;
new_segment = address / 16;
new_offset = address % 16;
segment_of_send_buffer = new_segment;
offset_of_send_buffer = new_offset;
linear_address_of_send_buffer = address;
address_of_send_buffer = ((unsigned long)new_segment << 16) | new_offset;
/* Do the same for recieve buffer */
info.size = (DOS_BUFFER_SIZE + 15) / 16;
if (_go32_dpmi_allocate_dos_memory(&info))
{
printf("ERROR Allocate dos buffer Alloc failed \n");
exit(0);
}
/* What is the 20 bit address? */
address = info.rm_segment << 4;
/* Does it cross a 64K boundary? */
page = address & 0xffff;
if ((page + DOS_BUFFER_TEST) > 0xffff)
address = (address - page) + 0x10000;
new_segment = address / 16;
new_offset = address % 16;
segment_of_recieve_buffer = new_segment;
offset_of_recieve_buffer = new_offset;
linear_address_of_recieve_buffer = address;
address_of_recieve_buffer = ((unsigned long)new_segment << 16) | new_offset;
/* Do the same for ecb send buffer */
info.size = (DOS_BUFFER_SIZE + 15) / 16;
if (_go32_dpmi_allocate_dos_memory(&info))
{
printf("ERROR Allocate dos buffer Alloc failed \n");
exit(0);
}
/* What is the 20 bit address? */
address = info.rm_segment << 4;
/* Does it cross a 64K boundary? */
page = address & 0xffff;
if ((page + DOS_BUFFER_TEST) > 0xffff)
address = (address - page) + 0x10000;
new_segment = address / 16;
new_offset = address % 16;
segment_of_ecb_send_buffer = new_segment;
offset_of_ecb_send_buffer = new_offset;
linear_address_of_ecb_send_buffer = address;
address_of_ecb_send_buffer = ((unsigned long)new_segment << 16) | new_offset;
/* Do the same for recieve buffer */
info.size = (DOS_BUFFER_SIZE + 15) / 16;
if (_go32_dpmi_allocate_dos_memory(&info))
{
printf("ERROR Allocate dos buffer Alloc failed \n");
exit(0);
}
/* What is the 20 bit address? */
address = info.rm_segment << 4;
/* Does it cross a 64K boundary? */
page = address & 0xffff;
if ((page + DOS_BUFFER_TEST) > 0xffff)
address = (address - page) + 0x10000;
new_segment = address / 16;
new_offset = address % 16;
segment_of_ecb_recieve_buffer = new_segment;
offset_of_ecb_recieve_buffer = new_offset;
linear_address_of_ecb_recieve_buffer = address;
address_of_ecb_recieve_buffer = ((unsigned long)new_segment << 16) | new_offset;
}
void Copy_Into_Dos_Buffer (void *block, short length)
{
dosmemput (block, length, linear_address_of_dos_buffer);
}
void Copy_From_Dos_Buffer (void *block, short length)
{
dosmemget (linear_address_of_dos_buffer, length, block);
}
void Copy_Into_Dos_Buffer_Two (void *block, short length)
{
dosmemput (block, length, linear_address_of_dos_buffer_two);
}
void Copy_From_Dos_Buffer_Two (void *block, short length)
{
dosmemget (linear_address_of_dos_buffer_two, length, block);
}
void Copy_Into_Send_Buffer (void *block, short length)
{
dosmemput (block, length, linear_address_of_send_buffer);
}
void Copy_From_Send_Buffer (void *block, short length)
{
dosmemget (linear_address_of_send_buffer, length, block);
}
void Copy_Into_Recieve_Buffer (void *block, short length)
{
dosmemput (block, length, linear_address_of_recieve_buffer);
}
void Copy_From_Recieve_Buffer (void *block, short length)
{
dosmemget (linear_address_of_recieve_buffer, length, block);
}
void Copy_Into_Ecb_Send_Buffer (void *block, short length)
{
dosmemput (block, length, linear_address_of_ecb_send_buffer);
}
void Copy_From_Ecb_Send_Buffer (void *block, short length)
{
dosmemget (linear_address_of_ecb_send_buffer, length, block);
}
void Copy_Into_Ecb_Recieve_Buffer (void *block, short length)
{
dosmemput (block, length, linear_address_of_ecb_recieve_buffer);
}
void Copy_From_Ecb_Recieve_Buffer (void *block, short length)
{
dosmemget (linear_address_of_ecb_recieve_buffer, length, block);
}
void Test_Dos_Buffers (void)
{
int i;
unsigned char buffer1[100], buffer2[100];
for (i = 0; i < 100; i++)
{
buffer1[i] = i;
buffer2[i] = 0;
}
Copy_Into_Dos_Buffer (buffer1, 100);
Copy_From_Dos_Buffer (buffer2, 100);
for (i = 0; i < 100; i++)
printf("%d \n", buffer2[i]);
for (i = 0; i < 100; i++)
{
buffer1[i] = i;
buffer2[i] = 0;
}
Copy_Into_Dos_Buffer_Two (buffer1, 100);
Copy_From_Dos_Buffer_Two (buffer2, 100);
for (i = 0; i < 100; i++)
printf("%d \n", buffer2[i]);
for (i = 0; i < 100; i++)
{
buffer1[i] = i;
buffer2[i] = 0;
}
Copy_Into_Send_Buffer (buffer1, 100);
Copy_From_Send_Buffer (buffer2, 100);
for (i = 0; i < 100; i++)
printf("%d \n", buffer2[i]);
for (i = 0; i < 100; i++)
{
buffer1[i] = i;
buffer2[i] = 0;
}
Copy_Into_Recieve_Buffer (buffer1, 100);
Copy_From_Recieve_Buffer (buffer2, 100);
for (i = 0; i < 100; i++)
printf("%d \n", buffer2[i]);
for (i = 0; i < 100; i++)
{
buffer1[i] = i;
buffer2[i] = 0;
}
Copy_Into_Ecb_Send_Buffer (buffer1, 100);
Copy_From_Ecb_Send_Buffer (buffer2, 100);
for (i = 0; i < 100; i++)
printf("%d \n", buffer2[i]);
for (i = 0; i < 100; i++)
{
buffer1[i] = i;
buffer2[i] = 0;
}
Copy_Into_Ecb_Recieve_Buffer (buffer1, 100);
Copy_From_Ecb_Recieve_Buffer (buffer2, 100);
for (i = 0; i < 100; i++)
printf("%d \n", buffer2[i]);
}
unsigned long Make_Far_Pointer (unsigned short segment, unsigned short offset)
{
unsigned long temp;
temp = ((unsigned long)segment << 16) | offset;
return(temp);
}
--------------F29025F971749F34679C5972--
- Raw text -