pp.c

printer processor sample code. tried successfully in win2k, winxp,

    if (err)
    {
        SetLastError(err);
        return 0;
    }

    return dwFlags;
}



BOOL
PP_EnumPorts
(
    LPWSTR   pszName,
    DWORD    dwLevel,
    LPBYTE   pbPort,
    DWORD    cbBuf,
    LPDWORD  pcbNeeded,
    LPDWORD  pcReturned
)

{
    DWORD         err = NO_ERROR;
    DWORD         cb = 0;
    PPORT         pPort;
    WCHAR        *pbEnd;
    PORT_INFO_1W *pInfoStruct;

    if (dwLevel != 1)
    {
        SetLastError(ERROR_INVALID_NAME);
        return FALSE;
    }
    else if (!IsLocalMachine(pszName))
    {
        SetLastError(ERROR_INVALID_NAME);
        return FALSE;
    }

    EnterCriticalSection(&SplSem);

    pPort = pFirstPort;
    while (pPort)
    {
        cb += sizeof(PORT_INFO_1W) + (wcslen(pPort->pName)+1)*sizeof(WCHAR);
        pPort = pPort->pNext;
    }

    *pcbNeeded = cb;
    *pcReturned = 0;

    pbEnd = (WCHAR *)(pbPort + cb);
    pInfoStruct = (PORT_INFO_1W *)pbPort;

    if (cb <= cbBuf)
    {
        pPort = pFirstPort;
        while (pPort)
        {
            int cwbName = wcslen(pPort->pName)+1;
            pbEnd -= cwbName;
            memmove((char *)pbEnd, (char *)pPort->pName, cwbName*sizeof(WCHAR));

            pInfoStruct->pName = pbEnd;
            pInfoStruct++;

            pPort = pPort->pNext;
            (*pcReturned)++;
        }
    }
    else
    {
        err = ERROR_INSUFFICIENT_BUFFER;
    }

    LeaveCriticalSection(&SplSem);

    if (err)
    {
        SetLastError(err);
    }

    return (err == NO_ERROR);
}



BOOL
PP_DeletePort
(
    LPWSTR  pszName,
    HWND    hWnd,
    LPWSTR  pszPortName
)

{
    DWORD err = NO_ERROR;
    BOOL fPortDeleted;

    if (!IsLocalMachine(pszName))
    {
        SetLastError(ERROR_NOT_SUPPORTED);
        return FALSE;
    }

    fPortDeleted = DeletePortEntry(pszPortName);

    if (fPortDeleted)
    {
        err = DeleteRegistryEntry(pszPortName);
    }
    else
    {
        err = ERROR_UNKNOWN_PORT;
    }

    if (err)
    {
        SetLastError(err);
    }
    return (err == NO_ERROR);
}



BOOL
PP_ConfigurePort
(
    LPWSTR  pszName,
    HWND    hWnd,
    LPWSTR  pszPortName
)

{
    if (!IsLocalMachine(pszName))
    {
        SetLastError(ERROR_NOT_SUPPORTED);
        return FALSE;
    }
    else if (!PortKnown(pszPortName))
    {
        SetLastError(ERROR_UNKNOWN_PORT);
        return FALSE;
    }

    return TRUE;
}

BOOL
PP_AddPrinterConnection
(
    LPWSTR  pszPrinterName
)
{
    SetLastError(ERROR_INVALID_NAME);
    return FALSE;
}

BOOL
PP_EnumMonitors
(
    LPWSTR   pszName,
    DWORD    dwLevel,
    LPBYTE   pbMonitor,
    DWORD    cbBuf,
    LPDWORD  pcbNeeded,
    LPDWORD  pcReturned
)
{
    SetLastError(ERROR_INVALID_NAME);
    return FALSE;
}


BOOL
PP_AddPort
(
    LPWSTR  pszName,
    HWND    hWnd,
    LPWSTR  pszMonitorName
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}


HANDLE
PP_AddPrinter
(
    LPWSTR  pszName,
    DWORD   dwLevel,
    LPBYTE  pbPrinter
)
{
    LPTSTR     pszPrinterName = NULL;
    LPTSTR     pszPServer = NULL;
    LPTSTR     pszQueue  =  NULL;
    HANDLE     hPrinter = NULL;
    size_t     uSize = 0;
    DWORD      err;
    PPRINTER_INFO_2 pPrinterInfo;

    pPrinterInfo = (PPRINTER_INFO_2)pbPrinter;

    if (dwLevel != 2)
    {
        err = ERROR_INVALID_PARAMETER;
        goto ErrorExit;
    }

    uSize = wcslen(((PRINTER_INFO_2 *)pbPrinter)->pPrinterName) + 1;

    if (!(pszPrinterName = (LPTSTR)LocalAlloc(LPTR, uSize * sizeof(WCHAR))))
    {
        err = ERROR_NOT_ENOUGH_MEMORY;
        goto ErrorExit;
    }

    err = StatusFromHResult(StringCchCopy(pszPrinterName, uSize, pPrinterInfo->pPrinterName));

    if (err != ERROR_SUCCESS)
    {
        goto ErrorExit;
    }


    if (  ( !ValidateUNCName(pszPrinterName))
       || ( (pszQueue = wcschr(pszPrinterName + 2, L'\\')) == NULL)
       || ( pszQueue == (pszPrinterName + 2))
       || ( *(pszQueue + 1) == L'\0')
       )
    {
        err =  ERROR_INVALID_NAME;
        goto ErrorExit;
    }

    if (pszPrinterName == NULL)
    {
        SetLastError(ERROR_INVALID_NAME);
        goto ErrorExit;
    }

    if (PortExists(pszPrinterName, &err) && !err)
    {
        SetLastError(ERROR_ALREADY_ASSIGNED);
        goto ErrorExit;
    }

    return hPrinter;

ErrorExit:
    if (!pszPrinterName)
    {
        (void)LocalFree((HLOCAL)pszPrinterName);
    }

    SetLastError(err);
    return (HANDLE)0x0;
}


BOOL
PP_DeletePrinter
(
    HANDLE  hPrinter
)
{
    LPWSTR pszPrinterName = NULL ;
    DWORD err = NO_ERROR;
    DWORD DoesPortExist = FALSE;

    pszPrinterName = (LPWSTR)LocalAlloc(LPTR,sizeof(WCHAR)*MAX_PATH);

    if (pszPrinterName == NULL)
    {
        err = ERROR_NOT_ENOUGH_MEMORY;
        return FALSE;
    }





    if (!err && PortExists(pszPrinterName, &DoesPortExist) && DoesPortExist)
    {
        if (DeleteRegistryEntry(pszPrinterName))
        {
            (void) DeletePortEntry(pszPrinterName);
        }
    }

    if (err)
    {
        SetLastError(err);
    }
    return (err == NO_ERROR);
}


BOOL
PP_DeletePrinterConnection
(
    LPWSTR  pszName
)
{
    SetLastError(ERROR_INVALID_NAME);
    return FALSE;
}


BOOL
PP_AddPrinterDriver
(
    LPWSTR  pszName,
    DWORD   dwLevel,
    LPBYTE  pbPrinter
)
{
    SetLastError(ERROR_INVALID_NAME);
    return FALSE;
}

BOOL
PP_EnumPrinterDrivers
(
    LPWSTR   pszName,
    LPWSTR   pszEnvironment,
    DWORD    dwLevel,
    LPBYTE   pbDriverInfo,
    DWORD    cbBuf,
    LPDWORD  pcbNeeded,
    LPDWORD  pcReturned
)
{
    SetLastError(ERROR_INVALID_NAME);
    return FALSE;
}

BOOL
PP_GetPrinterDriver
(
    HANDLE   hPrinter,
    LPWSTR   pszEnvironment,
    DWORD    dwLevel,
    LPBYTE   pbDriverInfo,
    DWORD    cbBuf,
    LPDWORD  pcbNeeded
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

BOOL
PP_GetPrinterDriverDirectory
(
    LPWSTR   pszName,
    LPWSTR   pszEnvironment,
    DWORD    dwLevel,
    LPBYTE   pbDriverDirectory,
    DWORD    cbBuf,
    LPDWORD  pcbNeeded
)
{
    SetLastError(ERROR_INVALID_NAME);
    return FALSE;
}

BOOL
PP_DeletePrinterDriver
(
    LPWSTR  pszName,
    LPWSTR  pszEnvironment,
    LPWSTR  pszDriverName
)
{
    SetLastError(ERROR_INVALID_NAME);
    return FALSE;
}

BOOL
PP_AddPrintProcessor
(
    LPWSTR  pszName,
    LPWSTR  pszEnvironment,
    LPWSTR  pszPathName,
    LPWSTR  pszPrintProcessorName
)
{
    SetLastError(ERROR_INVALID_NAME);
    return FALSE;
}

BOOL
PP_EnumPrintProcessors
(
    LPWSTR   pszName,
    LPWSTR   pszEnvironment,
    DWORD    dwLevel,
    LPBYTE   pbPrintProcessorInfo,
    DWORD    cbBuf,
    LPDWORD  pcbNeeded,
    LPDWORD  pcReturned
)
{
    SetLastError(ERROR_INVALID_NAME);
    return FALSE;
}

BOOL
PP_EnumPrintProcessorDatatypes
(
    LPWSTR   pszName,
    LPWSTR   pszPrintProcessorName,
    DWORD    dwLevel,
    LPBYTE   pbDatatypes,
    DWORD    cbBuf,
    LPDWORD  pcbNeeded,
    LPDWORD  pcReturned
)
{
    SetLastError(ERROR_INVALID_NAME);
    return FALSE;
}

BOOL
PP_GetPrintProcessorDirectory
(
    LPWSTR   pszName,
    LPWSTR   pszEnvironment,
    DWORD    dwLevel,
    LPBYTE   pbPrintProcessorDirectory,
    DWORD    cbBuf,
    LPDWORD  pcbNeeded
)
{
    SetLastError(ERROR_INVALID_NAME);
    return FALSE;
}

BOOL
PP_StartPagePrinter
(
    HANDLE  hPrinter
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

BOOL
PP_EndPagePrinter
(
    HANDLE  hPrinter
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

BOOL
PP_ReadPrinter
(
    HANDLE   hPrinter,
    LPVOID   pBuf,
    DWORD    cbBuf,
    LPDWORD  pcbRead
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

DWORD
PP_GetPrinterData
(
    HANDLE   hPrinter,
    LPWSTR   pszValueName,
    LPDWORD  pdwType,
    LPBYTE   pbData,
    DWORD    cbBuf,
    LPDWORD  pcbNeeded
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

DWORD
PP_SetPrinterData
(
    HANDLE  hPrinter,
    LPWSTR  pszValueName,
    DWORD   dwType,
    LPBYTE  pbData,
    DWORD   cbData
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

BOOL
PP_AddForm
(
    HANDLE  hPrinter,
    DWORD   dwLevel,
    LPBYTE  pbForm
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

BOOL
PP_DeleteForm
(
    HANDLE  hPrinter,
    LPWSTR  pszFormName
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

BOOL
PP_GetForm
(
    HANDLE   hPrinter,
    LPWSTR   pszFormName,
    DWORD    dwLevel,
    LPBYTE   pbForm,
    DWORD    cbBuf,
    LPDWORD  pcbNeeded
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

BOOL
PP_SetForm
(
    HANDLE  hPrinter,
    LPWSTR  pszFormName,
    DWORD   dwLevel,
    LPBYTE  pbForm
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

BOOL
PP_EnumForms
(
    HANDLE   hPrinter,
    DWORD    dwLevel,
    LPBYTE   pbForm,
    DWORD    cbBuf,
    LPDWORD  pcbNeeded,
    LPDWORD  pcReturned
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}


HANDLE
PP_CreatePrinterIC
(
    HANDLE     hPrinter,
    LPDEVMODE  pDevMode
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

BOOL
PP_PlayGdiScriptOnPrinterIC
(
    HANDLE  hPrinterIC,
    LPBYTE  pbIn,
    DWORD   cbIn,
    LPBYTE  pbOut,
    DWORD   cbOut,
    DWORD   ul
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

BOOL
PP_DeletePrinterIC
(
    HANDLE  hPrinterIC
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

DWORD
PP_PrinterMessageBox
(
    HANDLE  hPrinter,
    DWORD   dwError,
    HWND    hWnd,
    LPWSTR  pszText,
    LPWSTR  pszCaption,
    DWORD   dwType
)
{
    SetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

BOOL
PP_AddMonitor
(
    LPWSTR  pszName,
    DWORD   dwLevel,
    LPBYTE  pbMonitorInfo
)
{
    SetLastError(ERROR_INVALID_NAME);
    return FALSE;
}

BOOL
PP_DeleteMonitor
(
    LPWSTR  pszName,
    LPWSTR  pszEnvironment,
    LPWSTR  pszMonitorName
)
{
    SetLastError(ERROR_INVALID_NAME);
    return FALSE;
}

BOOL
PP_DeletePrintProcessor
(
    LPWSTR  pszName,
    LPWSTR  pszEnvironment,
    LPWSTR  pszPrintProcessorName
)
{
    SetLastError(ERROR_INVALID_NAME);
    return FALSE;
}

DWORD
StatusFromHResult(
    IN HRESULT hr
    )
{
    DWORD   Status = ERROR_SUCCESS;

    if (FAILED(hr))
    {
        if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
        {
            Status = HRESULT_CODE(hr);
        }
        else
        {
            Status = hr;
        }
    }

    return Status;
}

BOOL
BoolFromStatus(
    IN DWORD Status
    )
{
    BOOL bRet = TRUE;

    if (ERROR_SUCCESS != Status)
    {
        SetLastError(Status);

        bRet = FALSE;
    }

    return bRet;
}