xcv.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Local Port Monitor
 * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
 * PURPOSE:     Implementation of Xcv* and support functions
 * COPYRIGHT:   Copyright 2015 Colin Finck (colin@reactos.org)
 */
 
#include "precomp.h"
 
static DWORD
_HandleAddPort(PLOCALMON_XCV pXcv, PBYTE pInputData, PDWORD pcbOutputNeeded)
{
    DWORD res, cbPortName;
    HKEY hroot;
    HKEY hToken = NULL;
    PLOCALMON_PORT pPort;
    PLOCALMON_HANDLE pLocalmon = pXcv->pLocalmon;
    PWSTR PortName = (PWSTR)pInputData;
 
    FIXME("LcmXcvAddPort : %s\n", debugstr_w( (LPWSTR) PortName ) );
 
    if (!pLocalmon )
    {
        res = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    // This action can only happen at SERVER_ACCESS_ADMINISTER access level.
    if (!(pXcv->GrantedAccess & SERVER_ACCESS_ADMINISTER))
    {
        res = ERROR_ACCESS_DENIED;
        goto Cleanup;
    }
 
    // Switch to the SYSTEM context for modifying the registry.
    hToken = RevertToPrinterSelf();
    if (!hToken)
    {
        res = GetLastError();
        ERR("RevertToPrinterSelf failed with error %lu!\n", res);
        goto Cleanup;
    }
 
    res = RegOpenKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Ports", &hroot);
    if (res == ERROR_SUCCESS)
    {
        if ( DoesPortExist( PortName ) )
        {
            RegCloseKey(hroot);
            FIXME("=> %u\n", ERROR_ALREADY_EXISTS);
            res = ERROR_ALREADY_EXISTS;
            goto Cleanup;
        }
 
        cbPortName = (wcslen( PortName ) + 1) * sizeof(WCHAR);
 
        // Create a new LOCALMON_PORT structure for it.
        pPort = DllAllocSplMem(sizeof(LOCALMON_PORT) + cbPortName);
        if (!pPort)
        {
            res = ERROR_NOT_ENOUGH_MEMORY;
            RegCloseKey( hroot );
            goto Cleanup;
        }
        memset( pPort, 0, sizeof(LOCALMON_PORT) + cbPortName );
 
        pPort->hFile = INVALID_HANDLE_VALUE;
        pPort->pLocalmon = pLocalmon;
        pPort->pwszPortName = wcscpy( (PWSTR)(pPort+1), PortName );
 
        // Insert it into the Registry list.
        InsertTailList(&pLocalmon->RegistryPorts, &pPort->Entry);
 
        res = RegSetValueExW(hroot, PortName, 0, REG_SZ, (const BYTE *) L"", sizeof(L""));
        RegCloseKey(hroot);
    }
 
    FIXME("=> %u\n", res);
 
Cleanup:
    if (hToken) ImpersonatePrinterClient(hToken);
    SetLastError(res);
    return res;
}
 
static DWORD
_HandleConfigureLPTPortCommandOK(PLOCALMON_XCV pXcv, PBYTE pInputData, PDWORD pcbOutputNeeded)
{
    DWORD cbBuffer;
    DWORD dwErrorCode;
    HKEY hKey = NULL;
    HKEY hToken = NULL;
 
    // Sanity checks
    if (!pXcv || !pInputData || !pcbOutputNeeded)
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    *pcbOutputNeeded = 0;
 
    // This action can only happen at SERVER_ACCESS_ADMINISTER access level.
    if (!(pXcv->GrantedAccess & SERVER_ACCESS_ADMINISTER))
    {
        dwErrorCode = ERROR_ACCESS_DENIED;
        goto Cleanup;
    }
 
    // Switch to the SYSTEM context for modifying the registry.
    hToken = RevertToPrinterSelf();
    if (!hToken)
    {
        dwErrorCode = GetLastError();
        ERR("RevertToPrinterSelf failed with error %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // Open the key where our value is stored.
    dwErrorCode = (DWORD)RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Windows", 0, KEY_SET_VALUE, &hKey);
    if (dwErrorCode != ERROR_SUCCESS)
    {
        ERR("RegOpenKeyExW failed with status %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // We don't use cbInputData here, because the buffer pInputData could be bigger than the data it contains.
    cbBuffer = (wcslen((PWSTR)pInputData) + 1) * sizeof(WCHAR);
 
    // Write the value to the registry.
    dwErrorCode = (DWORD)RegSetValueExW(hKey, L"TransmissionRetryTimeout", 0, REG_SZ, pInputData, cbBuffer);
    if (dwErrorCode != ERROR_SUCCESS)
    {
        ERR("RegSetValueExW failed with status %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
Cleanup:
    if (hKey)
        RegCloseKey(hKey);
 
    if (hToken)
        ImpersonatePrinterClient(hToken);
 
    return dwErrorCode;
}
 
static DWORD
_HandleDeletePort(PLOCALMON_XCV pXcv, PBYTE pInputData, PDWORD pcbOutputNeeded)
{
    DWORD res;
    HKEY hroot;
    HKEY hToken = NULL;
    PLOCALMON_HANDLE pLocalmon = pXcv->pLocalmon;
    PLOCALMON_PORT pPort = NULL;
    PLIST_ENTRY pEntry;
    PWSTR pPortName = (PWSTR)pInputData;
 
    FIXME("LcmXcvDeletePort : %s\n", debugstr_w( pPortName ) );
 
    if (!pLocalmon )
    {
        res = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    // This action can only happen at SERVER_ACCESS_ADMINISTER access level.
    if (!(pXcv->GrantedAccess & SERVER_ACCESS_ADMINISTER))
    {
        res = ERROR_ACCESS_DENIED;
        goto Cleanup;
    }
 
    // Switch to the SYSTEM context for modifying the registry.
    hToken = RevertToPrinterSelf();
    if (!hToken)
    {
        res = GetLastError();
        ERR("RevertToPrinterSelf failed with error %lu!\n", res);
        goto Cleanup;
    }
 
    res = RegOpenKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Ports", &hroot);
    if ( res == ERROR_SUCCESS )
    {
        res = RegDeleteValueW(hroot, pPortName );
 
        RegCloseKey(hroot);
 
        if ( res == ERROR_SUCCESS )
        {
            EnterCriticalSection(&pLocalmon->Section);
 
            if (!IsListEmpty(&pLocalmon->RegistryPorts) )
            {
                for (pEntry = pLocalmon->RegistryPorts.Flink; pEntry != &pLocalmon->RegistryPorts; pEntry = pEntry->Flink)
                {
                    pPort = CONTAINING_RECORD(pEntry, LOCALMON_PORT, Entry);
 
                    if (wcscmp(pPort->pwszPortName, pPortName) == 0)
                        break;
                }
            }
 
            LeaveCriticalSection(&pLocalmon->Section);
 
            if ( pPort )
            {
                FIXME("LcmXcvDeletePort removed Port Entry\n");
                EnterCriticalSection(&pPort->pLocalmon->Section);
                RemoveEntryList(&pPort->Entry);
                LeaveCriticalSection(&pPort->pLocalmon->Section);
 
                DllFreeSplMem(pPort);
            }
        }
        FIXME("LcmXcvDeletePort => %u with %u\n", res, GetLastError() );
    }
 
Cleanup:
    if (hToken) ImpersonatePrinterClient(hToken);
    SetLastError(res);
    return res;
}
 
static DWORD
_HandleGetDefaultCommConfig(PBYTE pInputData, PBYTE pOutputData, DWORD cbOutputData, PDWORD pcbOutputNeeded)
{
    // Sanity checks
    if (!pInputData || !pcbOutputNeeded)
        return ERROR_INVALID_PARAMETER;
 
    *pcbOutputNeeded = sizeof(COMMCONFIG);
 
    // Check if the supplied buffer is large enough.
    if (cbOutputData < *pcbOutputNeeded)
        return ERROR_INSUFFICIENT_BUFFER;
 
    // Finally get the port configuration.
    if (!GetDefaultCommConfigW((PCWSTR)pInputData, (LPCOMMCONFIG)pOutputData, pcbOutputNeeded))
        return GetLastError();
 
    return ERROR_SUCCESS;
}
 
static DWORD
_HandleGetTransmissionRetryTimeout(PBYTE pOutputData, DWORD cbOutputData, PDWORD pcbOutputNeeded)
{
    DWORD dwTimeout;
 
    // Sanity checks
    if (!pOutputData || !pcbOutputNeeded)
        return ERROR_INVALID_PARAMETER;
 
    *pcbOutputNeeded = sizeof(DWORD);
 
    // Check if the supplied buffer is large enough.
    if (cbOutputData < *pcbOutputNeeded)
        return ERROR_INSUFFICIENT_BUFFER;
 
    // Retrieve and copy the number.
    dwTimeout = GetLPTTransmissionRetryTimeout();
    CopyMemory(pOutputData, &dwTimeout, sizeof(DWORD));
    return ERROR_SUCCESS;
}
 
static DWORD
_HandleMonitorUI(PBYTE pOutputData, DWORD cbOutputData, PDWORD pcbOutputNeeded)
{
    const WCHAR wszMonitorUI[] = L"LocalUI.dll";
 
    // Sanity checks
    if (!pcbOutputNeeded)
        return ERROR_INVALID_PARAMETER;
 
    *pcbOutputNeeded = sizeof(wszMonitorUI);
 
    // Check if the supplied buffer is large enough.
    if (cbOutputData < *pcbOutputNeeded)
        return ERROR_INSUFFICIENT_BUFFER;
 
    if (!pOutputData)
        return ERROR_INVALID_PARAMETER;
 
    // Copy the string.
    CopyMemory(pOutputData, wszMonitorUI, sizeof(wszMonitorUI));
    return ERROR_SUCCESS;
}
 
static DWORD
_HandlePortExists(PBYTE pInputData, PBYTE pOutputData, DWORD cbOutputData, PDWORD pcbOutputNeeded)
{
    // Sanity checks
    if (!pInputData || !pOutputData || !pcbOutputNeeded)
        return ERROR_INVALID_PARAMETER;
 
    *pcbOutputNeeded = sizeof(BOOL);
 
    // Check if the supplied buffer is large enough.
    if (cbOutputData < *pcbOutputNeeded)
        return ERROR_INSUFFICIENT_BUFFER;
 
    // Return the check result and error code.
    *(PBOOL)pOutputData = DoesPortExist((PCWSTR)pInputData);
    return GetLastError();
}
 
static DWORD
_HandlePortIsValid(PBYTE pInputData, PBYTE pOutputData, DWORD cbOutputData, PDWORD pcbOutputNeeded)
{
    DWORD res;
 
    TRACE("HandlePortIsValid : pInputData %s\n", debugstr_w( (LPWSTR) pInputData));
 
    res = GetTypeFromName((LPCWSTR) pInputData);
 
    TRACE("HandlePortIsValid : detected as %u\n",  res);
 
    /* names, that we have recognized, are valid */
    if (res) return ERROR_SUCCESS;
 
    TRACE("=> %u\n", GetLastError());
 
    /* ERROR_ACCESS_DENIED, ERROR_PATH_NOT_FOUND or something else */
    return GetLastError();
}
 
static DWORD
_HandleSetDefaultCommConfig(PLOCALMON_XCV pXcv, PBYTE pInputData, PDWORD pcbOutputNeeded)
{
    DWORD dwErrorCode;
    HANDLE hToken = NULL;
    LPCOMMCONFIG pCommConfig;
    PWSTR pwszPortNameWithoutColon = NULL;
 
    // Sanity checks
    // pwszObject needs to be at least 2 characters long to be a port name with a trailing colon.
    if (!pXcv || !pXcv->pwszObject || !pXcv->pwszObject[0] || !pXcv->pwszObject[1] || !pInputData || !pcbOutputNeeded)
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    *pcbOutputNeeded = 0;
 
    // This action can only happen at SERVER_ACCESS_ADMINISTER access level.
    if (!(pXcv->GrantedAccess & SERVER_ACCESS_ADMINISTER))
    {
        dwErrorCode = ERROR_ACCESS_DENIED;
        goto Cleanup;
    }
 
    // SetDefaultCommConfigW needs the port name without colon.
    dwErrorCode = GetPortNameWithoutColon(pXcv->pwszObject, &pwszPortNameWithoutColon);
    if (dwErrorCode != ERROR_SUCCESS)
        goto Cleanup;
 
    // Switch to the SYSTEM context for setting the port configuration.
    hToken = RevertToPrinterSelf();
    if (!hToken)
    {
        dwErrorCode = GetLastError();
        ERR("RevertToPrinterSelf failed with error %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // Finally pass the parameters to SetDefaultCommConfigW.
    pCommConfig = (LPCOMMCONFIG)pInputData;
    if (!SetDefaultCommConfigW(pwszPortNameWithoutColon, pCommConfig, pCommConfig->dwSize))
    {
        dwErrorCode = GetLastError();
        ERR("SetDefaultCommConfigW failed with error %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    if (hToken)
        ImpersonatePrinterClient(hToken);
 
    if (pwszPortNameWithoutColon)
        DllFreeSplMem(pwszPortNameWithoutColon);
 
    return dwErrorCode;
}
 
BOOL WINAPI
LocalmonXcvClosePort(HANDLE hXcv)
{
    PLOCALMON_XCV pXcv = (PLOCALMON_XCV)hXcv;
 
    TRACE("LocalmonXcvClosePort(%p)\n", hXcv);
 
    // Sanity checks
    if (!pXcv)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    // Remove it from the list and free the memory.
    EnterCriticalSection(&pXcv->pLocalmon->Section);
    RemoveEntryList(&pXcv->Entry);
    LeaveCriticalSection(&pXcv->pLocalmon->Section);
    DllFreeSplMem(pXcv);
 
    SetLastError(ERROR_SUCCESS);
    return TRUE;
}
 
DWORD WINAPI
LocalmonXcvDataPort(HANDLE hXcv, PCWSTR pszDataName, PBYTE pInputData, DWORD cbInputData, PBYTE pOutputData, DWORD cbOutputData, PDWORD pcbOutputNeeded)
{
    FIXME("LocalmonXcvDataPort(%p, %S, %p, %lu, %p, %lu, %p)\n", hXcv, pszDataName, pInputData, cbInputData, pOutputData, cbOutputData, pcbOutputNeeded);
 
    // Sanity checks
    if (!pszDataName)
        return ERROR_INVALID_PARAMETER;
 
    // Call the appropriate handler for the requested data name.
    if (wcscmp(pszDataName, L"AddPort") == 0)
        return _HandleAddPort((PLOCALMON_XCV)hXcv, pInputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"ConfigureLPTPortCommandOK") == 0)
        return _HandleConfigureLPTPortCommandOK((PLOCALMON_XCV)hXcv, pInputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"DeletePort") == 0)
        return _HandleDeletePort((PLOCALMON_XCV)hXcv, pInputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"GetDefaultCommConfig") == 0)
        return _HandleGetDefaultCommConfig(pInputData, pOutputData, cbOutputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"GetTransmissionRetryTimeout") == 0)
        return _HandleGetTransmissionRetryTimeout(pOutputData, cbOutputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"MonitorUI") == 0)
        return _HandleMonitorUI(pOutputData, cbOutputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"PortExists") == 0)
        return _HandlePortExists(pInputData, pOutputData, cbOutputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"PortIsValid") == 0)
        return _HandlePortIsValid(pInputData, pOutputData, cbOutputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"SetDefaultCommConfig") == 0)
        return _HandleSetDefaultCommConfig((PLOCALMON_XCV)hXcv, pInputData, pcbOutputNeeded);
 
    return ERROR_INVALID_PARAMETER;
}
 
BOOL WINAPI
LocalmonXcvOpenPort(HANDLE hMonitor, PCWSTR pwszObject, ACCESS_MASK GrantedAccess, PHANDLE phXcv)
{
    DWORD cbObject = 0;
    DWORD dwErrorCode;
    PLOCALMON_HANDLE pLocalmon = (PLOCALMON_HANDLE)hMonitor;
    PLOCALMON_XCV pXcv;
 
    FIXME("LocalmonXcvOpenPort(%p, %S, %lu, %p)\n", hMonitor, pwszObject, GrantedAccess, phXcv);
 
    // Sanity checks
    if (!pLocalmon || !phXcv)
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    if (pwszObject)
        cbObject = (wcslen(pwszObject) + 1) * sizeof(WCHAR);
 
    // Create a new LOCALMON_XCV structure and fill the relevant fields.
    pXcv = DllAllocSplMem(sizeof(LOCALMON_XCV) + cbObject);
    if (!pXcv)
    {
        dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
        ERR("DllAllocSplMem failed with error %lu!\n", GetLastError());
        goto Cleanup;
    }
 
    pXcv->pLocalmon = pLocalmon;
    pXcv->GrantedAccess = GrantedAccess;
 
    if (cbObject)
    {
        pXcv->pwszObject = (PWSTR)((PBYTE)pXcv + sizeof(LOCALMON_XCV));
        CopyMemory(pXcv->pwszObject, pwszObject, cbObject);
    }
 
    InsertTailList(&pLocalmon->XcvHandles, &pXcv->Entry);
 
    // Return it as the Xcv handle.
    *phXcv = (HANDLE)pXcv;
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}