ztcp.c

linux下的任天堂模拟器代码。供大家参考。

#else
      sprintf(blah,"Could not connect to other side");
      MessageBox(NULL,blah,
              "Error",
              MB_SYSTEMMODAL|MB_OK);
#endif

      closesocket(gamesocket);
      return(-3);
   }

//   GetUDPStatus();

   return(0);
}

int WaitForServer(){
  int i;

  if (UDPEnable){
    if ((i=GetData(1,blah))){
      if ((i==1) && (blah[0]==1))
        return(1);
    }
    return(0);
  }
  return(1);
}


/**********************************************************\
* Disconnect from game server                              *
* - no parameters                                          *
*                                                          *
* - no known side effects                                  *
\**********************************************************/

void Disconnect()
{
   if (UDPEnable)
   {
     closesocket(ugamesocket);
     closesocket(userversocket);
     return;
   }
   PacketCounter=0;
   closesocket(gamesocket);
}


/**********************************************************\
* Start the game server                                    *
* - parameters                                             *
      - port number
* - return 0 on success other value on error               *
*                                                          *
* - no known side effects                                  *
\**********************************************************/

int StartServerCycle(unsigned short port)
{
   int retval,i;

   portval = port;
   packetnum = 0;
   packetnumhead = 0;
   packetrecvhead = 0;
   ConnectAddr = 0;
   SendRepeated = 0;
   RecvPtr = 0;
   SendPtr = 0;
   RecvPtr2 = 0;
   SendPtr2 = 0;

   for (i=0;i<16;i++)
     PrevSPacket[i]=0;


   if (UDPConfig) UDPEnable = 1;

   if (UDPEnable)
   {
      /* get host and verify if it is valid */
      PacketCounter=1;
      for (i=0;i<256;i++) {packettimeleft[i]=-1; packetconfirm[i]=1; packetreceived[i]=0; RecvFlags[i]=0;}

      userveraddress.sin_family = AF_INET;
      ugameaddress.sin_family = AF_INET;

      userveraddress.sin_addr.s_addr = INADDR_ANY;
      ugameaddress.sin_addr.s_addr = INADDR_ANY;

//      portval++;
      ugameaddress.sin_port = htons((unsigned short) portval);
      userveraddress.sin_port = htons((unsigned short) portval);
//      portval--;

      userversocket = socket(AF_INET, SOCK_DGRAM,0);
      ugamesocket = socket(AF_INET, SOCK_DGRAM,0);

      if (userversocket == INVALID_SOCKET)
      {
#ifdef __UNIXSDL__
         STUB_FUNCTION;
#else
         tcperr=WSAGetLastError();
                 sprintf(blah,"Could not initialize UDP(5) : %d",tcperr);
                 MessageBox(NULL,blah,"Error",MB_SYSTEMMODAL|MB_OK);
#endif
                 return(-2);
      }
      if (bind(userversocket,(struct sockaddr*)&userveraddress,sizeof(userveraddress))==
          SOCKET_ERROR)
      {
#ifdef __UNIXSDL__
         STUB_FUNCTION;
#else
         tcperr=WSAGetLastError();
         sprintf(blah,"Could not initialize UDP(6) : %d",tcperr);
         MessageBox(NULL,blah,"Error",MB_SYSTEMMODAL|MB_OK);
#endif
         return(-2);
      }


      blah[0]=2;
      blah[1]='C';
      blah[2]='B';
      blah[3]='A';
      blah[4]=0;


//      retval = recvfrom(userversocket,blah,5,0,
//                        (struct sockaddr *)&userveraddress,&socklen);

      ugameaddress.sin_addr.s_addr = userveraddress.sin_addr.s_addr;

      ugamesocket = socket(AF_INET, SOCK_DGRAM,0);

      return(0);

//      retval = send(gamesocket,blah,1,0);
//      retval = recv(gamesocket,blah,1,0);

   }

   /* Create the listen socket */
   serversocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
   if (serversocket == INVALID_SOCKET)
   {
#ifndef __UNIXSDL__
     tcperr=WSAGetLastError();
#endif

      return(-1);
   }

   serveraddress.sin_family = AF_INET;
   serveraddress.sin_addr.s_addr = INADDR_ANY;
   serveraddress.sin_port = htons(port);

   /* bind name and socket */
   retval = bind(serversocket,
                 (LPSOCKADDR)&serveraddress,
                 sizeof(struct sockaddr));
   if (retval == SOCKET_ERROR)
   {
#ifndef __UNIXSDL__
     tcperr=WSAGetLastError();
#endif
      closesocket(serversocket);
      return(-2);
   }

   /* setup socket to listen */
   retval = listen(serversocket, SOMAXCONN);
   if (retval == SOCKET_ERROR)
   {
#ifndef __UNIXSDL__
      tcperr=WSAGetLastError();
#endif
      closesocket(serversocket);
      return(-3);
   }

   return 0;
}

int acceptzuser()
{
   if (UDPEnable)
   {
     return(0);
   }

   /* wait for connection */

   gamesocket = accept(serversocket, NULL, NULL);
   if (gamesocket == INVALID_SOCKET)
   {
#ifndef __UNIXSDL__
      tcperr=WSAGetLastError();
#endif
      closesocket(serversocket);
      serversocket=-1;
      return(-1);
   }

//   GetUDPStatus();

   return(0);
}

int ServerCheckNewClient()
{
   FD_SET_VAR zrf;
   struct timeval nto;
   int r;

        if (UDPEnable)
        {
          r=GetData(256,blah);
          if (r == -1) return(-1);
          if (r > 0){
            ugameaddress.sin_addr.s_addr=userveraddress.sin_addr.s_addr;
            ConnectAddr = ugameaddress.sin_addr.s_addr;
            blah[0]=1;
            r=SendData(1,blah);
            return(1);
          }
          return(0);
        }

   if(serversocket == INVALID_SOCKET)
   {
      return(-1);
   }
   nto.tv_sec=0;
   nto.tv_usec=0; /* return immediately */

        FD_ZERO(&zrf);
   FD_SET(serversocket,&zrf);
   r=select(serversocket+1,&zrf,0,0,&nto);

   if(r == -1)
   {
#ifndef __UNIXSDL__
                tcperr=WSAGetLastError();
#endif
                return(-2);
   }
   if(r == 0)
   {
      return(0);
   }
        if(FD_ISSET(serversocket,&zrf))
   {
      return 1;
   }
   return(0);

}


/**********************************************************\
* Stop the game server                                     *
* - no parameters                                          *
*                                                          *
* - no known side effects                                  *
\**********************************************************/

void StopServer()
{
   if (UDPEnable)
   {
     closesocket(ugamesocket);
     closesocket(userversocket);
     return;
   }
   PacketCounter=0;
   closesocket(gamesocket);
   closesocket(serversocket);
}


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

int PacketReceive()
{
   int dataleft,i,i2,i3,i4,i5,i6,i7,retval;

   dataleft=GetLeftUDP();
   if (dataleft<=0) return(dataleft);
   i = sizeof(userveraddress);
   retval = recvfrom(userversocket,cpacketdata,2048+32,0,(struct sockaddr *)&userveraddress,&i);
   if ((ConnectAddr!=0) && (ConnectAddr != userveraddress.sin_addr.s_addr)) return(0);
   if (retval == SOCKET_ERROR)
   {
      closesocket(ugamesocket);
      return(-1);
   }
   if ((cpacketdata[0]==1) && (retval>0)) {
     i=(unsigned char)cpacketdata[1];
     blah[0]=2;
     blah[1]=cpacketdata[1];
     sendto(ugamesocket,blah,2,0,(struct sockaddr *)&ugameaddress,sizeof(ugameaddress));
     if (!packetreceived[i]){
       packetreceived[i]=1;
       packetreceivesize[i]=retval-2;
       CopyMemory(&(packetrdata[2048*(i & 0x0F)]),&(cpacketdata[2]),retval-2);
     }
   }
   if (cpacketdata[0]==2){
     packetconfirm[cpacketdata[1]]=1;
     while ((packetconfirm[packetnumhead]) && (packetnum!=packetnumhead))
       packetnumhead=(packetnumhead+1) & 0xFF;
   }

   if ((cpacketdata[0]==16) && (cpacketdata[1]!=SendPtr)){
      i=cpacketdata[1];
      cpacketdata[0]=17;
      cpacketdata[2]=SendPtr;
      i3=3;
      while (i!=SendPtr){
        cpacketdata[i3]=SendBufferSize[i];
        i3++;
        for (i4=0;i4<SendBufferSize[i];i4++){
          cpacketdata[i3]=SendBuffer[i4+(i << 5)];
          i3++;
        }
        i=(i+1) & 0xFF;
      }
      sendto(ugamesocket,cpacketdata,i3,0,(struct sockaddr *)&ugameaddress,sizeof(ugameaddress));
      return(0);
   }

   if (cpacketdata[0]==17){
     i2=cpacketdata[1];
     i3=3;
     while (i2!=cpacketdata[2]){
       i4=cpacketdata[i3];
       i3++;
       RecvFlags[i2]=1;
       RecvBufferSize[i2]=i4;
       for (i5=0;i5<i4;i5++){
         RecvBuffer[(i2 << 5)+i5]=cpacketdata[i3];
         i3++;
       }
       i2=(i2+1) & 0xFF;
     }
   }

   i2=RecvPtr+(RecvPtr2 << 8);
   i3=(cpacketdata[2]+(cpacketdata[3] << 8))-i2;
   if (i3<0) i3+=65536;

   if ((((cpacketdata[0] & 0xF7)==4) || ((cpacketdata[0] & 0xF7)==5))
      && ((i3>=0) && (i3<=127))) {


      CLatencyVal=cpacketdata[1];
      i=cpacketdata[2];
      i3=0;

      if ((cpacketdata[0] & 0x07)==4){
        for (i2=0;i2<cpacketdata[4];i2++){
          RecvBuffer[((i-i2) & 0xFF) << 5] = 0;
          RecvBuffer[(((i-i2) & 0xFF) << 5)+1] = CLatencyVal;
          RecvFlags[((i-i2) & 0xFF)] = 1;
          RecvBufferSize[((i-i2) & 0xFF)] = 2;
        }
        i3+=5;
      } else {
        for (i2=0;i2<cpacketdata[4];i2++){
          RecvBuffer[(i << 5) + i2] = cpacketdata[i2+5];
        }
        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);
}