/* * Copyright (C) 2002 Andreas Mohr * Copyright (C) 2002 Shachar Shemesh * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* Based on the Wine "bootup" handler application * * This app handles the various "hooks" windows allows for applications to perform * as part of the bootstrap process. Theses are roughly devided into three types. * Knowledge base articles that explain this are 137367, 179365, 232487 and 232509. * Also, 119941 has some info on grpconv.exe * The operations performed are (by order of execution): * * Preboot (prior to fully loading the Windows kernel): * - wininit.exe (rename operations left in wininit.ini - Win 9x only) * - PendingRenameOperations (rename operations left in the registry - Win NT+ only) * * Startup (before the user logs in) * - Services (NT, ?semi-synchronous?, not implemented yet) * - HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServicesOnce (9x, asynch) * - HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServices (9x, asynch) * * After log in * - HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunOnce (all, synch) * - HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run (all, asynch) * - HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run (all, asynch) * - Startup folders (all, ?asynch?, no imp) * - HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce (all, asynch) * * Somewhere in there is processing the RunOnceEx entries (also no imp) * * Bugs: * - If a pending rename registry does not start with \??\ the entry is * processed anyways. I'm not sure that is the Windows behaviour. * - Need to check what is the windows behaviour when trying to delete files * and directories that are read-only * - In the pending rename registry processing - there are no traces of the files * processed (requires translations from Unicode to Ansi). */ #include #include #include /** * Performs the rename operations dictated in %SystemRoot%\Wininit.ini. * Returns FALSE if there was an error, or otherwise if all is ok. */ static BOOL wininit() { return TRUE; } static BOOL pendingRename() { static const WCHAR ValueName[] = {'P','e','n','d','i','n','g', 'F','i','l','e','R','e','n','a','m','e', 'O','p','e','r','a','t','i','o','n','s',0}; static const WCHAR SessionW[] = { 'S','y','s','t','e','m','\\', 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\', 'C','o','n','t','r','o','l','\\', 'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r',0}; WCHAR *buffer=NULL; const WCHAR *src=NULL, *dst=NULL; DWORD dataLength=0; HKEY hSession=NULL; DWORD res; printf("Entered\n"); if ((res=RegOpenKeyExW(HKEY_LOCAL_MACHINE, SessionW, 0, KEY_ALL_ACCESS, &hSession)) !=ERROR_SUCCESS) { if (res==ERROR_FILE_NOT_FOUND) { printf("The key was not found - skipping\n"); res=TRUE; } else { printf("Couldn't open key, error %ld\n", res); res=FALSE; } goto end; } res=RegQueryValueExW(hSession, ValueName, NULL, NULL /* The value type does not really interest us, as it is not truely a REG_MULTI_SZ anyways */, NULL, &dataLength); if (res==ERROR_FILE_NOT_FOUND) { /* No value - nothing to do. Great! */ printf("Value not present - nothing to rename\n"); res=TRUE; goto end; } if (res!=ERROR_SUCCESS) { printf("Couldn't query value's length (%ld)\n", res); res=FALSE; goto end; } buffer=malloc(dataLength); if (buffer==NULL) { printf("Couldn't allocate %lu bytes for the value\n", dataLength); res=FALSE; goto end; } res=RegQueryValueExW(hSession, ValueName, NULL, NULL, (LPBYTE)buffer, &dataLength); if (res!=ERROR_SUCCESS) { printf("Couldn't query value after successfully querying before (%lu),\n" "please report to wine-devel@winehq.org\n", res); res=FALSE; goto end; } /* Make sure that the data is long enough and ends with two NULLs. This * simplifies the code later on. */ if (dataLength<2*sizeof(buffer[0]) || buffer[dataLength/sizeof(buffer[0])-1]!='\0' || buffer[dataLength/sizeof(buffer[0])-2]!='\0') { printf("Improper value format - doesn't end with NULL\n"); res=FALSE; goto end; } for(src=buffer; (src-buffer)*sizeof(src[0])0) { DWORD nValLength=nMaxValue, nDataLength=nMaxCmdLine; DWORD type; --i; if ((res=RegEnumValueW(hkRun, i, szValue, &nValLength, 0, &type, (LPBYTE)szCmdLine, &nDataLength))!=ERROR_SUCCESS) { printf("Couldn't read in value %ld - %ld\n", i, res); continue; } if (bDelete && (res=RegDeleteValueW(hkRun, szValue))!=ERROR_SUCCESS) { printf("Couldn't delete value - %ld, %ld. Running command anyways.\n", i, res); } if (type!=REG_SZ) { printf("Incorrect type of value #%ld (%ld)\n", i, type); continue; } if ((res=runCmd(szCmdLine, NULL, bSynchronous, FALSE))==INVALID_RUNCMD_RETURN) { printf("Error running cmd #%ld (%ld)\n", i, GetLastError()); } printf("Done processing cmd #%ld\n", i); } free(szValue); free(szCmdLine); res=ERROR_SUCCESS; end: if (hkRun!=NULL) RegCloseKey(hkRun); if (hkWin!=NULL) RegCloseKey(hkWin); printf("done\n"); return res==ERROR_SUCCESS?TRUE:FALSE; } /// structure holding startup flags struct op_mask { BOOL w9xonly; /* Perform only operations done on Windows 9x */ BOOL ntonly; /* Perform only operations done on Windows NT */ BOOL startup; /* Perform the operations that are performed every boot */ BOOL preboot; /* Perform file renames typically done before the system starts */ BOOL prelogin; /* Perform the operations typically done before the user logs in */ BOOL postlogin; /* Operations done after login */ }; static const struct op_mask SESSION_START = {FALSE, FALSE, TRUE, TRUE, TRUE, TRUE}, SETUP = {FALSE, FALSE, FALSE, TRUE, TRUE, TRUE}; #define DEFAULT SESSION_START int startup(int argc, const char *argv[]) { struct op_mask ops; /* Which of the ops do we want to perform? */ /* First, set the current directory to SystemRoot */ TCHAR gen_path[MAX_PATH]; DWORD res; res = GetWindowsDirectory(gen_path, sizeof(gen_path)); if (res==0) { printf("Couldn't get the windows directory - error %ld\n", GetLastError()); return 100; } if (res>=sizeof(gen_path)) { printf("Windows path too long (%ld)\n", res); return 100; } if (!SetCurrentDirectory(gen_path)) { wprintf(L"Cannot set the dir to %s (%ld)\n", gen_path, GetLastError()); return 100; } if (argc>1) { switch(argv[1][0]) { case 'r': /* Restart */ ops=SETUP; break; case 's': /* Full start */ ops=SESSION_START; break; default: ops=DEFAULT; break; } } else ops=DEFAULT; /* Perform the ops by order, stopping if one fails, skipping if necessary */ /* Shachar: Sorry for the perl syntax */ res=(ops.ntonly || !ops.preboot || wininit()) && (ops.w9xonly || !ops.preboot || pendingRename()) && (ops.ntonly || !ops.prelogin || ProcessRunKeys(HKEY_LOCAL_MACHINE, runkeys_names[RUNKEY_RUNSERVICESONCE], TRUE, FALSE)) && (ops.ntonly || !ops.prelogin || !ops.startup || ProcessRunKeys(HKEY_LOCAL_MACHINE, runkeys_names[RUNKEY_RUNSERVICES], FALSE, FALSE)) && (!ops.postlogin || ProcessRunKeys(HKEY_LOCAL_MACHINE, runkeys_names[RUNKEY_RUNONCE], TRUE, TRUE)) && (!ops.postlogin || !ops.startup || ProcessRunKeys(HKEY_LOCAL_MACHINE, runkeys_names[RUNKEY_RUN], FALSE, FALSE)) && (!ops.postlogin || !ops.startup || ProcessRunKeys(HKEY_CURRENT_USER, runkeys_names[RUNKEY_RUN], FALSE, FALSE)); printf("Operation done\n"); return res?0:101; }