ipx.c

一个使用IPX协议在两台机器间传送文件的程序

#include <stdio.h>
#include <string.h>
#include "ipx.h"

unsigned long ipx_entry = 0;

long __get_ipx_entry(void);

#pragma aux __get_ipx_entry =             \
   "mov  AX,7A00h"                        \
   "int  2Fh"                             \
   "cmp  AL,0FFh"                         \
   "jnz  ipx_init0"                       \
   "mov  DX, ES"                          \
   "mov  AX, DI"                          \
   "jmp  ipx_init1"                       \
   "ipx_init0:"                           \
   "xor  DX,DX"                           \
   "xor  AX,AX"                           \
   "ipx_init1:"                           \
   parm caller nomemory                   \
   value [AX DX]                          \
   modify [BX CX SI DI ES] nomemory;

int ipx_init(void)
{
   if ( ipx_entry != 0L )
      return 1;
   ipx_entry = __get_ipx_entry();
   if ( ipx_entry == 0L )
      return 0;
   return 1;
}

unsigned char far * __inline_get_network_number(unsigned char far *adr, long far *);

#pragma aux __inline_get_network_number = \
   "push DS"                              \
   "push BP"                              \
   "mov  DS,CX"                           \
   "mov  BX,0009h"                        \
   "call far ptr DS:[DI]"                 \
   "pop  BP"                              \
   "pop  DS"                              \
   parm caller [SI ES] [DI CX] nomemory   \
   value [SI ES]                          \
   modify [AX BX CX DX SI DI ES] nomemory;

int ___get_network_number(ipx_adr_struct far *adr)
{
   if ( ipx_entry == 0L )
      return 0;
   __inline_get_network_number((unsigned char far *)adr, (long far *)&ipx_entry);
   return 1;
}

ipx_adr_struct far *ipx_get_local_net_number(void)
{
   static ipx_adr_struct adr;
   static is_ok = 0;
   if ( is_ok != 0 )
      return &adr;
   if ( ipx_entry == 0L )
      return NULL;
   if ( ___get_network_number(&adr) == 0 )
      return NULL;
   is_ok = 1;
   return &adr;
}

short inline_ipx_open_socket(unsigned short far *socket, long far *adr);
#pragma aux inline_ipx_open_socket =      \
   "push DS"                              \
   "push BP"                              \
   "mov  BX,0000h"                        \
   "mov  AL, 000h"                        \
   "mov  DX, word ptr ES:[SI]"            \
   "xchg DH, DL"                          \
   "mov  DS,CX"                           \
   "push ES"                              \
   "call far ptr DS:[DI]"                 \
   "pop  ES"                              \
   "xchg DH, DL"                          \
   "mov  word ptr ES:[SI], DX"            \
   "pop  BP"                              \
   "pop  DS"                              \
   "mov  AH, 0"                           \
   parm caller [SI ES] [DI CX]            \
   value [AX]                             \
   modify [AX BX CX DX SI DI ES];

/* 0: ok    0x0fe: full    0x0ff: open */
int ipx_open_socket(unsigned short socket)
{
   return (int)inline_ipx_open_socket((unsigned short far *)&socket, (long far *)&ipx_entry);
}

/* 0: ok    0x0fe: full    0x0ff: open */
int ipx_open_new_socket(unsigned short far *socket)
{
   *socket = 0;
   return (int)inline_ipx_open_socket(socket, (long far *)&ipx_entry);
}

void inline_ipx_close_socket(unsigned short socket, long far *adr);
#pragma aux inline_ipx_close_socket =      \
   "push DS"                              \
   "push BP"                              \
   "mov  DS,CX"                           \
   "mov  BX,0001h"                        \
   "xchg DH,DL"                           \
   "call far ptr DS:[DI]"                 \
   "pop  BP"                              \
   "pop  DS"                              \
   parm caller [DX] [DI CX] nomemory      \
   value [DX]                             \
   modify [AX BX CX DX SI DI ES] nomemory;

void ipx_close_socket(unsigned short socket)
{
   inline_ipx_close_socket(socket, (long far *)&ipx_entry);
}


/* RELINQUISH CONTROL */
void inline_ipx_dispatch(long far *adr);
#pragma aux inline_ipx_dispatch =         \
   "push DS"                              \
   "push BP"                              \
   "mov  DS,CX"                           \
   "mov  BX,000ah"                        \
   "call far ptr DS:[DI]"                 \
   "pop  BP"                              \
   "pop  DS"                              \
   parm caller [DI CX] nomemory           \
   modify [AX BX CX DX SI DI ES] nomemory;

void inline_send_ecb(ipx_ecb_struct far *ecb, long far *adr);
#pragma aux inline_send_ecb =             \
   "push DS"                              \
   "push BP"                              \
   "mov  DS,CX"                           \
   "mov  BX,0003h"                        \
   "call far ptr DS:[DI]"                 \
   "pop  BP"                              \
   "pop  DS"                              \
   parm caller [SI ES] [DI CX] nomemory   \
   modify [AX BX CX DX SI DI ES] nomemory;

int ipx_send_ecb(ipx_ecb_struct far *ecb)
{
   if ( ipx_entry == 0L )
      return 0;
   inline_send_ecb(ecb, (long far *)&ipx_entry);
   return 1;
}

void ipx_dispatch(void)
{
   inline_ipx_dispatch((long far *)&ipx_entry);
}

int ipx_is_ecb_in_use(ipx_ecb_struct far *ecb)
{
   if ( ipx_entry == 0L )
      return 0;
   if ( ecb == NULL )
      return 0;
   ipx_dispatch();
   if ( ecb->inuse != 0 )
      return 1;
   return 0;
}

unsigned short inline_ipx_listen_ecb(ipx_ecb_struct far *ecb, long far *adr);
#pragma aux inline_ipx_listen_ecb = \
   "push DS"                              \
   "push BP"                              \
   "mov  DS,CX"                           \
   "mov  BX,0004h"                        \
   "call far ptr DS:[DI]"                 \
   "mov  AH, 0"                           \
   "pop  BP"                              \
   "pop  DS"                              \
   parm caller [SI ES] [DI CX] nomemory   \
   value [AX]                             \
   modify [AX BX CX DX SI DI ES DS] nomemory;

int ipx_listen_ecb(ipx_ecb_struct far *ecb)
{
   if ( ipx_entry == 0L )
      return 0;
   if ( inline_ipx_listen_ecb(ecb, (long far *)&ipx_entry) != 0 )
      return 0;
   return 1;
}

unsigned short inline_ipx_cancel_ecb(ipx_ecb_struct far *ecb, long far *adr);
#pragma aux inline_ipx_cancel_ecb = \
   "push DS"                              \
   "push BP"                              \
   "mov  DS,CX"                           \
   "mov  BX,0006h"                        \
   "call far ptr DS:[DI]"                 \
   "mov  AH, 0"                           \
   "pop  BP"                              \
   "pop  DS"                              \
   parm caller [SI ES] [DI CX] nomemory   \
   value [AX]                             \
   modify [AX BX CX DX SI DI ES DS] nomemory;

int ipx_cancel_ecb(ipx_ecb_struct far *ecb)
{
   if ( ipx_entry == 0L )
      return 0;
   if ( inline_ipx_cancel_ecb(ecb, (long far *)&ipx_entry) != 0 )
      return 0;
   return 1;
}

char far *get_str_net_adr(ipx_adr_struct far *adr)
{
   static char s[10];
   sprintf(s, "%02x%02x%02x%02x", 
      adr->netadd[3],
      adr->netadd[2],
      adr->netadd[1],
      adr->netadd[0] );
   return s;
}

char far *get_str_node_adr(ipx_adr_struct far *adr)
{
   static char s[14];
   sprintf(s, "%02x%02x%02x%02x%02x%02x", 
      adr->nodeadd[5],
      adr->nodeadd[4],
      adr->nodeadd[3],
      adr->nodeadd[2],
      adr->nodeadd[1],
      adr->nodeadd[0] );
   return s;
}

ipx_header_struct far *ipx_get_header(ipx_adr_struct far *dest,
   unsigned short dest_socket, unsigned short source_socket)
{
   static ipx_header_struct head;
   head.checksum = 0;
   head.length = 0;
   head.tc = 0;
   head.type = 4;      // packet exchange packet, see ralf brown's intlist
   if ( dest == NULL )
   {
      head.dest.netadd[3] = 0;
      head.dest.netadd[2] = 0;
      head.dest.netadd[1] = 0;
      head.dest.netadd[0] = 0;
      head.dest.nodeadd[5] = 0x0ff;
      head.dest.nodeadd[4] = 0x0ff;
      head.dest.nodeadd[3] = 0x0ff;
      head.dest.nodeadd[2] = 0x0ff;
      head.dest.nodeadd[1] = 0x0ff;
      head.dest.nodeadd[0] = 0x0ff;
   }
   else
   {
      head.dest = *dest;