Exemplo n.º 1
0
/*
============
WriteGame

This will be called whenever the game goes to a new level,
and when the user explicitly saves the game.

Game information include cross level data, like multi level
triggers, help computer info, and all client states.

A single player death will automatically restore from the
last save position.
============
*/
void WriteGame (char *filename, qboolean autosave)
{
	FILE	*f;
	int		i;
	char	str[16];

	if (!autosave)
		SaveClientData ();

	f = fopen (filename, "wb");
	if (!f)
		gi.error ("Couldn't open %s", filename);

	memset (str, 0, sizeof(str));
	strcpy (str, __DATE__);
	fwrite (str, sizeof(str), 1, f);

	game.autosaved = autosave;
	fwrite (&game, sizeof(game), 1, f);
	game.autosaved = false;

	for (i=0 ; i<game.maxclients ; i++)
		WriteClient (f, &game.clients[i]);

	fclose (f);
}
Exemplo n.º 2
0
/*
 * Writes the game struct into
 * a file. This is called when
 * ever the games goes to e new
 * level or the user saves the
 * game. Saved informations are:
 * - cross level data
 * - client states
 * - help computer info
 */
void
WriteGame(const char *filename, qboolean autosave)
{
    FILE *f;
    int i;
    char str_ver[32];
    char str_game[32];
    char str_os[32];
    char str_arch[32];

    if (!autosave)
    {
        SaveClientData();
    }

    f = fopen(filename, "wb");

    if (!f)
    {
        gi.error("Couldn't open %s", filename);
    }

    /* Savegame identification */
    memset(str_ver, 0, sizeof(str_ver));
    memset(str_game, 0, sizeof(str_game));
    memset(str_os, 0, sizeof(str_os));
    memset(str_arch, 0, sizeof(str_arch));

    strncpy(str_ver, SAVEGAMEVER, sizeof(str_ver));
    strncpy(str_game, GAMEVERSION, sizeof(str_game));
    strncpy(str_os, OS, sizeof(str_os));
    strncpy(str_arch, ARCH, sizeof(str_arch));

    fwrite(str_ver, sizeof(str_ver), 1, f);
    fwrite(str_game, sizeof(str_game), 1, f);
    fwrite(str_os, sizeof(str_os), 1, f);
    fwrite(str_arch, sizeof(str_arch), 1, f);

    game.autosaved = autosave;
    fwrite(&game, sizeof(game), 1, f);
    game.autosaved = false;

    for (i = 0; i < game.maxclients; i++)
    {
        WriteClient(f, &game.clients[i]);
    }

    fclose(f);
}
Exemplo n.º 3
0
//
// This is a special callback function used by the DLL for certain extra 
// functionality. Look at the API help for details.
//
BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest,
				LPVOID lpvBuffer, LPDWORD lpdwSize, LPDWORD lpdwDataType){

	TIsapiContext *c = (TIsapiContext *)hConn;
	char *lpszRespBuf;
	char * temp = NULL;
	DWORD dwBytes;
	BOOL bRet = TRUE;

	switch(dwHSERequest) {
		case (HSE_REQ_SEND_RESPONSE_HEADER) :
			lpszRespBuf = (char *)xmalloc(*lpdwSize);//+ 80);//accomodate our header
			if (!lpszRespBuf)
				return FALSE;
			wsprintf(lpszRespBuf,"%s",
				//HTTP_VER,
				
				/* Default response is 200 Ok */

				//lpvBuffer?lpvBuffer:"200 Ok",
				
				/* Create a string for the time. */
				//temp=MakeDateStr(),

				//SERVER_VERSION,
				
				/* If this exists, it is a pointer to a data buffer to
				   be sent. */
				lpdwDataType?(char *)lpdwDataType:NULL);

			if (temp) xfree(temp);

			dwBytes = strlen(lpszRespBuf);
			bRet = WriteClient(0, lpszRespBuf, &dwBytes, 0);
			xfree(lpszRespBuf);

			break;
			//
			// A real server would do cleanup here
		case (HSE_REQ_DONE_WITH_SESSION):
			SetEvent(c->waitEvent);
			//ExitThread(0);
			break;
		
		//
		// This sends a redirect (temporary) to the client.
		// The header construction is similar to RESPONSE_HEADER above.
		//
		case (HSE_REQ_SEND_URL_REDIRECT_RESP):
			lpszRespBuf = (char *)xmalloc(*lpdwSize +80) ;
			if (!lpszRespBuf)
				return FALSE;
			wsprintf(lpszRespBuf,"%s %s %s\r\n",
					HTTP_VER,
					"302 Moved Temporarily",
					(lpdwSize > 0)?lpvBuffer:0);
			xfree(temp);
			dwBytes = strlen(lpszRespBuf);
			bRet = WriteClient(0, lpszRespBuf, &dwBytes, 0);
			xfree(lpszRespBuf);
			break;
		default:
			return FALSE;
		break;
	}
	return bRet;
	
}
Exemplo n.º 4
0
int main (int argc, char **argv)
{
  int listenPort = 5002;
  int listenFd;
  struct a_client *theClients=0;
  int nbClient=0;
  struct pollfd *fds=0;
  int maxClientFd=-1;
  long dataLen = 6 *1024 * 1024;
  long stopAfter = 0;
  void *buf = 0;
  int buflen = 0;
  struct timeval startTime;
  struct timeval endTime;


  initBuffer (&buf, &buflen);
  listenFd = socket (AF_INET, SOCK_STREAM, 0);

  if (listenFd < 0)
    {
      fprintf (stderr, "Unable to open socket ? errno %d\n",errno);
      exit (1);
    }
  if (argc >= 2)
    {
      listenPort = atoi (argv[1]);
    }
  if (argc >= 3)
    {
      dataLen= atoi (argv[2]);
    }
  if (argc >= 4)
    {
      stopAfter= atoi (argv[3]);
    }
  struct sockaddr_in addr;
  addr.sin_family = AF_INET;
  addr.sin_port = htons (listenPort);
  addr.sin_addr.s_addr = INADDR_ANY;

  int status;
  status = bind (listenFd, (const struct sockaddr *) &addr, sizeof(addr));
  if (status)
    {
      fprintf (stderr, "Unable to open bind ? errno %d\n",errno);
      exit (2);
    }
  status = listen (listenFd, 256);
  if (status)
    {
      fprintf (stderr, "Unable to open listen ? errno %d \n",errno);
      exit (3);
    }

  while (1)
    {
      fds = realloc (fds, sizeof (struct pollfd) *  nbClient + 1 );

      fds[0].fd = listenFd;
      fds[0].events = POLLIN;
      fds[0].revents = 0;

      int j = 1;
      int c =0;
      for (c=0; c <= maxClientFd ; c++)
        {
          if (theClients[c].sockfd >= 0)
            {
              if (theClients[c].writeLen < dataLen)

                {
                  fds[j].fd = theClients[c].sockfd;
                  fds[j].events = POLLOUT;
                  fds[j].revents = 0;
                  j++;
                }
              else
                {
                  fds[j].fd = theClients[c].sockfd;
                  fds[j].events = POLLIN;
                  fds[j].revents = 0;
                  j++;
                }
            }
        }
      printf ("%d: --> poll j=%d\n",time(NULL), j );
      int ret = poll (fds, j, 29000 * 1000);
      printf ("%d: poll --> %d\n", time(NULL), ret);

      if (ret <= 0)
        {
          exit (0);
        }
      if (ret > 0)
        {
          int i=0;
          for (i=0; i < j; i++)
            {
              if ( fds[i].revents )
                {
                  if (i == 0)
                    { // a new cnxion
                      if ( fds[i].revents & POLLIN  )
                        {
                          int newFd = accept (listenFd, 0, 0);

                          if (newFd >= 0)
                            {
                              if ( 0 == nbClient)
                                {
                                  gettimeofday (&startTime, 0);
                                }
                              NewClient (newFd, &theClients, &nbClient, &maxClientFd);
                            }
                        }
                      if ( fds[i].revents & POLLERR  )
                        {
                          exit (4);
                        }
                    }
                  else
                    { // a client

                      printf ("Client %d revents %d \n", i, fds[i].revents );
                      gettimeofday (&endTime, 0);

                      if ( fds[i].revents & POLLOUT  )
                        {
                          WriteClient (theClients, fds[i].fd, &nbClient, dataLen, buf, buflen, duration (&startTime, &endTime));
                        }
                      if ( ( fds[i].revents & POLLHUP  ) || ( fds[i].revents & POLLIN  )  || ( fds[i].revents & POLLERR  ) )
                        {
                          gettimeofday (&endTime, 0);
                          CloseClient (theClients, fds[i].fd, &nbClient, duration (&startTime, &endTime), dataLen);
                        }
                      if ( stopAfter && ( totalClients >=  stopAfter ))
                        {
                          exit (0);
                        }
                    }
                }
            }
        }
    }
}