if (!PnpGetLocalHandles(&BindingHandle, NULL))
return CR_FAILURE;
- bAdmin = IsUserAdmin();
+ bAdmin = pSetupIsUserAdmin();
for (i = 0; i < 30; i++)
{
FIXME("%p %p %lu %lx %p\n",
plcLogConf, dnDevInst, Priority, ulFlags, hMachine);
- if (!IsUserAdmin())
+ if (!pSetupIsUserAdmin())
return CR_ACCESS_DENIED;
if (plcLogConf == NULL)
TRACE("%p %s %lx %p\n", dnDevInst, pszID, ulFlags, hMachine);
- if (CaptureAndConvertAnsiArg(pszID, &pszIDW))
+ if (pSetupCaptureAndConvertAnsiArg(pszID, &pszIDW))
return CR_INVALID_DATA;
ret = CM_Add_ID_ExW(dnDevInst, pszIDW, ulFlags, hMachine);
TRACE("%p %s %lx %p\n", dnDevInst, debugstr_w(pszID), ulFlags, hMachine);
- if (!IsUserAdmin())
+ if (!pSetupIsUserAdmin())
return CR_ACCESS_DENIED;
if (dnDevInst == 0)
if (UNCServerName == NULL || *UNCServerName == 0)
return CM_Connect_MachineW(NULL, phMachine);
- if (CaptureAndConvertAnsiArg(UNCServerName, &pServerNameW))
+ if (pSetupCaptureAndConvertAnsiArg(UNCServerName, &pServerNameW))
return CR_INVALID_DATA;
ret = CM_Connect_MachineW(pServerNameW, phMachine);
TRACE("%p %s %p %lx %p\n",
pdnDevInst, debugstr_a(pDeviceID), dnParent, ulFlags, hMachine);
- if (CaptureAndConvertAnsiArg(pDeviceID, &pDeviceIDW))
+ if (pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDeviceIDW))
return CR_INVALID_DATA;
ret = CM_Create_DevNode_ExW(pdnDevInst, pDeviceIDW, dnParent, ulFlags,
FIXME("%p %s %p %lx %p\n",
pdnDevInst, debugstr_w(pDeviceID), dnParent, ulFlags, hMachine);
- if (!IsUserAdmin())
+ if (!pSetupIsUserAdmin())
return CR_ACCESS_DENIED;
if (pdnDevInst == NULL)
FIXME("%p %lx %p\n", dnDevInst, ulFlags, hMachine);
- if (!IsUserAdmin())
+ if (!pSetupIsUserAdmin())
return CR_ACCESS_DENIED;
if (dnDevInst == 0)
TRACE("%p %lx %p\n", dnDevInst, ulFlags, hMachine);
- if (!IsUserAdmin())
+ if (!pSetupIsUserAdmin())
return CR_ACCESS_DENIED;
if (dnDevInst == 0)
TRACE("%lx %lx %lx\n", lcLogConfToBeFreed, ulFlags, hMachine);
- if (!IsUserAdmin())
+ if (!pSetupIsUserAdmin())
return CR_ACCESS_DENIED;
pLogConfInfo = (PLOG_CONF_INFO)lcLogConfToBeFreed;
}
else
{
- if (CaptureAndConvertAnsiArg(pszFilter, &pszFilterW))
+ if (pSetupCaptureAndConvertAnsiArg(pszFilter, &pszFilterW))
{
ret = CR_INVALID_DEVICE_ID;
goto Done;
}
else
{
- if (CaptureAndConvertAnsiArg(pszFilter, &pszFilterW))
+ if (pSetupCaptureAndConvertAnsiArg(pszFilter, &pszFilterW))
return CR_INVALID_DEVICE_ID;
ret = CM_Get_Device_ID_List_Size_ExW(pulLen,
if (szDevInstName != NULL)
{
- if (CaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
+ if (pSetupCaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
return CR_INVALID_DEVICE_ID;
}
if (pDeviceID != NULL)
{
- if (CaptureAndConvertAnsiArg(pDeviceID, &pDevIdW))
+ if (pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDevIdW))
return CR_INVALID_DEVICE_ID;
}
FIXME("%lx %lx %lx %lx\n",
dnFromDevInst, dnToDevInst, ulFlags, hMachine);
- if (!IsUserAdmin())
+ if (!pSetupIsUserAdmin())
return CR_ACCESS_DENIED;
if (dnFromDevInst == 0 || dnToDevInst == 0)
if (pszClassName != NULL)
{
- if (CaptureAndConvertAnsiArg(pszClassName, &pszClassNameW))
+ if (pSetupCaptureAndConvertAnsiArg(pszClassName, &pszClassNameW))
return CR_INVALID_DATA;
}
TRACE("%lx %lx\n", ulFlags, hMachine);
- if (!IsUserAdmin())
+ if (!pSetupIsUserAdmin())
return CR_ACCESS_DENIED;
if (ulFlags & ~CM_DETECT_BITS)
TRACE("%lu %lu %lx\n", ulHardwareProfile, ulFlags, hMachine);
- if (!IsUserAdmin())
+ if (!pSetupIsUserAdmin())
return CR_ACCESS_DENIED;
if (ulFlags != 0)
if (szDevInstName != NULL)
{
- if (CaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
+ if (pSetupCaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
return CR_INVALID_DEVICE_ID;
}
FIXME("%lx %lx %lx\n", dnDevInst, ulFlags, hMachine);
- if (!IsUserAdmin())
+ if (!pSetupIsUserAdmin())
return CR_ACCESS_DENIED;
if (dnDevInst == 0)
if (MachineName)
{
- MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
+ MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
if (MachineNameW == NULL)
return FALSE;
}
*ScorePlatform = *ScoreMajorVersion = *ScoreMinorVersion = *ScoreProductType = *ScoreSuiteMask = 0;
- Section = DuplicateString(SectionName);
+ Section = pSetupDuplicateString(SectionName);
if (!Section)
{
- TRACE("DuplicateString() failed\n");
+ TRACE("pSetupDuplicateString() failed\n");
goto cleanup;
}
if (MachineName)
{
- MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
+ MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
if (MachineNameW == NULL) return FALSE;
}
return FALSE;
}
- ClassNameW = MultiByteToUnicode(ClassName, CP_ACP);
+ ClassNameW = pSetupMultiByteToUnicode(ClassName, CP_ACP);
if (ClassNameW == NULL)
return FALSE;
if (MachineName)
{
- MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
+ MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
if (MachineNameW == NULL)
{
MyFree(ClassNameW);
BOOL ret;
if (MachineName)
- MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
+ MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
ret = SetupDiClassNameFromGuidExW(ClassGuid, ClassNameW, MAX_CLASS_NAME_LEN,
RequiredSize, MachineNameW, Reserved);
if (ret)
if (MachineName)
{
- MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
+ MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
if (MachineNameW == NULL)
return INVALID_HANDLE_VALUE;
}
}
else
{
- InfSectionNameW = MultiByteToUnicode(InfSectionName, CP_ACP);
+ InfSectionNameW = pSetupMultiByteToUnicode(InfSectionName, CP_ACP);
if (InfSectionNameW == NULL) return INVALID_HANDLE_VALUE;
}
}
if (DeviceName)
{
- DeviceNameW = MultiByteToUnicode(DeviceName, CP_ACP);
+ DeviceNameW = pSetupMultiByteToUnicode(DeviceName, CP_ACP);
if (DeviceNameW == NULL) return FALSE;
}
if (DeviceDescription)
{
- DeviceDescriptionW = MultiByteToUnicode(DeviceDescription, CP_ACP);
+ DeviceDescriptionW = pSetupMultiByteToUnicode(DeviceDescription, CP_ACP);
if (DeviceDescriptionW == NULL)
{
MyFree(DeviceNameW);
if (InfSectionName)
{
- InfSectionNameW = MultiByteToUnicode(InfSectionName, CP_ACP);
+ InfSectionNameW = pSetupMultiByteToUnicode(InfSectionName, CP_ACP);
if (InfSectionNameW == NULL)
goto cleanup;
}
if (MachineName)
{
- MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
+ MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
if (!MachineNameW)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
if (enumstr)
{
- enumstrW = MultiByteToUnicode(enumstr, CP_ACP);
+ enumstrW = pSetupMultiByteToUnicode(enumstr, CP_ACP);
if (!enumstrW)
{
ret = INVALID_HANDLE_VALUE;
}
if (machine)
{
- machineW = MultiByteToUnicode(machine, CP_ACP);
+ machineW = pSetupMultiByteToUnicode(machine, CP_ACP);
if (!machineW)
{
MyFree(enumstrW);
if (ReferenceString)
{
- ReferenceStringW = MultiByteToUnicode(ReferenceString, CP_ACP);
+ ReferenceStringW = pSetupMultiByteToUnicode(ReferenceString, CP_ACP);
if (ReferenceStringW == NULL) return FALSE;
}
SetLastError(ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
- InfSectionNameW = MultiByteToUnicode(InfSectionName, CP_ACP);
+ InfSectionNameW = pSetupMultiByteToUnicode(InfSectionName, CP_ACP);
if (!InfSectionNameW)
return INVALID_HANDLE_VALUE;
}
}
else
{
- InfFileNameW = MultiByteToUnicode(InfFileName, CP_ACP);
+ InfFileNameW = pSetupMultiByteToUnicode(InfFileName, CP_ACP);
if (InfFileNameW == NULL)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
if (MachineName)
{
- MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
+ MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
if (MachineNameW == NULL)
return INVALID_HANDLE_VALUE;
}
TRACE("%p %s %08lx %p\n", DeviceInfoSet, debugstr_a(DevicePath), OpenFlags, DeviceInterfaceData);
- DevicePathW = MultiByteToUnicode(DevicePath, CP_ACP);
+ DevicePathW = pSetupMultiByteToUnicode(DevicePath, CP_ACP);
if (DevicePathW == NULL)
return FALSE;
TRACE("%p %s %p %lx %p\n", DeviceInfoSet, DeviceInstanceId, hwndParent, OpenFlags, DeviceInfoData);
- DeviceInstanceIdW = MultiByteToUnicode(DeviceInstanceId, CP_ACP);
+ DeviceInstanceIdW = pSetupMultiByteToUnicode(DeviceInstanceId, CP_ACP);
if (DeviceInstanceIdW == NULL)
return FALSE;
}
else
{
- FullIconName = DuplicateString(FullFileName);
+ FullIconName = pSetupDuplicateString(FullFileName);
if (!FullIconName)
goto cleanup;
}
if (!DestinationInfFileName && DestinationInfFileNameSize > 0)
SetLastError(ERROR_INVALID_PARAMETER);
- else if (!(SourceInfFileNameW = MultiByteToUnicode(SourceInfFileName, CP_ACP)))
+ else if (!(SourceInfFileNameW = pSetupMultiByteToUnicode(SourceInfFileName, CP_ACP)))
SetLastError(ERROR_INVALID_PARAMETER);
- else if (OEMSourceMediaType != SPOST_NONE && !(OEMSourceMediaLocationW = MultiByteToUnicode(OEMSourceMediaLocation, CP_ACP)))
+ else if (OEMSourceMediaType != SPOST_NONE && !(OEMSourceMediaLocationW = pSetupMultiByteToUnicode(OEMSourceMediaLocation, CP_ACP)))
SetLastError(ERROR_INVALID_PARAMETER);
else
{
Comma++;
/* W->A conversion for function name */
- FunctionNameA = UnicodeToMultiByte(Comma, CP_ACP);
+ FunctionNameA = pSetupUnicodeToMultiByte(Comma, CP_ACP);
if (!FunctionNameA)
{
rc = GetLastError();
/**************************************************************************
- * DuplicateString [SETUPAPI.@]
+ * pSetupDuplicateString [SETUPAPI.@]
*
* Duplicates a unicode string.
*
* NOTES
* Call MyFree() to release the duplicated string.
*/
-LPWSTR WINAPI DuplicateString(LPCWSTR lpSrc)
+LPWSTR WINAPI pSetupDuplicateString(LPCWSTR lpSrc)
{
LPWSTR lpDst;
/**************************************************************************
- * MultiByteToUnicode [SETUPAPI.@]
+ * pSetupMultiByteToUnicode [SETUPAPI.@]
*
* Converts a multi-byte string to a Unicode string.
*
* NOTE
* Use MyFree to release the returned Unicode string.
*/
-LPWSTR WINAPI MultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
+LPWSTR WINAPI pSetupMultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
{
LPWSTR lpUnicodeStr;
int nLength;
/**************************************************************************
- * UnicodeToMultiByte [SETUPAPI.@]
+ * pSetupUnicodeToMultiByte [SETUPAPI.@]
*
* Converts a Unicode string to a multi-byte string.
*
* NOTE
* Use MyFree to release the returned multi-byte string.
*/
-LPSTR WINAPI UnicodeToMultiByte(LPCWSTR lpUnicodeStr, UINT uCodePage)
+LPSTR WINAPI pSetupUnicodeToMultiByte(LPCWSTR lpUnicodeStr, UINT uCodePage)
{
LPSTR lpMultiByteStr;
int nLength;
/**************************************************************************
- * EnablePrivilege [SETUPAPI.@]
+ * pSetupEnablePrivilege [SETUPAPI.@]
*
* Enables or disables one of the current users privileges.
*
* Success: TRUE
* Failure: FALSE
*/
-BOOL WINAPI EnablePrivilege(LPCWSTR lpPrivilegeName, BOOL bEnable)
+BOOL WINAPI pSetupEnablePrivilege(LPCWSTR lpPrivilegeName, BOOL bEnable)
{
TOKEN_PRIVILEGES Privileges;
HANDLE hToken;
if (pDst == NULL)
return ERROR_INVALID_PARAMETER;
- *pDst = DuplicateString(pSrc);
+ *pDst = pSetupDuplicateString(pSrc);
return ERROR_SUCCESS;
}
/**************************************************************************
- * CaptureAndConvertAnsiArg [SETUPAPI.@]
+ * pSetupCaptureAndConvertAnsiArg [SETUPAPI.@]
*
* Captures an ANSI string and converts it to a UNICODE string.
*
* NOTE
* Call MyFree to release the captured UNICODE string.
*/
-DWORD WINAPI CaptureAndConvertAnsiArg(LPCSTR pSrc, LPWSTR *pDst)
+DWORD WINAPI pSetupCaptureAndConvertAnsiArg(LPCSTR pSrc, LPWSTR *pDst)
{
if (pDst == NULL)
return ERROR_INVALID_PARAMETER;
- *pDst = MultiByteToUnicode(pSrc, CP_ACP);
+ *pDst = pSetupMultiByteToUnicode(pSrc, CP_ACP);
return ERROR_SUCCESS;
}
/**************************************************************************
- * OpenAndMapFileForRead [SETUPAPI.@]
+ * pSetupOpenAndMapFileForRead [SETUPAPI.@]
*
* Open and map a file to a buffer.
*
* NOTE
* Call UnmapAndCloseFile to release the file.
*/
-DWORD WINAPI OpenAndMapFileForRead(LPCWSTR lpFileName,
- LPDWORD lpSize,
- LPHANDLE lpFile,
- LPHANDLE lpMapping,
- LPVOID *lpBuffer)
+DWORD WINAPI pSetupOpenAndMapFileForRead(LPCWSTR lpFileName,
+ LPDWORD lpSize,
+ LPHANDLE lpFile,
+ LPHANDLE lpMapping,
+ LPVOID *lpBuffer)
{
DWORD dwError;
/**************************************************************************
- * UnmapAndCloseFile [SETUPAPI.@]
+ * pSetupUnmapAndCloseFile [SETUPAPI.@]
*
* Unmap and close a mapped file.
*
* Success: TRUE
* Failure: FALSE
*/
-BOOL WINAPI UnmapAndCloseFile(HANDLE hFile, HANDLE hMapping, LPVOID lpBuffer)
+BOOL WINAPI pSetupUnmapAndCloseFile(HANDLE hFile, HANDLE hMapping, LPVOID lpBuffer)
{
TRACE("%p %p %p\n",
hFile, hMapping, lpBuffer);
/**************************************************************************
- * MyGetFileTitle [SETUPAPI.@]
+ * pSetupGetFileTitle [SETUPAPI.@]
*
* Returns a pointer to the last part of a fully qualified file name.
*
* Pointer to a files name.
*/
LPWSTR WINAPI
-MyGetFileTitle(LPCWSTR lpFileName)
+pSetupGetFileTitle(LPCWSTR lpFileName)
{
LPWSTR ptr;
LPWSTR ret;
/**************************************************************************
- * ConcatenatePaths [SETUPAPI.@]
+ * pSetupConcatenatePaths [SETUPAPI.@]
*
* Concatenates two paths.
*
* Failure: FALSE
*/
BOOL WINAPI
-ConcatenatePaths(LPWSTR lpPath,
- LPCWSTR lpAppend,
- DWORD dwBufferSize,
- LPDWORD lpRequiredSize)
+pSetupConcatenatePaths(LPWSTR lpPath,
+ LPCWSTR lpAppend,
+ DWORD dwBufferSize,
+ LPDWORD lpRequiredSize)
{
DWORD dwPathSize;
DWORD dwAppendSize;
/**************************************************************************
- * CenterWindowRelativeToParent [SETUPAPI.@]
+ * pSetupCenterWindowRelativeToParent [SETUPAPI.@]
*
* Centers a window relative to its parent.
*
* None
*/
VOID WINAPI
-CenterWindowRelativeToParent(HWND hwnd)
+pSetupCenterWindowRelativeToParent(HWND hwnd)
{
HWND hwndOwner;
POINT ptOrigin;
/**************************************************************************
- * GetVersionInfoFromImage [SETUPAPI.@]
+ * pSetupGetVersionInfoFromImage [SETUPAPI.@]
*
* Retrieves version information for a given file.
*
* Failure: FALSE
*/
BOOL WINAPI
-GetVersionInfoFromImage(LPWSTR lpFileName,
- PULARGE_INTEGER lpFileVersion,
- LPWORD lpVersionVarSize)
+pSetupGetVersionInfoFromImage(LPWSTR lpFileName,
+ PULARGE_INTEGER lpFileVersion,
+ LPWORD lpVersionVarSize)
{
DWORD dwHandle;
DWORD dwSize;
TRACE("%s, %p, %d, %p, %p, %p, %p\n", debugstr_a(source), name, len, required,
source_size, target_size, type);
- if (!source || !(sourceW = MultiByteToUnicode( source, CP_ACP ))) return FALSE;
+ if (!source || !(sourceW = pSetupMultiByteToUnicode( source, CP_ACP ))) return FALSE;
if (name)
{
ret = SetupGetFileCompressionInfoExW( sourceW, nameW, nb_chars, &nb_chars, source_size, target_size, type );
if (ret)
{
- if ((nameA = UnicodeToMultiByte( nameW, CP_ACP )))
+ if ((nameA = pSetupUnicodeToMultiByte( nameW, CP_ACP )))
{
if (name && len >= nb_chars) lstrcpyA( name, nameA );
else
DWORD ret = FALSE;
WCHAR *sourceW = NULL, *targetW = NULL;
- if (source && !(sourceW = MultiByteToUnicode( source, CP_ACP ))) return FALSE;
- if (target && !(targetW = MultiByteToUnicode( target, CP_ACP )))
+ if (source && !(sourceW = pSetupMultiByteToUnicode( source, CP_ACP ))) return FALSE;
+ if (target && !(targetW = pSetupMultiByteToUnicode( target, CP_ACP )))
{
MyFree( sourceW );
return ERROR_NOT_ENOUGH_MEMORY;
*/
BOOL
WINAPI
-IsUserAdmin(VOID)
+pSetupIsUserAdmin(VOID)
{
SID_IDENTIFIER_AUTHORITY Authority = {SECURITY_NT_AUTHORITY};
BOOL bResult = FALSE;
if (Flags & SPFILELOG_SYSTEMLOG)
{
- if (!IsUserAdmin() && !(Flags & SPFILELOG_QUERYONLY))
+ if (!pSetupIsUserAdmin() && !(Flags & SPFILELOG_QUERYONLY))
{
/* insufficient privileges */
SetLastError(ERROR_ACCESS_DENIED);
if (DirectoryPath != NULL)
{
- DirectoryPathW = MultiByteToUnicode(DirectoryPath, CP_ACP);
+ DirectoryPathW = pSetupMultiByteToUnicode(DirectoryPath, CP_ACP);
if (DirectoryPathW == NULL) goto Cleanup;
}
if (InfName != NULL)
{
- InfNameW = MultiByteToUnicode(InfName, CP_ACP);
+ InfNameW = pSetupMultiByteToUnicode(InfName, CP_ACP);
if (InfNameW == NULL) goto Cleanup;
}
@ stdcall InstallHinfSection(long long str long) InstallHinfSectionA
@ stdcall InstallHinfSectionA(long long str long)
@ stdcall InstallHinfSectionW(long long wstr long)
-@ stdcall IsUserAdmin()
+@ stdcall IsUserAdmin() pSetupIsUserAdmin
@ stdcall MyFree(ptr)
@ stdcall MyMalloc(long)
@ stdcall MyRealloc(ptr long)
@ stdcall SetupUninstallOEMInfW(wstr long ptr)
@ stub SetupVerifyInfFileA
@ stub SetupVerifyInfFileW
-@ stdcall UnicodeToMultiByte(wstr long)
+@ stdcall UnicodeToMultiByte(wstr long) pSetupUnicodeToMultiByte
@ stub VerifyCatalogFile
@ stub pSetupAccessRunOnceNodeList
@ stub pSetupAcquireSCMLock
@ stub pSetupAddMiniIconToList
@ stub pSetupAddTagToGroupOrderListEntry
@ stub pSetupAppendStringToMultiSz
-@ stdcall pSetupCaptureAndConvertAnsiArg(str ptr) CaptureAndConvertAnsiArg
-@ stdcall pSetupCenterWindowRelativeToParent(long) CenterWindowRelativeToParent
-@ stdcall pSetupConcatenatePaths(wstr wstr long ptr) ConcatenatePaths
+@ stdcall pSetupCaptureAndConvertAnsiArg(str ptr)
+@ stdcall pSetupCenterWindowRelativeToParent(long)
+@ stdcall pSetupConcatenatePaths(wstr wstr long ptr)
@ stub pSetupDestroyRunOnceNodeList
@ stub pSetupDiGetDeviceInfoContext
@ stub pSetupDiSetDeviceInfoContext
@ stub pSetupDoesUserHavePrivilege
-@ stdcall pSetupDuplicateString(wstr) DuplicateString
-@ stdcall pSetupEnablePrivilege(wstr long) EnablePrivilege
+@ stdcall pSetupDuplicateString(wstr)
+@ stdcall pSetupEnablePrivilege(wstr long)
@ stub pSetupFree
@ stub pSetupFreeStringArray
@ stub pSetupGetCurrentDriverSigningPolicy
@ stdcall pSetupGetField(ptr long)
-@ stdcall pSetupGetFileTitle(wstr) MyGetFileTitle
+@ stdcall pSetupGetFileTitle(wstr)
@ stdcall pSetupGetGlobalFlags()
@ stub pSetupGetInfSections
@ stdcall pSetupGetQueueFlags(ptr)
@ stub pSetupGetRealSystemTime
-@ stdcall pSetupGetVersionInfoFromImage(wstr ptr ptr) GetVersionInfoFromImage
+@ stdcall pSetupGetVersionInfoFromImage(wstr ptr ptr)
@ stdcall pSetupGuidFromString(wstr ptr)
@ stub pSetupHandleFailedVerification
@ stub pSetupInfCacheBuild
@ stub pSetupInstallStopEx
@ stdcall pSetupIsGuidNull(ptr)
@ stub pSetupIsLocalSystem
-@ stdcall pSetupIsUserAdmin() IsUserAdmin
+@ stdcall pSetupIsUserAdmin()
@ stub pSetupMakeSurePathExists
@ stub pSetupMalloc
@ stub pSetupModifyGlobalFlags
-@ stdcall pSetupMultiByteToUnicode(str long) MultiByteToUnicode
-@ stdcall pSetupOpenAndMapFileForRead(wstr ptr ptr ptr ptr) OpenAndMapFileForRead
+@ stdcall pSetupMultiByteToUnicode(str long)
+@ stdcall pSetupOpenAndMapFileForRead(wstr ptr ptr ptr ptr)
@ stub pSetupOutOfMemory
@ stub pSetupQueryMultiSzValueToArray
@ stub pSetupRealloc
-@ stdcall pSetupRegistryDelnode(long long) RegistryDelnode
+@ stdcall pSetupRegistryDelnode(long long)
@ stub pSetupRetrieveServiceConfig
@ stub pSetupSetArrayToMultiSzValue
@ stdcall pSetupSetGlobalFlags(long)
@ stdcall pSetupStringTableSetExtraData(ptr long ptr long)
@ stdcall pSetupStringTableStringFromId(ptr long)
@ stdcall pSetupStringTableStringFromIdEx(ptr long ptr ptr)
-@ stdcall pSetupUnicodeToMultiByte(wstr long) UnicodeToMultiByte
-@ stdcall pSetupUnmapAndCloseFile(long long ptr) UnmapAndCloseFile
+@ stdcall pSetupUnicodeToMultiByte(wstr long)
+@ stdcall pSetupUnmapAndCloseFile(long long ptr)
@ stub pSetupVerifyCatalogFile
@ stub pSetupVerifyFile
@ stub pSetupVerifyQueuedCatalogs
}
/***********************************************************************
- * RegistryDelnode(SETUPAPI.@)
+ * pSetupRegistryDelnode(SETUPAPI.@)
*/
-BOOL WINAPI RegistryDelnode(DWORD x, DWORD y)
+BOOL WINAPI pSetupRegistryDelnode(DWORD x, DWORD y)
{
FIXME("%08x %08x: stub\n", x, y);
return FALSE;
WINSETUPAPI LONG WINAPI AddTagToGroupOrderList(PCWSTR, DWORD, DWORD);
WINSETUPAPI VOID WINAPI AssertFail(LPSTR, UINT, LPSTR);
-WINSETUPAPI DWORD WINAPI CaptureAndConvertAnsiArg(PCSTR, PWSTR*);
WINSETUPAPI DWORD WINAPI CaptureStringArg(PCWSTR, PWSTR*);
-WINSETUPAPI VOID WINAPI CenterWindowRelativeToParent(HWND);
-WINSETUPAPI BOOL WINAPI ConcatenatePaths(LPWSTR, LPCWSTR, DWORD, LPDWORD);
WINSETUPAPI BOOL WINAPI DelayedMove(PCWSTR, PCWSTR);
WINSETUPAPI BOOL WINAPI DoesUserHavePrivilege(PCWSTR);
-WINSETUPAPI PWSTR WINAPI DuplicateString(PCWSTR);
-WINSETUPAPI BOOL WINAPI EnablePrivilege(PCWSTR, BOOL);
WINSETUPAPI BOOL WINAPI FileExists(PCWSTR, PWIN32_FIND_DATAW);
WINSETUPAPI DWORD WINAPI GetSetFileTimestamp(PCWSTR, PFILETIME, PFILETIME, PFILETIME, BOOLEAN);
-WINSETUPAPI BOOL WINAPI GetVersionInfoFromImage(LPWSTR, PULARGE_INTEGER, LPWORD);
WINSETUPAPI BOOL WINAPI IsUserAdmin(VOID);
-WINSETUPAPI PWSTR WINAPI MultiByteToUnicode(PCSTR, UINT);
WINSETUPAPI VOID WINAPI MyFree(PVOID);
-WINSETUPAPI PWSTR WINAPI MyGetFileTitle(PCWSTR);
WINSETUPAPI PVOID WINAPI MyMalloc(DWORD);
WINSETUPAPI PVOID WINAPI MyRealloc(PVOID, DWORD);
-WINSETUPAPI DWORD WINAPI OpenAndMapForRead(PCWSTR, PDWORD, PHANDLE, PHANDLE, PVOID*);
WINSETUPAPI LONG WINAPI QueryRegistryValue(HKEY, PCWSTR, PBYTE*, PDWORD, PDWORD);
WINSETUPAPI DWORD WINAPI RetreiveFileSecurity(PCWSTR, PSECURITY_DESCRIPTOR*);
WINSETUPAPI DWORD WINAPI StampFileSecurity(PCWSTR, PSECURITY_DESCRIPTOR);
+
+WINSETUPAPI DWORD WINAPI pSetupCaptureAndConvertAnsiArg(PCSTR, PWSTR*);
+WINSETUPAPI VOID WINAPI pSetupCenterWindowRelativeToParent(HWND);
+WINSETUPAPI BOOL WINAPI pSetupConcatenatePaths(LPWSTR, LPCWSTR, DWORD, LPDWORD);
+WINSETUPAPI PWSTR WINAPI pSetupDuplicateString(PCWSTR);
+WINSETUPAPI BOOL WINAPI pSetupEnablePrivilege(PCWSTR, BOOL);
+WINSETUPAPI PWSTR WINAPI pSetupGetFileTitle(PCWSTR);
+WINSETUPAPI BOOL WINAPI pSetupGetVersionInfoFromImage(LPWSTR, PULARGE_INTEGER, LPWORD);
+WINSETUPAPI BOOL WINAPI pSetupIsUserAdmin(VOID);
+WINSETUPAPI PWSTR WINAPI pSetupMultiByteToUnicode(PCSTR, UINT);
+WINSETUPAPI DWORD WINAPI pSetupOpenAndMapForRead(PCWSTR, PDWORD, PHANDLE, PHANDLE, PVOID*);
+
+
+
WINSETUPAPI DWORD WINAPI pSetupStringTableAddString(HSTRING_TABLE, LPWSTR, DWORD);
WINSETUPAPI DWORD WINAPI pSetupStringTableAddStringEx(HSTRING_TABLE, LPWSTR, DWORD, LPVOID, DWORD);
WINSETUPAPI VOID WINAPI pSetupStringTableDestroy(HSTRING_TABLE);
WINSETUPAPI LPWSTR WINAPI pSetupStringTableStringFromId(HSTRING_TABLE, DWORD);
WINSETUPAPI BOOL WINAPI pSetupStringTableStringFromIdEx(HSTRING_TABLE, DWORD, LPWSTR, LPDWORD);
+WINSETUPAPI PSTR WINAPI pSetupUnicodeToMultiByte(PCWSTR lpUnicodeStr, UINT uCodePage);
+WINSETUPAPI BOOL WINAPI pSetupUnmapAndCloseFile(HANDLE, HANDLE, PVOID);
+
+
WINSETUPAPI DWORD WINAPI TakeOwnershipOfFile(PCWSTR);
WINSETUPAPI PSTR WINAPI UnicodeToMultiByte(PCWSTR lpUnicodeStr, UINT uCodePage);
-WINSETUPAPI BOOL WINAPI UnmapAndCloseFile(HANDLE, HANDLE, PVOID);
/* for backward compatability */