ztcp.c

十七种模拟器源代码 非常有用的作课程设计不可缺少的

        RecvFlags[i] = 1;
        RecvBufferSize[i] = cpacketdata[4];
        i3+=cpacketdata[4]+5;
      }
      if (cpacketdata[0] & 0x08){
        retval=cpacketdata[i3];
        i3++;
        for (i2=0;i2<retval;i2++){
          i=cpacketdata[i3];
          i5=cpacketdata[i3+1];
          i3+=2;
          RecvFlags[i] = 1;
          RecvBufferSize[i] = i5;
          if ((cpacketdata[i3]==0) && (i5==3)){
            i7 = cpacketdata[i3+2];
            for (i6=0;i6<i7;i6++){
              RecvFlags[(i-i6) & 0xFF] = 1;
              RecvBufferSize[(i-i6) & 0xFF] = 2;
            }
            for (i4=0;i4<i5;i4++){
              for (i6=0;i6<i7;i6++)
                RecvBuffer[(((i-i6) & 0xFF) << 5)+i4]=cpacketdata[i3];
              i3++;
            }
          }
          else
          {
           for (i4=0;i4<i5;i4++){
              RecvBuffer[(i << 5)+i4]=cpacketdata[i3];
              i3++;
            }
          }
        }
      }
   }

   return(0);
}


void PacketResend()
{
   int i;
   for (i=0;i<256;i++) {
     if ((packettimeleft[i]==0) && (packetconfirm[i]==0)){
       packettimeleft[i]=180;
       if (packetresent[i]==1) packettimeleft[i]=60;
       if (packetresent[i]==2) packettimeleft[i]=90;
       if (packetsize[i]>512) packettimeleft[packetnum]=60*3;
       packetresent[i]++;
       CopyMemory(&(cpacketdata[2]),&(packetdata[2048*(i & 0x0F)]),packetsize[i]);
       cpacketdata[0]=1;
       cpacketdata[1]=(char)i;
       sendto(ugamesocket,cpacketdata,packetsize[i]+2,0,(struct sockaddr *)&ugameaddress,sizeof(ugameaddress));
     }
   }
}

extern void UpdateVFrame(void);

int SendData(int dsize,unsigned char *dptr)
{
   int retval;

   if (UDPEnable){
/*      retval = sendto(ugamesocket,dptr,dsize,0,(struct sockaddr *)&ugameaddress,sizeof(ugameaddress));
      if (retval == SOCKET_ERROR)
           {
         closesocket(gamesocket);
         return(-1);
           }
      return(0);  */

     if (((packetnum-packetnumhead) & 0xFF) >= 15){
//        sprintf(message1,"Packet Overflow.");
//        MessageBox (NULL, message1, "Init Error" , MB_ICONERROR );

        // wait for receive packet, call JoyRead while waiting
        while (((packetnum-packetnumhead) & 0xFF) >= 15){
           PacketResend();
           PacketReceive();
           UpdateVFrame();
           while ((packetconfirm[packetnumhead]) && (packetnum!=packetnumhead))
             packetnumhead=(packetnumhead+1) & 0xFF;
        }
     }
     CopyMemory(&(cpacketdata[2]),dptr,dsize);
     CopyMemory(&(packetdata[2048*(packetnum & 0x0F)]),dptr,dsize);
     packetsize[packetnum]=dsize;
     packetconfirm[packetnum]=0;
     cpacketdata[0]=1;
     cpacketdata[1]=(char)packetnum;
     retval = sendto(ugamesocket,cpacketdata,dsize+2,0,(struct sockaddr *)&ugameaddress,sizeof(ugameaddress));
     packettimeleft[packetnum]=60;
     if (dsize>512) packettimeleft[packetnum]=90;
     packetresent[packetnum]=1;
     packetnum=(packetnum+1) & 0xFF;
     if (retval == SOCKET_ERROR)
          {
        closesocket(ugamesocket);
        return(-1);
          }
     return(0);
   }

   /* send data with the socket */
   retval = send(gamesocket,dptr,dsize,0);
   if (retval == SOCKET_ERROR)
	{
      closesocket(gamesocket);
      return(-1);
	}
   return(0);
}


/**********************************************************\
* Send data UDP                                            *
* - parameters :                                           *
*        - size of data                                    *
*        - pointer to data                                 *
* - return 0 on success other value on error               *
*                                                          *
* - side effects :                                         *
*        - close the socket on error                       *
\**********************************************************/

int AttachEnd(int psb){
   int i,i2,i3,ps;
//int PrevSPacket[4];
//int PrevSData[4*32];
//int PrevSSize[4];

   ps=psb;
   i2=0;
   for (i=0;i<(UDPBackTrace-1);i++){
     if (PrevSPacket[i]) i2++;
   }
//   if (PrevSPacket[0]) i2=0;
   if (i2){
      cpacketdata[0]+=8;
      cpacketdata[ps]=(char)i2;
      ps++;
      for (i=0;i<(UDPBackTrace-1);i++){
        if (PrevSPacket[i]){
          cpacketdata[ps]=PrevSPtr[i];
          cpacketdata[ps+1]=PrevSSize[i];
          ps+=2;
          for (i3=0;i3<PrevSSize[i];i3++){
            cpacketdata[ps]=PrevSData[i*32+i3];
            ps++;
          }
        }
      }
      for (i=0;i<(UDPBackTrace-2);i++){
        PrevSPacket[i]=PrevSPacket[i+1];
        PrevSSize[i]=PrevSSize[i+1];
        PrevSPtr[i]=PrevSPtr[i+1];
        CopyMemory(&(PrevSData[i*32]),&(PrevSData[i*32+32]),32);
      }
   }

   return ps;
}

int SendDataUDP(int dsize,unsigned char *dptr)
{
   int retval,i;
   int packetsize;



//   return (SendData(dsize,dptr));

   if (UDPEnable){

/*int SendPtr;
char SendBuffer[256*32];
char SendBufferSize[256];*/
      blahblahblah++;

      packetsize = 0;

      for (i=0;i<dsize;i++)
        SendBuffer[SendPtr*32+i]=dptr[i];
      SendBufferSize[SendPtr]=dsize;

      if ((dsize == 2) && (dptr[0]<=1)){
        if (SendRepeated < 32) SendRepeated++;
        cpacketdata[0]=4;
        cpacketdata[1]=dptr[1];
        cpacketdata[2]=(char)SendPtr;
        cpacketdata[3]=(char)SendPtr2;
        cpacketdata[4]=(char)SendRepeated;
        packetsize=5;
        packetsize=AttachEnd(packetsize);
        PrevSPacket[UDPBackTrace-2]=0;
        SendPtr=(SendPtr+1) & 0xFF;
        if (!SendPtr) SendPtr2=(SendPtr2+1) & 0xFF;
        retval = sendto(ugamesocket,cpacketdata,packetsize,0,(struct sockaddr *)&ugameaddress,sizeof(ugameaddress));
        if (retval == SOCKET_ERROR)
           {
         closesocket(gamesocket);
         return(-1);
           }
      } else {
        if (SendRepeated){
          PrevSPacket[UDPBackTrace-2]=1;
          PrevSSize[UDPBackTrace-2]=3;
          PrevSData[(UDPBackTrace-2)*32]=0;
          PrevSData[(UDPBackTrace-2)*32+1]=dptr[1];
          PrevSData[(UDPBackTrace-2)*32+2]=SendRepeated;
          PrevSPtr[UDPBackTrace-2]=(SendPtr-1) & 0xFF;
        }
        SendRepeated=0;
        cpacketdata[0]=5;
        cpacketdata[1]=dptr[1];
        cpacketdata[2]=SendPtr;
        cpacketdata[3]=SendPtr2;
        cpacketdata[4]=dsize;
        packetsize=5;
        for (i=0;i<dsize;i++)
          cpacketdata[i+5]=dptr[i];
        packetsize+=dsize;
        packetsize=AttachEnd(packetsize);

        PrevSPacket[UDPBackTrace-2]=1;
        PrevSSize[UDPBackTrace-2]=dsize;
        for (i=0;i<dsize;i++)
          PrevSData[(UDPBackTrace-2)*32+i]=dptr[i];
        PrevSPtr[UDPBackTrace-2]=SendPtr;

        SendPtr=(SendPtr+1) & 0xFF;
        if (!SendPtr) SendPtr2=(SendPtr2+1) & 0xFF;
        retval = sendto(ugamesocket,cpacketdata,packetsize,0,(struct sockaddr *)&ugameaddress,sizeof(ugameaddress));
        if (retval == SOCKET_ERROR)
           {
         closesocket(gamesocket);
         return(-1);
           }
      }
      return(0); 
   }

   /* send data with the socket */
   retval = sendto(gamesocket,dptr,dsize,0,(struct sockaddr *) &ugameaddress,sizeof(struct sockaddr));
   if (retval == SOCKET_ERROR)
	{
      closesocket(gamesocket);
      return(-1);
	}
   return(0);
}


/**********************************************************\
* Get data left                                            *
* - return size left on success negative value on error    *
*                                                          *
* - side effects :                                         *
*        - close the socket on error                       *
\**********************************************************/

int GetLeft()
{
   int retval;
   int tempsize;
#ifdef __LINUX__
   retval = ioctl(gamesocket,FIONREAD,&tempsize);
#else
   retval = ioctlsocket(gamesocket,FIONREAD,&tempsize);
#endif
   if (retval == SOCKET_ERROR)
	{
      closesocket(gamesocket);
      return(-1);
	}
   return(tempsize);
}


/**********************************************************\
* Receive data                                             *
* - parameters :                                           *
*        - size of data                                    *
*        - pointer to data                                 *
* - return size on success negative value on error         *
*                                                          *
* - side effects :                                         *
*        - close the socket on error                       *
\**********************************************************/

int GetData(int dsize,unsigned char *dptr)
{
   int retval,i;
   int dataleft;

   retval=0;

      // Temporary UDP routines
   if (UDPEnable) {

     PacketResend();
     PacketReceive();

     i=packetrecvhead;
     if (packetreceived[i]){
       CopyMemory(dptr,&(packetrdata[2048*(i & 0x0F)]),packetreceivesize[i]);
       retval = packetreceivesize[i];
       packetreceived[(i+128) & 0xFF]=0;
       packetrecvhead=(packetrecvhead+1) & 0xFF;
       return(retval); 
     }

     i=RecvPtr;
     if ((RecvFlags[i]) && (UDPMode2)){
       CopyMemory(dptr,&(RecvBuffer[32*i]),RecvBufferSize[i]);
       retval = RecvBufferSize[i];
       RecvFlags[(i+128) & 0xFF]=0;
       RecvPtr=(RecvPtr+1) & 0xFF;
       if (!RecvPtr) RecvPtr2=(RecvPtr2+1) & 0xFF;
       CounterA=90;
       return(retval);
     }

     if ((CounterA==0) & (UDPMode2)){
       // Send 16+RecvPtr
       cpacketdata[0]=16;
       cpacketdata[1]=RecvPtr;
       sendto(ugamesocket,cpacketdata,2,0,(struct sockaddr *)&ugameaddress,sizeof(ugameaddress));
       CounterA=90;
       return(0);
     }

     return(0);
   }

   dataleft=GetLeft();
   if(dataleft==0) return(0);

   if(dataleft<dsize)
   {
      dsize=dataleft;
   }
   /* get data with the socket */
   retval = recv(gamesocket,dptr,dsize,0);
   if (retval == SOCKET_ERROR)
	{
      closesocket(gamesocket);
      return(-1);
	}
   return(retval);
}


void GetHostName()
{
  HOSTENT* phe;

  if (!InitTCP()){

    strcpy(hostname,"YOUR IP: ");
    gethostname(blah,255);
    phe = gethostbyname(blah);
    strcpy(blah, inet_ntoa(*(struct in_addr*)phe->h_addr));
    strcat(hostname,blah);
  }
}

void UDPWait1Sec(){
  CounterB=60;
  while (CounterB>0)
    UpdateVFrame();
}

void UDPClearVars(){
  int i;
  CounterA=-1;
  RecvPtr = 0;
  SendPtr = 0;
  for (i=0;i<16;i++)
    PrevSPacket[i]=0;
  for (i=0;i<256;i++)
    RecvFlags[i]=0;
}

void UDPEnableMode(){
  UDPMode2=1;
}

void UDPDisableMode(){
  UDPMode2=0;
}

void WinErrorA2(void){
#ifdef __LINUX__
	STUB_FUNCTION;
#else
    char message1[256];
    sprintf(message1,"Failed waiting for checksum.");
    MessageBox (NULL, message1, "Init Error" , MB_ICONERROR );
#endif
}

void WinErrorB2(void){
#ifdef __LINUX__
	STUB_FUNCTION;
#else
    char message1[256];
    sprintf(message1,"Failed waiting for confirmation.");
    MessageBox (NULL, message1, "Init Error" , MB_ICONERROR );
#endif
}

void WinErrorC2(void){
#ifdef __LINUX__
	STUB_FUNCTION;
#else
    char message1[256];
    sprintf(message1,"Failed waiting for confirmation(B).");
    MessageBox (NULL, message1, "Init Error" , MB_ICONERROR );
#endif
}