//////////////////////////////////////////////////////////// /// Initialize the application //////////////////////////////////////////////////////////// bool ApplicationInitialize() { // Initialize mutex MutexInitialize(&AppMutex); // Start it AppSetRun(false); // Platform Initialize #ifdef SYSTEM_MACOS InitializeWorkingDirectory(); // Specific in MacOS #endif if (!UsersInitialize()) return false; // Initialize database if (!DataBaseInitialize()) return false; // Initialize protocol if (!ProtocolInitialize(12993)) return false; // Initialize console if (!ConsoleInitialize()) return false; // Run it AppSetRun(true); return true; }
//////////////////////////////////////////////////////////// /// Add user in the list //////////////////////////////////////////////////////////// void UserAdd(struct UserData * User) { // Initialize mutex MutexInitialize(&User->MutexData); // Set login status User->Logged = false; // Initialize account data AccountInitialize(User); // Set parser status User->Connection.Parser = PARSER_WAITING_PREAMBLE; // If list is empty, put the user at first if (UserList.First == NULL) { UserList.First = User; User->Previous = NULL; } else { UserList.Last->Next = User; User->Previous = UserList.Last; } if (UserList.Last != NULL) { struct UserData * UserPtr; MutexLock(&UserList.Last->MutexData); UserPtr = UserList.Last; UserList.Last = User; MutexUnlock(&UserPtr->MutexData); } else { UserList.Last = User; } User->Next = NULL; }
/*++ Function: PAL_Initialize Abstract: This function is the first function of the PAL to be called. Internal structure initialization is done here. It could be called several time by the same process, a reference count is kept. Return: 0 if successful -1 if it failed --*/ int PALAPI PAL_Initialize( int argc, char *argv[]) { LPWSTR command_line = NULL; LPWSTR exe_path = NULL; int retval = -1; /* the first ENTRY within the first call to PAL_Initialize is a special case, since debug channels are not initialized yet. So in that case the ENTRY will be called after the DBG channels initialization */ ENTRY("PAL_Initialize(argc = %d argv = %p)\n", argc, argv); /*Firstly initiate a temporary lastError storage */ StartupLastError = 0; if(NULL == init_critsec) { PCRITICAL_SECTION temp_critsec; temp_critsec = malloc(sizeof(CRITICAL_SECTION)); if(NULL == temp_critsec) { /* note that these macros probably won't output anything, since the debug channels haven't been initialized yet */ ERROR("couldn't allocate critical section!\n"); LOGEXIT("PAL_Initialize returns %d.\n",-1); return -1; } if (0 != SYNCInitializeCriticalSection(temp_critsec)) { ERROR("couldn't initialize critical section!\n"); free(temp_critsec); LOGEXIT("PAL_Initialize returns %d.\n",-1); return -1; } if(NULL != InterlockedCompareExchangePointer((LPVOID *)&init_critsec, temp_critsec, NULL)) { /* another thread got in before us! shouldn't happen, if the PAL isn't initialized there shouldn't be any other threads */ WARN("Another thread initialized the critical section\n"); DeleteCriticalSection(temp_critsec); free(temp_critsec); } } SYNCEnterCriticalSection(init_critsec, TRUE); if(init_count==0) { // Set our pid. gPID = getpid(); // Initialize the Misc TLS Index and the environment. if (FALSE == MiscInitialize()) { goto done; } // Initialize debug channel settings before anything else. // This depends on the environment, so it must come after // MiscInitialize. if (FALSE == DBG_init_channels()) { goto done; } #if _DEBUG // Verify that our page size is what we think it is. If it's // different, we can't run. if (PAGE_SIZE != getpagesize()) { ASSERT("PAGE_SIZE is incorrect for this system!\n" "Change include/pal/virtual.h and clr/src/inc/stdmacros.h " "to reflect the correct page size of %d.\n", getpagesize()); } #endif // _DEBUG /* Output the ENTRY here, since it doesn't work before initializing debug channels */ ENTRY("PAL_Initialize(argc = %d argv = %p)\n", argc, argv); if(argc<1 || argv==NULL) { ERROR("First-time initialization attempted with bad parameters!\n"); goto done; } if (!INIT_IncreaseDescriptorLimit()) { ERROR("Unable to increase the file descriptor limit!\n"); // We can continue if this fails; we'll just have problems if // we use large numbers of threads or have many open files. } if( !CODEPAGEInit() ) { ERROR( "Unable to initialize the locks or the codepage.\n" ); goto done; } #if defined(__ppc__) { int mib[2]; size_t len; /* Determine the processor's cache line size, for FlushInstructionCache */ mib[0] = CTL_HW; mib[1] = HW_CACHELINE; len = sizeof(CacheLineSize); if (sysctl(mib, 2, &CacheLineSize, &len, NULL, 0) == -1) { goto done; } } #endif //__ppc__ /* Create user's configuration directory if*/ if(FALSE == INIT_InitPalConfigDir()) { ERROR("Unable to setup PAL configuration directory!\n"); goto CLEANUP0; } /* initialize the shared memory infrastructure */ if(!SHMInitialize()) { ERROR("Shared memory initialization failed!\n"); INIT_RemovePalConfigDir(); goto CLEANUP0; } /* initialize handle manager */ if(!HMGRInitHandleManager()) { ERROR("Handle manager initialization failed!\n"); goto CLEANUP1; } /* build the command line */ command_line=INIT_FormatCommandLine(argc,argv); /* find out the application's full path */ exe_path=INIT_FindEXEPath(argv[0]); if(NULL == command_line || NULL == exe_path) { ERROR("Failed to process command-line parameters!\n"); goto CLEANUP2; } /* Initialize the mutex critical sections. */ if (FALSE == MutexInitialize()) { ERROR("Failed to initialize mutex support!\n"); goto CLEANUP2; } /* initialize structure for the inital process */ if (FALSE == PROCCreateInitialProcess(command_line, exe_path) ) { ERROR("Unable to Create the initial process\n"); goto CLEANUP4; } /* initialize structured exception handling stuff (signals, etc) */ if (FALSE == SEHInitialize()) { ERROR("Unable to initialize SEH support\n"); goto CLEANUP5; } /* Initialize the File mapping critical section. */ if (FALSE == MAPInitialize()) { ERROR("Unable to initialize file mapping support\n"); goto CLEANUP6; } /* intialize the strtok function */ if(!StrtokInitialize()) { ERROR("Unable to initialize the strtok function\n"); goto CLEANUP7; } /* initialize module manager */ if(!LOADInitializeModules(exe_path)) { ERROR("Unable to initialize module manager\n"); goto CLEANUP8; } /* Initialize the Virtual* functions. */ if (FALSE == VIRTUALInitialize()) { ERROR("Unable to initialize virtual memory support\n"); goto CLEANUP10; } /* initialize the socket worker thread */ if(!SOCKInitWinSock()) { ERROR("Unable to initialize socket worker thread\n"); goto CLEANUP12; } /* create file objects for standard handles */ if(!FILEInitStdHandles()) { ERROR("Unable to initialize standard file handles\n"); goto CLEANUP13; } /* Initialize the MsgBox functions. */ if (FALSE == MsgBoxInitialize()) { ERROR("Unable to initialize MsgBox management\n"); goto CLEANUP14; } if ( !CRTInitStdStreams() ) { ERROR("Unable to initialize CRT standard streams\n"); goto CLEANUP15; } TRACE("First-time PAL initialization complete.\n"); init_count++; /* Set LastError to a non-good value - functions within the PAL startup may set lasterror to a nonzero value. */ SetLastError(NO_ERROR); retval = 0; } else { init_count++; TRACE("Initialization count increases to %d\n", init_count); retval = 0; } goto done; CLEANUP15: MsgBoxCleanup(); CLEANUP14: FILECleanupStdHandles(); CLEANUP13: SOCKTerminateWinSock(); CLEANUP12: VIRTUALCleanup(); CLEANUP10: LOADFreeModules(TRUE); CLEANUP8: StrtokCleanup(); CLEANUP7: MAPCleanup(); CLEANUP6: SEHCleanup(); CLEANUP5: PROCCleanupInitialProcess(); CLEANUP4: FMTMSG_FormatMessageCleanUp(); MutexCleanup(); CLEANUP2: free(command_line); free(exe_path); HMGRStopHandleManager(); CLEANUP1: SHMCleanup(); INIT_RemovePalConfigDir(); CLEANUP0: CODEPAGECleanup(); ERROR("PAL_Initialize failed\n"); done: SYNCLeaveCriticalSection(init_critsec, TRUE); LOGEXIT("PAL_Initialize returns int %d\n", retval); return retval; }
//////////////////////////////////////////////////////////// /// Create (or recreate) the window //////////////////////////////////////////////////////////// bool WindowCreate(struct VideoMode * Mode, char * Title, unsigned long WindowStyle, struct WindowSettings * Params) { int Left, Top, Width, Height; bool FullScreen = false; DWORD Win32Style; RECT ActualRect; // Initialize the event mutex MutexInitialize(&WindowEventMutex); // Register the window class at first call RegisterWindowClass(); // Compute position and size Left = (GetDeviceCaps(GetDC(NULL), HORZRES) - Mode->Width) / 2; Top = (GetDeviceCaps(GetDC(NULL), VERTRES) - Mode->Height) / 2; Width = WindowWidth = Mode->Width; Height = WindowHeight = Mode->Height; // Choose the window style according to the Style parameter Win32Style = WS_VISIBLE; if (WindowStyle == NonStyle) { Win32Style |= WS_POPUP; } else { if (WindowStyle & Titlebar) Win32Style |= WS_CAPTION | WS_MINIMIZEBOX; if (WindowStyle & Resize) Win32Style |= WS_THICKFRAME | WS_MAXIMIZEBOX; if (WindowStyle & Close) Win32Style |= WS_SYSMENU; } // In windowed mode, adjust width and height so that window will have the requested client area FullScreen = ((WindowStyle & Fullscreen) != 0); if (!FullScreen) { RECT Rect = {0, 0, Width, Height}; AdjustWindowRect(&Rect, Win32Style, false); Width = Rect.right - Rect.left; Height = Rect.bottom - Rect.top; } // Create the window if (HasUnicodeSupport()) { wchar_t WTitle[256]; int NbChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (LPCSTR)(Title), (int)(strlen(Title)), WTitle, sizeof(WTitle) / sizeof(*WTitle)); WTitle[NbChars] = L'\0'; WindowhWnd = CreateWindowW(WindowClassNameW, WTitle, Win32Style, Left, Top, Width, Height, NULL, NULL, GetModuleHandle(NULL), NULL); } else { WindowhWnd = CreateWindowA(WindowClassNameA, (LPCSTR)(Title), Win32Style, Left, Top, Width, Height, NULL, NULL, GetModuleHandle(NULL), NULL); } // Switch to fullscreen if requested if (FullScreen) SwitchToFullscreen(Mode); // Create the rendering context if (WindowhWnd) CreateContext(Mode, Params); // Get the actual size of the window, which can be smaller even after the call to AdjustWindowRect // This happens when the window is bigger than the desktop GetClientRect(WindowhWnd, &ActualRect); WindowWidth = ActualRect.right - ActualRect.left; WindowHeight = ActualRect.bottom - ActualRect.top; // Set window open state to true WindowIsOpened = true; // Key Repeat is enabled WindowKeyRepeatEnabled = false; // Resize the OpenGL scene OpenGLResizeScene(); return true; }