home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / comm / amipx1_21 / doc / fool_doom2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-28  |  5.1 KB  |  175 lines
  1. #include <clib/exec_protos.h>
  2. #include <amipx.h>
  3. #include <amipx_protos.h>
  4. #include <amipx_pragmas.h>
  5.  
  6. struct AMIPX_Library *AMIPX_Library;
  7.  
  8. struct myECB {
  9.  struct AMIPX_ECB ECB;
  10.  struct AMIPX_Fragment extra[2];
  11. };
  12.  
  13. unsigned char pd[12]={00,00,00,00,02,00,02,00,00,00,00,00
  14.                    };
  15.  
  16. /*****************************************************************************
  17.  * This program fools DOOM2 into thinking it found a second DOOM2 node in    *
  18.  * IPX game setup time.                                                      *
  19.  * All this program does is first sending the packet data above with a DOOM  *
  20.  * timeval of -1, and then listening for one packet, after which it exits.   *
  21.  * Typically, you would start IPX setup on the PC or Mac, then run this      *
  22.  * program, after which the PC or Mac will think the other node has been     *
  23.  * found. By the way: because both 'number of players found' and 'number of  *
  24.  * players requested' are set to 2 in pd, the PC or Mac will send its        *
  25.  * network start packet and wait.                                            *
  26.  * In that situation, the first packet received by this program is probably  *
  27.  * the network start packet.                                                 *
  28.  *                                                                           *
  29.  * Alternatively, you can first start this program and then PC or Mac DOOM2. *
  30.  * In this case, the first packet received by this program is DOOM2's        *
  31.  * broadcast. PC DOOM2 can then be stopped by pressing 'Esc'.                *
  32.  *                                                                           *
  33.  * Yes! This program busy-waits. However, between polling, a game can do     *
  34.  * more interesting stuff.                                                   * 
  35.  *****************************************************************************/
  36.  
  37. struct myECB LECB[4];
  38. struct AMIPX_PacketHeader Lheader[4];
  39. BYTE Ltime[4][4];
  40. BYTE Luserdata[4][512];
  41.  
  42. main(int argc,char **argv)
  43. {
  44.  struct myECB ECB;
  45.  unsigned char myaddrbuff[20];
  46.  int t,lp;
  47.  UWORD mysocket;
  48.  int socknum;
  49.  struct AMIPX_PacketHeader header;
  50.  BYTE time[4];
  51.  BYTE userdata[512];
  52.  
  53.  socknum=0x869b;
  54.  
  55.  if(argc>1)
  56.   sscanf(argv[1],"%x",&socknum);
  57.  
  58.  for(lp=0;lp<4;lp++) { /* set up 4 listen requests */
  59.   for(t=0;t<sizeof(struct myECB);t++)
  60.    ((char *)&(LECB[lp]))[t]=0;
  61.  
  62.   LECB[lp].ECB.Fragment[0].FragData=&(Lheader[lp]);
  63.   LECB[lp].ECB.Fragment[0].FragSize=sizeof(struct AMIPX_PacketHeader);
  64.   LECB[lp].ECB.FragCount=3;
  65.   LECB[lp].ECB.Fragment[1].FragData=&(Ltime[lp]);
  66.   LECB[lp].ECB.Fragment[1].FragSize=4;
  67.   LECB[lp].ECB.Fragment[2].FragData=&(Luserdata[lp]);
  68.   LECB[lp].ECB.Fragment[2].FragSize=12;
  69.   LECB[lp].ECB.InUse=0x00;
  70.  }
  71.  
  72.  for(t=0;t<10;t++)
  73.   myaddrbuff[t]=10-t;
  74.  
  75.  for(t=0;t<4;t++)
  76.   time[t]=0xff;
  77.  
  78.  for(t=0;t<12;t++)
  79.   userdata[t]=pd[t];
  80.  
  81.  for(t=0;t<sizeof(ECB);t++)
  82.   ((char *)&ECB)[t]=0;
  83.  
  84.  header.Checksum[0]=0xff;
  85.  header.Checksum[1]=0xff;
  86.  header.Length[0]=0;
  87.  header.Length[1]=0x2e;
  88.  header.Tc=0;
  89.  header.Type=0;
  90.  
  91.  ECB.ECB.Fragment[0].FragData=&header;
  92.  ECB.ECB.Fragment[0].FragSize=sizeof(header);
  93.  ECB.ECB.FragCount=3;
  94.  ECB.ECB.Fragment[1].FragData=&time;
  95.  ECB.ECB.Fragment[1].FragSize=4;
  96.  ECB.ECB.Fragment[2].FragData=&userdata;
  97.  ECB.ECB.Fragment[2].FragSize=12;
  98.  ECB.ECB.InUse=0x00;
  99.  for(t=0;t<6;t++)
  100.   ECB.ECB.ImmedAddr[t]=0xff;
  101.  
  102.  AMIPX_Library=(struct AMIPX_Library *)OpenLibrary("amipx.library",0);
  103.  
  104.  if(AMIPX_Library) {
  105.   printf("Library opened.\n");
  106.   AMIPX_GetLocalAddr(myaddrbuff);
  107.   for(t=0;t<10;t++)
  108.    printf("%02x ",(unsigned int)myaddrbuff[t]);
  109.   printf("\n");
  110.   if((mysocket=AMIPX_OpenSocket(socknum))!=0) {
  111.    printf("Socket %04x opened\n",(unsigned int)mysocket);
  112.    for(t=0;t<4;t++) {
  113.     header.Dst.Network[t]=myaddrbuff[t];
  114.     header.Src.Network[t]=myaddrbuff[t];
  115.    }
  116.  
  117.    for(t=0;t<6;t++) {
  118.     header.Dst.Node[t]=0xff;
  119.     header.Src.Node[t]=myaddrbuff[t+4];
  120.    }
  121.  
  122.    header.Dst.Socket[0]=(mysocket/256)&0xff;
  123.    header.Dst.Socket[1]=(mysocket)    &0xff;
  124.    header.Src.Socket[0]=(mysocket/256)&0xff;
  125.    header.Src.Socket[1]=(mysocket)    &0xff;
  126.    ECB.ECB.Socket=mysocket;
  127.  
  128.  
  129.  
  130.    printf("Now submitting Listen ECBs...\n");
  131.  
  132.    for(lp=0;lp<4;lp++) {
  133.     LECB[lp].ECB.Socket=mysocket;
  134.     AMIPX_ListenForPacket(&LECB[lp]);
  135.    }
  136.  
  137.    for(lp=0;lp<4;lp++) { /* since all requests are queued for the same socket,
  138.                             they are satisfied in the same order */
  139.     printf("Now submitting Send ECB...");
  140.     printf("Return value: %d\n",AMIPX_SendPacket(&ECB));
  141.  
  142.     printf("Waiting for Listen to return...\n");
  143.     while(LECB[lp].ECB.InUse) 
  144.       ;
  145.  
  146.  
  147.     printf("header : ");
  148.     for(t=0;t<sizeof(header);t++)
  149.      printf("%02x ",((unsigned char *)&Lheader[lp])[t]);
  150.  
  151.     printf("\nTime : ");
  152.  
  153.     for(t=0;t<4;t++)
  154.      printf("%02x ",(unsigned char)Ltime[lp][t]);
  155.  
  156.     printf("\n");
  157.     for(t=0;t<512 && t<(Lheader[lp].Length[1]+Lheader[lp].Length[0]*256-34);t++)
  158.      printf("%02x ",(unsigned char)Luserdata[lp][t]);
  159.  
  160.     printf("\n");
  161.     printf("Now waiting for Send to return\n");
  162.     while(ECB.ECB.InUse) 
  163.      ;
  164.    }
  165.    
  166.    AMIPX_CloseSocket(mysocket);
  167.   }
  168.   else {
  169.    printf("Panic! Socket not opened!\n");
  170.   }
  171.   printf("Now exiting...\n");
  172.   CloseLibrary(AMIPX_Library);
  173.  }
  174. }
  175.