Пример #1
0
void InitAsyncConnections(void)
{
	WSADATA WSAData; 
	
	if (WSAStartup(MAKEWORD(1,1),&WSAData) != 0)
	{
		eprintf("InitAsyncConnections can't open WinSock!\n");
		return;
	}
	
	maintenance_buffer = (char *)malloc(strlen(ConfigStr(SOCKET_MAINTENANCE_MASK)) + 1);
	strcpy(maintenance_buffer,ConfigStr(SOCKET_MAINTENANCE_MASK));

	// now parse out each maintenance ip
	maintenance_masks[num_maintenance_masks] = strtok(maintenance_buffer,";");
	while (maintenance_masks[num_maintenance_masks] != NULL)
	{
		num_maintenance_masks++;
		if (num_maintenance_masks == MAX_MAINTENANCE_MASKS)
			break;
		maintenance_masks[num_maintenance_masks] = strtok(NULL,";");		
	}

	/*
	{
		int i;
		for (i=0;i<num_maintenance_masks;i++)
		{
			dprintf("mask %i is [%s]\n",i,maintenance_masks[i]);
		}
	}
	*/
}
Пример #2
0
/*
 * LoadRsc: Loads the RESOURCE_RSC_SPEC files (.rsc or .rsb).
 */
void LoadRsc(void)
{
   char file_load_path[MAX_PATH+FILENAME_MAX];
   char *filespec = ConfigStr(RESOURCE_RSC_SPEC);
   char *filepath = ConfigStr(PATH_RSC);

   int files_loaded = 0;
   sprintf(file_load_path, "%s%s", filepath, filespec);
   StringVector files;
   if (FindMatchingFiles(file_load_path, &files))
   {
      for (StringVector::iterator it = files.begin(); it != files.end(); ++it)
      {
         sprintf(file_load_path, "%s%s", filepath, it->c_str());

         if (RscFileLoad(file_load_path, EachLoadRsc))
         {
            if (stricmp(filespec, "*.rsb") == 0)
               LoadRSBHash(file_load_path);
            files_loaded++;
         }
         else
            eprintf("LoadRsc error loading %s\n", it->c_str());
      }
   }

   dprintf("LoadRsc loaded %i of %i found %s files\n",
      files_loaded, files.size(), filespec);

}
Пример #3
0
void LoadMotd(void)
{
   char file_load_path[MAX_PATH+FILENAME_MAX];
   char file_copy_path[MAX_PATH+FILENAME_MAX];

   sprintf(file_load_path,"%s%s",ConfigStr(PATH_MOTD),MOTD_FILE);
   sprintf(file_copy_path,"%s%s",ConfigStr(PATH_MEMMAP),MOTD_FILE);

   /* if there's a new motd file, move it in */

   if (access(file_load_path,0) != -1)
      if (!MoveFileEx(file_load_path,file_copy_path,MOVEFILE_REPLACE_EXISTING))
	 eprintf("LoadMotd can't move %s\n",MOTD_FILE);
      /*
      else
	 dprintf("LoadMotd moved in the new message of the day\n");
      */

   LoadMotdName(file_copy_path);
/*
   if (motd != NULL)
      dprintf("LoadMotd loaded the message of the day\n");
   else
      dprintf("LoadMotd found no message of the day\n");
*/
}
Пример #4
0
void SaveControlFile(int save_time)
{
   char save_name[MAX_PATH+FILENAME_MAX];
   FILE *savefile;

   sprintf(save_name,"%s%s",ConfigStr(PATH_LOADSAVE),SAVE_CONTROL_FILE);
   if ((savefile = fopen(save_name,"wt")) == NULL)
   {
      eprintf("SaveContrtolFile can't open %s to save date/time of successful save!!!\n",
	      save_name);
      return;
   }

   fprintf(savefile,"#\n");
   fprintf(savefile,"# Control file for last successful save\n");
   fprintf(savefile,"#\n");
   fprintf(savefile,"# Files written:\n");
   fprintf(savefile,"# %s%s%i\n",ConfigStr(PATH_LOADSAVE),GAME_FILE_SAVE,save_time);
   fprintf(savefile,"# %s%s%i\n",ConfigStr(PATH_LOADSAVE),ACCOUNT_FILE_SAVE,save_time);
   fprintf(savefile,"# %s%s%i\n",ConfigStr(PATH_LOADSAVE),STRING_FILE_SAVE,save_time);
   fprintf(savefile,"# %s%s%i\n",ConfigStr(PATH_LOADSAVE),DYNAMIC_RSC_FILE_SAVE,save_time);
   fprintf(savefile,"#\n");
   fprintf(savefile,"# Last successful save was at %s\n",TimeStr(save_time));
   fprintf(savefile,"#\n");
   fprintf(savefile,"\n");
   fprintf(savefile,"LASTSAVE %i\n",save_time);
   
   fclose(savefile);
}
Пример #5
0
void LoadBof(void)
{
	HANDLE hFindFile;
	WIN32_FIND_DATA search_data;
	int files_found;
	int files_loaded;
	char file_load_path[MAX_PATH+FILENAME_MAX];
	char file_copy_path[MAX_PATH+FILENAME_MAX];
	
	files_found = 0;
	files_loaded = 0;
	
	sprintf(file_load_path,"%s%s",ConfigStr(PATH_BOF),BOF_SPEC);
	hFindFile = FindFirstFile(file_load_path,&search_data);
	if (hFindFile != INVALID_HANDLE_VALUE)
	{
		do
		{
			files_found++; 
			sprintf(file_load_path,"%s%s",ConfigStr(PATH_BOF),search_data.cFileName);
			sprintf(file_copy_path,"%s%s",ConfigStr(PATH_MEMMAP),search_data.cFileName);
			if (BlakMoveFile(file_load_path,file_copy_path))
				files_loaded++;
		} while (FindNextFile(hFindFile,&search_data));
		FindClose(hFindFile);
	}
	
	/*
	if (files_found > 0)
	dprintf("LoadBof moved in %i of %i found new .bof files\n",files_loaded,files_found);
	*/

	//dprintf("starting to load bof files\n");
	files_found = 0;
	files_loaded = 0;
	
	sprintf(file_load_path,"%s%s",ConfigStr(PATH_MEMMAP),BOF_SPEC);
	hFindFile = FindFirstFile(file_load_path,&search_data);
	if (hFindFile != INVALID_HANDLE_VALUE)
	{
		do
		{
			files_found++; 
			sprintf(file_load_path,"%s%s",ConfigStr(PATH_MEMMAP),search_data.cFileName);
			
			if (LoadBofName(file_load_path))
				files_loaded++;
			else
				eprintf("LoadAllBofs can't load %s\n",search_data.cFileName);
		} while (FindNextFile(hFindFile,&search_data));
		FindClose(hFindFile);
	}
	
	SetClassesSuperPtr();
	SetClassVariables();
	SetMessagesPropagate();

	//dprintf("LoadBof loaded %i of %i found .bof files\n",files_loaded,files_found);
}
Пример #6
0
int SaveAll(void)
{
   Bool save_ok;
   int save_time;
   char save_name[MAX_PATH+FILENAME_MAX];
   char time_str[100];
   
   /* Note:  You must call GarbageCollect() right before SaveAll() */
   
/*
	 charlie: machine sets the local time from a time synch server
     its potentially dangerous, but only if the time has been changed
	 between either server startup or last save, which is unlikely to
	 have drifted by much, things will only start to freak out if the 
	 difference is more than say a minute behind, meaning the all the
	 timers will run for an extra minute.. its better this way as the 
	 time is going to be corrected every (currently) 4 hours , even
	 the worst PC clocks aren`t going to degrade that much in 4 hours
*/
     
   /* The current time is used as a suffix to the save filenames.  
      We make our own copy since the time functions use a static
      buffer. */
   save_time = GetTime();
   sprintf(time_str,"%i",save_time);
   
   save_ok = True;

   lprintf("Saving game (time stamp %s)...\n", time_str);
   
   sprintf(save_name,"%s%s%s",ConfigStr(PATH_LOADSAVE),GAME_FILE_SAVE,time_str);
   if (SaveGame(save_name) == False)
      save_ok = False;

   sprintf(save_name,"%s%s%s",ConfigStr(PATH_LOADSAVE),STRING_FILE_SAVE,time_str);
   if (SaveStrings(save_name) == False)
      save_ok = False;

   sprintf(save_name,"%s%s%s",ConfigStr(PATH_LOADSAVE),ACCOUNT_FILE_SAVE,time_str);
   if (SaveAccounts(save_name) == False)
      save_ok = False;

   sprintf(save_name,"%s%s%s",ConfigStr(PATH_LOADSAVE),DYNAMIC_RSC_FILE_SAVE,time_str);
   if (!SaveDynamicRsc(save_name))
      save_ok = False;

   if (save_ok)
      SaveControlFile(save_time);
   
   lprintf("Save game successful (time stamp %s).\n", time_str);

   if (save_ok)
      return save_time;

   return 0;
}
Пример #7
0
void LoadAdminConstants(void)
{
   FILE *constantsfile;
   char line[MAX_CONSTANTS_LINE];
   int lineno;
   char *name_str, *value_str;
   int value;

   if (ConfigBool(CONSTANTS_ENABLED) == False)
      return;

   if ((constantsfile = fopen(ConfigStr(CONSTANTS_FILENAME), "rt")) == NULL)
   {
      eprintf("LoadAdminConstants can't open %s, no constants\n",
         ConfigStr(CONSTANTS_FILENAME));
      return;
   }

   lineno = 0;

   while (fgets(line, MAX_CONSTANTS_LINE, constantsfile))
   {
      lineno++;

      name_str = strtok(line, "= \t\n");

      /* ignore blank lines */
      if (name_str == NULL)
         continue;

      /* ignore comments lines */
      if (strlen(name_str) > 1 && name_str[0] == '/' && name_str[1] == '/')
         continue;

      value_str = strtok(NULL, "= \t\n");

      if (name_str == NULL || name_str[0] == '/')
      {
         eprintf("LoadAdminConstants error reading value on line %i\n", lineno);
         continue;
      }

      if (sscanf(value_str, "%i", &value) != 1)
      {
         eprintf("LoadAdminConstants error parsing integer on line %i\n", lineno);
         continue;
      }

      AddAdminConstant(name_str, value);

   }

   fclose(constantsfile);
}
Пример #8
0
void LoadBof(void)
{
	char file_load_path[MAX_PATH+FILENAME_MAX];
	char file_copy_path[MAX_PATH+FILENAME_MAX];
	
	int files_loaded = 0;
	
	sprintf(file_load_path,"%s%s",ConfigStr(PATH_BOF),BOF_SPEC);
   StringVector files;
   if (FindMatchingFiles(file_load_path, &files))
   {
      for (StringVector::iterator it = files.begin(); it != files.end(); ++it)
      {
			sprintf(file_load_path,"%s%s",ConfigStr(PATH_BOF), it->c_str());
			sprintf(file_copy_path,"%s%s",ConfigStr(PATH_MEMMAP), it->c_str());
			if (BlakMoveFile(file_load_path,file_copy_path))
				files_loaded++;
      }
   }
	
	/*
	if (!files.empty())
	dprintf("LoadBof moved in %i of %i found new .bof files\n",files_loaded,files.size());
	*/

	//dprintf("starting to load bof files\n");
	files_loaded = 0;
	
	sprintf(file_load_path,"%s%s",ConfigStr(PATH_MEMMAP),BOF_SPEC);
   if (FindMatchingFiles(file_load_path, &files))
   {
      for (StringVector::iterator it = files.begin(); it != files.end(); ++it)
      {
			sprintf(file_load_path,"%s%s",ConfigStr(PATH_MEMMAP), it->c_str());
			
			if (LoadBofName(file_load_path))
				files_loaded++;
			else
				eprintf("LoadAllBofs can't load %s\n", it->c_str());
		}
	}
	
	SetClassesSuperPtr();
	SetClassVariables();
	SetMessagesPropagate();

	dprintf("LoadBof loaded %i of %i found .bof files\n",files_loaded,files.size());
}
Пример #9
0
void SetMotd(char *new_motd)
{
   int fh;
   char filename[MAX_PATH+FILENAME_MAX];

   /* write file to memmap directory */

   sprintf(filename,"%s%s",ConfigStr(PATH_MEMMAP),MOTD_FILE);

   fh = open(filename,O_CREAT | O_TRUNC | O_BINARY | O_WRONLY,S_IREAD | S_IWRITE);

   if (fh == -1)
   {
      eprintf("SetMotd error saving motd file to %s\n",filename);
      return;
   }

   if (write(fh,new_motd,strlen(new_motd)) != (int)strlen(new_motd))
   {
      eprintf("SetMotd error writing motd file to %s\n",filename);
      close(fh);
      return;
   }

   close(fh);

   ResetLoadMotd();
   LoadMotdName(filename);
}
Пример #10
0
char * GetMotd(void)
{
   if (motd != NULL)
      return motd;
   else
      return ConfigStr(MOTD_DEFAULT);
}
Пример #11
0
int GetMotdLength(void)
{
   if (motd != NULL)
      return strlen(motd);
   else
      return strlen(ConfigStr(MOTD_DEFAULT));
}
Пример #12
0
void AddBuiltInDLlist()
{
   char filename[MAX_PATH+FILENAME_MAX];
   FILE *packagefile;
   char line[MAX_PACKAGE_LINE+1];
   int lineno,time,type,size;
   
   char *t1,*t2,*t3,*t4;

   sprintf(filename,"%s%s",ConfigStr(PATH_PACKAGE_FILE),PACKAGE_FILE);
   
   if ((packagefile = fopen(filename,"rt")) == NULL)
   {
      eprintf("AddBuiltinDLlist can't open %s to load the packages!\n",
	      filename);
      return;
   }

   lineno = 0;
   while (fgets(line,MAX_PACKAGE_LINE,packagefile))
   {
      lineno++;

      t1 = strtok(line," \t\n");

      if (t1 == NULL)	/* ignore blank lines */
	 continue;

      if (*t1 == '#')   /* ignore commentns */
	 continue;

      t2 = strtok(NULL," \t\n");
      if (t2 == NULL || sscanf(t2,"%i",&time) != 1)
      {
	 eprintf("AddBuiltInDLlist (%i) can't read time\n",lineno);
	 continue;
      }
      t3 = strtok(NULL," \t\n");
      if (t3 == NULL || sscanf(t3,"%i",&type) != 1)
      {
	 eprintf("AddBuiltInDLlist (%i) can't read type\n",lineno);
	 continue;
      }
      t4 = strtok(NULL," \t\n");
      if (t4 == NULL || sscanf(t4,"%i",&size) != 1)
      {
	 size = 1024; // default file size
#if 0
	 eprintf("AddBuiltInDLlist (%i) can't read size\n",lineno);
	 continue;
#endif
      }

      AddOrUpdateDLlist(t1,time,type,size);
   }

   fclose(packagefile);
}
Пример #13
0
void CreateAccountFromSMTPMail(smtp_node *smtp)
{
#ifdef SMTP_TEST
	return;
#else
	
	int len_buf;
	char *buf;
	string_list *sl;
	
	/* put mail into buffer, than analyze, then free buffer */
	
	len_buf = 0;
	sl = smtp->data;
	while (sl != NULL)
	{
		len_buf += strlen(sl->str);
		sl = sl->next;
	}
	
	buf = (char *) AllocateMemory(MALLOC_ID_SMTP,len_buf+1);
	len_buf = 0;
	
	sl = smtp->data;
	while (sl != NULL)
	{
		strcpy(buf+len_buf,sl->str);
		len_buf += strlen(sl->str);
		sl = sl->next;
	}
	
	if (strcmp(smtp->forward_path->str,ConfigStr(EMAIL_ACCOUNT_CREATE_NAME)) == 0)
	{
		CreateAccountFromBuffer(buf);
	}
	else
	{
		if (strcmp(smtp->forward_path->str,ConfigStr(EMAIL_ACCOUNT_DELETE_NAME)) == 0)
			DeleteAccountFromBuffer(buf);
	}
	
	FreeMemory(MALLOC_ID_SMTP,buf,len_buf+1);
#endif
}
Пример #14
0
FILE *CreateFileChannel(int channel_id)
{
   char channel_file[MAX_PATH+FILENAME_MAX];
   FILE *pFile;

   sprintf(channel_file,"%s%s",ConfigStr(PATH_CHANNEL),channel_table[channel_id].file_name);
   pFile = fopen(channel_file, "ab");

   return pFile;
}
Пример #15
0
Bool ExistInternetMailName(char *s)
{
#ifdef SMTP_TEST
	return True;
#else
	
	val_type ret_val;
	
	return (strcmp(s,ConfigStr(EMAIL_ACCOUNT_CREATE_NAME)) == 0) ||
		(strcmp(s,ConfigStr(EMAIL_ACCOUNT_DELETE_NAME)) == 0);
	
	/* only account creation right now */
	
	EnterServerLock();
	ret_val.int_val = GetInternetMailObject(s);
	LeaveServerLock();
	
	return (ret_val.v.tag == TAG_OBJECT);
	
#endif   
}
Пример #16
0
void PageAlert(char *subject,char *message)
{
	char messagebuf[4000];
	char FAR hostname[256];
	unsigned int i;
	int res;
	char *mailServer;
	char *emailAddress;

	/* hostname of computer */
	gethostname((char *)&hostname ,255-1);

	mailServer = ConfigStr( EMAIL_HOST );
	emailAddress = ConfigStr( EMAIL_NAME );

	/* don`t want spaces in either subject or message */
	for(i=0;i<strlen( subject ); i++) {
		if(subject[ i ] == ' ' ) subject[ i ] = '_'; 
	}
	for(i=0;i<strlen( message ); i++) {
		if(message[ i ] == ' ' ) message[ i ] = '_'; 
	}

	/* build the command string , bypass the mail filter .. (its ok we`re inside 3do) */
	/* until i finish the internal mail sender, i`ve ignored the subject parameter */
	sprintf(messagebuf,"mailto -H %s -U %s -S Warning -M %s -D %s",mailServer,hostname,message,emailAddress);
	dprintf(messagebuf);
	
	/* calling system() requires a flush of all buffered streams */
	_flushall();

	/* handle any returns from system */
	res = system(messagebuf);

	/* handle any returns from system */
	if(res==-1) {
		DisplayErrnoText();
	} else	
		dprintf("system command returned %d\n",res);
}
Пример #17
0
void LoadRsc(void)
{
	char file_load_path[MAX_PATH+FILENAME_MAX];
	
	int files_loaded = 0;
	StringVector files;
	if (FindMatchingFiles(ConfigStr(PATH_RSC), RSC_EXTENSION, &files))
	{
		for (StringVector::iterator it = files.begin(); it != files.end(); ++it)
		{
			sprintf(file_load_path,"%s%s",ConfigStr(PATH_RSC), it->c_str());
			
			if (RscFileLoad(file_load_path,EachLoadRsc))
				files_loaded++;
			else
				eprintf("LoadRsc error loading %s\n", it->c_str());
		}
	}
	
	/*
	dprintf("LoadRsc loaded %i of %i found .rsc files\n",files_loaded,files.size());
	*/
}
Пример #18
0
void MySQLInit()
{
	if (ConfigBool(MYSQL_ENABLED) == False)
		return;
	enabled = true;

	mysqlcon = mysql_init(NULL);

	if (mysqlcon == NULL)
	{
		dprintf("%s\n", mysql_error(mysqlcon));
		return;
	}

	if (mysql_real_connect(mysqlcon, ConfigStr(MYSQL_HOST), ConfigStr(MYSQL_USERNAME), ConfigStr(MYSQL_PASSWORD), NULL, 0, NULL, 0) == NULL) 
    {
		dprintf("Error connecting: %s\n", mysql_error(mysqlcon));
		dprintf("host: %s user: %s pass: %s", ConfigStr(MYSQL_HOST), ConfigStr(MYSQL_USERNAME), ConfigStr(MYSQL_PASSWORD));
		mysql_close(mysqlcon);
		return;
    } 
	else
	{
		dprintf("connected to mysql host: %s user: %s", ConfigStr(MYSQL_HOST),ConfigStr(MYSQL_USERNAME) );
	}

	//Check for valid schema here...

	char buf[100];
	sprintf(buf, "USE %s", ConfigStr(MYSQL_DB));
	if(mysql_query(mysqlcon, buf))
	{
		dprintf("Error selecting databsae: %s\n", mysql_error(mysqlcon));
		return;
	}
	else
	{
		dprintf("connected to mysql database: %s", ConfigStr(MYSQL_DB));
	}
	connected = true;
    return;
}
Пример #19
0
void InitAccount(void)
{
   accounts = NULL;
   next_account_id = 1;

   console_account = &console_account_node;
   console_account->account_id = 0;
   console_account->name = ConfigStr(CONSOLE_ADMINISTRATOR);
   console_account->password = (char *)AllocateMemory(MALLOC_ID_ACCOUNT,1);
   console_account->password[0] = 0;

   console_account->type = ACCOUNT_ADMIN;
   console_account->last_login_time = 0;
   console_account->suspend_time = 0;
   console_account->credits = 0;
}
Пример #20
0
account_node * AccountLoginByName(char *name)
{
   account_node *a;

   if (0 == stricmp(name,ConfigStr(GUEST_ACCOUNT)))
   {
      if (GetUsedGuestAccounts() >= ConfigInt(GUEST_MAX))
	 return NULL;

      a = accounts;
      while (a != NULL)
      {
	 if (a->type == ACCOUNT_GUEST)
	 {
	    if (GetSessionByAccount(a) == NULL)
	    {
	       /* no one using this particular guest account, so we will */

	       /* give guests credits every time they login */
	       /* a->credits = 100*ConfigInt(GUEST_CREDITS); */
	       
	       return a;
	    }
	 }
	 a = a->next;
      }
   }
   else
   {
      a = accounts;
      while (a != NULL)
      {
	 if (!stricmp(a->name,name))
	 {
	    /* give administrators credits every time they login */
	    /*
	    if (a->type == ACCOUNT_ADMIN)
	       a->credits = 100*ConfigInt(CREDIT_ADMIN);
	       */
	    return a;
	 }
	 a = a->next;
      }
   }
   return NULL;
}
Пример #21
0
int LoadRoom(int resource_id)
{
   val_type ret_val;
   resource_node* r;
   room_rsc_node *rrsc;
   char s[MAX_PATH + FILENAME_MAX];

   /****************************************************************/

   r = GetResourceByID(resource_id);
   if (!r)
   {
      bprintf("LoadRoomData can't find resource %i\n",resource_id);
      return NIL;
   }

   ret_val.v.tag = TAG_ROOM_DATA;

   /****************************************************************/

   // CASE 1: Reuse already loaded ROO
   if (room_rscs)
   {
      rrsc = room_rscs[resource_id % INIT_ROOMTABLE_SIZE];
      while (rrsc)
      {
         if (rrsc->resource_id == resource_id)
         {
            ret_val.v.data = rrsc->roomdata_id;
            return ret_val.int_val;
         }
         rrsc = rrsc->next;
      }
   }

   /****************************************************************/

   // CASE 2: Load ROO
   room_node* newnode = (room_node*)AllocateMemory(MALLOC_ID_ROOM, sizeof(room_node));

   // combine path for roo and filename
   sprintf(s, "%s%s", ConfigStr(PATH_ROOMS), r->resource_val[0]);

   // try load it
   if (!BSPLoadRoom(s, &newnode->data))
   {
      FreeMemory(MALLOC_ID_ROOM, newnode, sizeof(room_node));
      bprintf("LoadRoomData couldn't open %s!!!\n",r->resource_val[0]);
      return NIL;
   }

   // Add this room_node to the rooms table.
   newnode->data.roomdata_id = idcounter++;
   newnode->data.resource_id = resource_id;
   newnode->next = rooms[newnode->data.roomdata_id % INIT_ROOMTABLE_SIZE];
   rooms[newnode->data.roomdata_id % INIT_ROOMTABLE_SIZE] = newnode;

   // Add room_rsc_node for this resource.
   rrsc = (room_rsc_node *)AllocateMemory(MALLOC_ID_ROOM, sizeof(room_rsc_node));

   rrsc->resource_id = resource_id;
   rrsc->roomdata_id = newnode->data.roomdata_id;
   rrsc->next = room_rscs[resource_id % INIT_ROOMTABLE_SIZE];
   room_rscs[resource_id % INIT_ROOMTABLE_SIZE] = rrsc;

   ret_val.v.data = newnode->data.roomdata_id;
   return ret_val.int_val;
}
Пример #22
0
void ServiceTimers(void)
{
   MSG msg;
   INT64 ms;

   StartupComplete(); /* for the interface to report no errors on startup */
   InterfaceUpdate();
   lprintf("Status: %i accounts\n",GetNextAccountID());

   lprintf("-------------------------------------------------------------------------------------\n");
   dprintf("-------------------------------------------------------------------------------------\n");
   eprintf("-------------------------------------------------------------------------------------\n");

   in_main_loop = True;
   SetWindowText(hwndMain, ConfigStr(CONSOLE_CAPTION));

	AsyncSocketStart();

   for(;;)
   {
      if (timers == NULL)
			ms = 500;
      else
      {
			ms = timers->time - GetMilliCount();
			if (ms <= 0)
				ms = 0;
	 
			if (ms > 500)
				ms = 500;
      }	 
      
      if (MsgWaitForMultipleObjects(0,NULL,0,(DWORD)ms,QS_ALLINPUT) == WAIT_OBJECT_0)
      {
	 while (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
	 {
	    if (msg.message == WM_QUIT)
	    {
	       lprintf("ServiceTimers shutting down the server\n");   
	       return;
	    }
	    
	    switch (msg.message)
	    {
	    case WM_BLAK_MAIN_READ :
	       EnterServerLock();
	       
	       PollSession(msg.lParam);
	       TimerActivate();
	       
	       LeaveServerLock();
	       break;
	    case WM_BLAK_MAIN_RECALIBRATE :
	       /* new soonest timer, so we should recalculate our time left... 
		  so we just need to restart the loop! */
	       break;
	    case WM_BLAK_MAIN_DELETE_ACCOUNT :
	       EnterServerLock();
	       DeleteAccountAndAssociatedUsersByID(msg.lParam);
	       LeaveServerLock();
	       break;

	    case WM_BLAK_MAIN_VERIFIED_LOGIN :
	       EnterServerLock();
	       VerifiedLoginSession(msg.lParam);
	       LeaveServerLock();
	       break;
       case WM_BLAK_MAIN_LOAD_GAME :
          EnterServerLock();
          LoadFromKod(msg.lParam);
          LeaveServerLock();
          break;

	    default :
	       dprintf("ServiceTimers got unknown message %i\n",msg.message);
	       break;
	    }
	 }
      }
      else
      {
	 /* a Blakod timer is ready to go */
	 
	 EnterServerLock();
	 PollSessions(); /* really just need to check session timers */
	 TimerActivate();
	 LeaveServerLock();
      }
   }
}