scm.c

winNT技术操作系统,国外开放的原代码和LIUX一样

    DPRINT("QueryServiceLockStatusA() called\n");

    HandleBind();

    /* Call to services.exe using RPC */
    dwError = ScmrQueryServiceLockStatusA(BindingHandle,
                                          (unsigned int)hSCManager,
                                          (unsigned char *)lpLockStatus,
                                          cbBufSize,
                                          pcbBytesNeeded);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("ScmrQueryServiceLockStatusA() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }

    if (lpLockStatus->lpLockOwner != NULL)
    {
        lpLockStatus->lpLockOwner =
            (LPSTR)((UINT_PTR)lpLockStatus + (UINT_PTR)lpLockStatus->lpLockOwner);
    }

    DPRINT("QueryServiceLockStatusA() done\n");

    return TRUE;
}


/**********************************************************************
 *  QueryServiceLockStatusW
 *
 * @implemented
 */
BOOL STDCALL
QueryServiceLockStatusW(SC_HANDLE hSCManager,
                        LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus,
                        DWORD cbBufSize,
                        LPDWORD pcbBytesNeeded)
{
    DWORD dwError;

    DPRINT("QueryServiceLockStatusW() called\n");

    HandleBind();

    /* Call to services.exe using RPC */
    dwError = ScmrQueryServiceLockStatusW(BindingHandle,
                                          (unsigned int)hSCManager,
                                          (unsigned char *)lpLockStatus,
                                          cbBufSize,
                                          pcbBytesNeeded);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("ScmrQueryServiceLockStatusW() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }

    if (lpLockStatus->lpLockOwner != NULL)
    {
        lpLockStatus->lpLockOwner =
            (LPWSTR)((UINT_PTR)lpLockStatus + (UINT_PTR)lpLockStatus->lpLockOwner);
    }

    DPRINT("QueryServiceLockStatusW() done\n");

    return TRUE;
}


/**********************************************************************
 *  QueryServiceObjectSecurity
 *
 * @implemented
 */
BOOL STDCALL
QueryServiceObjectSecurity(SC_HANDLE hService,
                           SECURITY_INFORMATION dwSecurityInformation,
                           PSECURITY_DESCRIPTOR lpSecurityDescriptor,
                           DWORD cbBufSize,
                           LPDWORD pcbBytesNeeded)
{
    DWORD dwError;

    DPRINT("QueryServiceObjectSecurity(%p, %lu, %p)\n",
           hService, dwSecurityInformation, lpSecurityDescriptor);

    HandleBind();

    /* Call to services.exe using RPC */
    dwError = ScmrQueryServiceObjectSecurity(BindingHandle,
                                             (unsigned int)hService,
                                             dwSecurityInformation,
                                             (unsigned char *)lpSecurityDescriptor,
                                             cbBufSize,
                                             pcbBytesNeeded);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT1("QueryServiceObjectSecurity() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }

    return TRUE;
}


/**********************************************************************
 *  QueryServiceStatus
 *
 * @implemented
 */
BOOL STDCALL
QueryServiceStatus(SC_HANDLE hService,
                   LPSERVICE_STATUS lpServiceStatus)
{
    DWORD dwError;

    DPRINT("QueryServiceStatus(%p, %p)\n",
           hService, lpServiceStatus);

    HandleBind();

    /* Call to services.exe using RPC */
    dwError = ScmrQueryServiceStatus(BindingHandle,
                                     (unsigned int)hService,
                                     lpServiceStatus);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT1("ScmrQueryServiceStatus() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }

    return TRUE;
}


/**********************************************************************
 *  QueryServiceStatusEx
 *
 * @implemented
 */
BOOL STDCALL
QueryServiceStatusEx(SC_HANDLE hService,
                     SC_STATUS_TYPE InfoLevel,
                     LPBYTE lpBuffer,
                     DWORD cbBufSize,
                     LPDWORD pcbBytesNeeded)
{
    DWORD dwError;

    DPRINT("QueryServiceStatusEx() called\n");

    HandleBind();

    /* Call to services.exe using RPC */
    dwError = ScmrQueryServiceStatusEx(BindingHandle,
                                       (unsigned int)hService,
                                       InfoLevel,
                                       lpBuffer,
                                       cbBufSize,
                                       pcbBytesNeeded);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("ScmrQueryServiceStatusEx() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }

    return TRUE;
}


/**********************************************************************
 *  SetServiceObjectSecurity
 *
 * @implemented
 */
BOOL STDCALL
SetServiceObjectSecurity(SC_HANDLE hService,
                         SECURITY_INFORMATION dwSecurityInformation,
                         PSECURITY_DESCRIPTOR lpSecurityDescriptor)
{
    PSECURITY_DESCRIPTOR SelfRelativeSD = NULL;
    ULONG Length;
    NTSTATUS Status;
    DWORD dwError;

    Length = 0;
    Status = RtlMakeSelfRelativeSD(lpSecurityDescriptor,
                                   SelfRelativeSD,
                                   &Length);
    if (Status != STATUS_BUFFER_TOO_SMALL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    SelfRelativeSD = HeapAlloc(GetProcessHeap(), 0, Length);
    if (SelfRelativeSD == NULL)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    Status = RtlMakeSelfRelativeSD(lpSecurityDescriptor,
                                   SelfRelativeSD,
                                   &Length);
    if (!NT_SUCCESS(Status))
    {
        HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
        SetLastError(RtlNtStatusToDosError(Status));
        return FALSE;
    }

    HandleBind();

    /* Call to services.exe using RPC */
    dwError = ScmrSetServiceObjectSecurity(BindingHandle,
                                           (unsigned int)hService,
                                           dwSecurityInformation,
                                           (unsigned char *)SelfRelativeSD,
                                           Length);

    HeapFree(GetProcessHeap(), 0, SelfRelativeSD);

    if (dwError != ERROR_SUCCESS)
    {
        DPRINT1("ScmrServiceObjectSecurity() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }

    return TRUE;
}


/**********************************************************************
 *  StartServiceA
 *
 * @implemented
 */
BOOL STDCALL
StartServiceA(SC_HANDLE hService,
              DWORD dwNumServiceArgs,
              LPCSTR *lpServiceArgVectors)
{
    LPSTR lpBuffer;
    LPSTR lpStr;
    DWORD dwError;
    DWORD dwBufSize;
    DWORD i;

    dwBufSize = 0;
    for (i = 0; i < dwNumServiceArgs; i++)
    {
        dwBufSize += (strlen(lpServiceArgVectors[i]) + 1);
    }
    dwBufSize++;
    DPRINT1("dwBufSize: %lu\n", dwBufSize);

    lpBuffer = HeapAlloc(GetProcessHeap(), 0, dwBufSize);
    if (lpBuffer == NULL)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    lpStr = lpBuffer;
    for (i = 0; i < dwNumServiceArgs; i++)
    {
        strcpy(lpStr, lpServiceArgVectors[i]);
        lpStr += (strlen(lpServiceArgVectors[i]) + 1);
    }
    *lpStr = 0;

    dwError = ScmrStartServiceA(BindingHandle,
                                (unsigned int)hService,
                                dwNumServiceArgs,
                                (unsigned char *)lpBuffer,
                                dwBufSize);

    HeapFree(GetProcessHeap(), 0, lpBuffer);

    if (dwError != ERROR_SUCCESS)
    {
        DPRINT1("ScmrStartServiceA() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }

    return TRUE;
}


/**********************************************************************
 *  StartServiceW
 *
 * @implemented
 */
BOOL STDCALL
StartServiceW(SC_HANDLE hService,
              DWORD dwNumServiceArgs,
              LPCWSTR *lpServiceArgVectors)
{
    LPWSTR lpBuffer;
    LPWSTR lpStr;
    DWORD dwError;
    DWORD dwBufSize;
    DWORD i;

    dwBufSize = 0;
    for (i = 0; i < dwNumServiceArgs; i++)
    {
        dwBufSize += ((wcslen(lpServiceArgVectors[i]) + 1) * sizeof(WCHAR));
    }
    dwBufSize += sizeof(WCHAR);
    DPRINT("dwBufSize: %lu\n", dwBufSize);

    lpBuffer = HeapAlloc(GetProcessHeap(), 0, dwBufSize);
    if (lpBuffer == NULL)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    lpStr = lpBuffer;
    for (i = 0; i < dwNumServiceArgs; i++)
    {
        wcscpy(lpStr, lpServiceArgVectors[i]);
        lpStr += (wcslen(lpServiceArgVectors[i]) + 1);
    }
    *lpStr = 0;

    dwError = ScmrStartServiceW(BindingHandle,
                                (unsigned int)hService,
                                dwNumServiceArgs,
                                (unsigned char *)lpBuffer,
                                dwBufSize);

    HeapFree(GetProcessHeap(), 0, lpBuffer);

    if (dwError != ERROR_SUCCESS)
    {
        DPRINT1("ScmrStartServiceW() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }

    return TRUE;
}


/**********************************************************************
 *  UnlockServiceDatabase
 *
 * @implemented
 */
BOOL STDCALL
UnlockServiceDatabase(SC_LOCK ScLock)
{
    DWORD dwError;

    DPRINT("UnlockServiceDatabase(%x)\n", ScLock);

    HandleBind();

    /* Call to services.exe using RPC */
    dwError = ScmrUnlockServiceDatabase(BindingHandle,
                                        (unsigned int)ScLock);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT1("ScmrUnlockServiceDatabase() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }

    return TRUE;
}


/**********************************************************************
 *  NotifyBootConfigStatus
 *
 * @implemented
 */
BOOL STDCALL
NotifyBootConfigStatus(BOOL BootAcceptable)
{
    DWORD dwError;

    DPRINT1("NotifyBootConfigStatus()\n");

    HandleBind();

    /* Call to services.exe using RPC */
    dwError = ScmrNotifyBootConfigStatus(BindingHandle,
                                         BootAcceptable);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT1("NotifyBootConfigStatus() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }

    return TRUE;
}


void __RPC_FAR * __RPC_USER midl_user_allocate(size_t len)
{
    return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
}


void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
{
    HeapFree(GetProcessHeap(), 0, ptr);
}

/* EOF */