windows-xp/Source/XPSP1/NT/printscan/print/spooler/inetpp2/server/ppinfo.cxx

/*****************************************************************************\
* MODULE: ppinfo.c
*
* This module contains the print-information routines.
*
*
* Copyright (C) 1996-1997 Microsoft Corporation
* Copyright (C) 1996-1997 Hewlett Packard
*
* History:
*   09-Jun-1993 JonMarb     Created
*   07-Oct-1996 HWP-Guys    Initiated port from win95 to winNT
*
\*****************************************************************************/


#include "precomp.h"
#include "priv.h"

/*****************************************************************************\
* ppprn_IppGetRsp (Local Callback Routine)
*
* Retrieves a GetPrinter response from the IPP server
*
\*****************************************************************************/
BOOL CALLBACK ppinfo_IppGetRsp(
    CAnyConnection *pConnection,
    HINTERNET hReq,
    PCINETMONPORT   pIniPort,
    LPARAM    lParam)
{
    HANDLE       hIpp;
    DWORD        dwRet;
    DWORD        cbRd;
    LPBYTE       lpDta;
    DWORD        cbDta;
    LPIPPRET_PRN lpRsp;
    DWORD        cbRsp;
    BYTE         bBuf[MAX_IPP_BUFFER];
    BOOL         bRet = FALSE;


    if (hIpp = WebIppRcvOpen(IPP_RET_GETPRN)) {

        while (TRUE) {

            cbRd = 0;
            if (pIniPort->ReadFile (pConnection, hReq, (LPVOID)bBuf, sizeof(bBuf), &cbRd) && cbRd) {

                dwRet = WebIppRcvData(hIpp, bBuf, cbRd, (LPBYTE*)&lpRsp, &cbRsp, &lpDta, &cbDta);

                switch (dwRet) {

                case WEBIPP_OK:

                    if (!lpRsp) {
                        SetLastError (ERROR_INVALID_DATA);
                    }
                    else if ((bRet = lpRsp->bRet) == FALSE)
                        SetLastError(lpRsp->dwLastError);
                    else {

                        pIniPort->SetPowerUpTime (lpRsp->pi.ipp.dwPowerUpTime);
                        ((LPPRINTER_INFO_2)lParam)->Status       = lpRsp->pi.pi2.Status;
                        ((LPPRINTER_INFO_2)lParam)->cJobs        = lpRsp->pi.pi2.cJobs;
                        ((LPPRINTER_INFO_2)lParam)->pPrinterName = memAllocStr(lpRsp->pi.pi2.pPrinterName);
                        ((LPPRINTER_INFO_2)lParam)->pDriverName  = memAllocStr(lpRsp->pi.pi2.pDriverName);
                    }

                    WebIppFreeMem(lpRsp);

                    goto EndGetRsp;

                case WEBIPP_MOREDATA:

                    // Need to do another read to fullfill our header-response.
                    //

                    break;

                default:

                    DBG_MSG(DBG_LEV_ERROR, (TEXT("ppinfo_IppGetRsp - Err : Receive Data Error (dwRet=%d, LE=%d)"),
                         dwRet, WebIppGetError(hIpp)));

                    SetLastError(ERROR_INVALID_DATA);

                    goto EndGetRsp;
                }

            } else {

                goto EndGetRsp;
            }
        }

EndGetRsp:

        WebIppRcvClose(hIpp);

    } else {

        SetLastError(ERROR_OUTOFMEMORY);
    }

    return bRet;
}


/*****************************************************************************\
* ppinfo_Get (Local Routine)
*
* Gets printer info from server.
*
\*****************************************************************************/
BOOL ppinfo_Get(
    PCINETMONPORT           pIniPort,
    LPPRINTER_INFO_2 ppi2)
{
    PIPPREQ_GETPRN pgp;
    REQINFO        ri;
    DWORD          dwRet;
    LPBYTE         lpIpp;
    DWORD          cbIpp;
    LPCTSTR        lpszUri;
    BOOL           bRet = FALSE;

    lpszUri = pIniPort->GetPortName();


    // Create our ipp-reqest-structure.
    //
    if (pgp = WebIppCreateGetPrnReq(0, lpszUri)) {

        // Convert the reqest to IPP, and perform the
        // post.
        //
        ZeroMemory(&ri, sizeof(REQINFO));
        ri.cpReq = CP_UTF8;
        ri.idReq = IPP_REQ_GETPRN;

        ri.fReq[0] = IPP_REQALL;
        ri.fReq[1] = IPP_REQALL;

        dwRet = WebIppSndData(IPP_REQ_GETPRN,
                              &ri,
                              (LPBYTE)pgp,
                              pgp->cbSize,
                              &lpIpp,
                              &cbIpp);


        // The request-structure has been converted to IPP format,
        // so it is ready to go to the server.
        //
        if (dwRet == WEBIPP_OK) {

            bRet = pIniPort->SendReq(lpIpp,
                                     cbIpp,
                                     ppinfo_IppGetRsp,
                                     (LPARAM)ppi2,
                                     TRUE);

            WebIppFreeMem(lpIpp);

        } else {

            SetLastError(ERROR_OUTOFMEMORY);
        }

        WebIppFreeMem(pgp);

    } else {

        SetLastError(ERROR_OUTOFMEMORY);
    }

    return bRet;
}


/*****************************************************************************\
* _ppinfo_set_str (Local Routine)
*
* Copies strings into a Win32 format buffer -- a structure at the front of
* the buffer and strings packed into the end.
*
* On entry, *buf should point to the last available byte in the buffer.
*
\*****************************************************************************/
VOID _ppinfo_set_str(
    LPTSTR  *dest,
    LPCTSTR src,
    LPTSTR  *buf)
{
    if (src != NULL) {

        // Place string at end of buffer.  This performs pointer
        // arithmatic, so the offsets are TCHAR in size.
        //
        (*buf) -= lstrlen(src);

        DBG_ASSERT( ((DWORD_PTR)dest < (DWORD_PTR)*buf) ,
                    (TEXT("String fill overrun in _ppinfo_set_str"))
                  );

        lstrcpy(*buf, src);


        // Place string address in structure and save pointer to new
        // last available byte.
        //
        *dest = *buf;
        (*buf)--;

    } else {

        *dest = TEXT('\0');
    }
}


/*****************************************************************************\
* _ppinfo_describe_provider (Local Routine)
*
* Fills a PRINTER_INFO_1 structure with information about the print provider.
* Returns TRUE if successful.  Otherwise, it returns FALSE.  Extended error
* information is available from GetLastError.
*
\*****************************************************************************/
BOOL _ppinfo_describe_provider(
    LPPRINTER_INFO_1 pInfo,
    DWORD            cbSize,
    LPDWORD          pcbNeeded,
    LPDWORD          pcbReturned)
{
    LPTSTR pszString;


    // Calculate the space needed (in bytes) that is necessary to
    // store the information for the print-processor.
    //
    *pcbNeeded = sizeof(PRINTER_INFO_1)       +
                 utlStrSize(g_szDescription)  +
                 utlStrSize(g_szProviderName) +
                 utlStrSize(g_szComment);

    if (*pcbNeeded > cbSize) {

        *pcbReturned = 0;

        DBG_MSG(DBG_LEV_WARN, (TEXT("Warn: _describe_provider: Not enough memory")));
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }


    // Initialize the fields which do not need to copy strings.
    //
    pInfo->Flags = (PRINTER_ENUM_ICON1 | PRINTER_ENUM_CONTAINER);

    //
    // Hide this provider from the UI, there is nothing underneath to enumerate.
    //
#if WINNT32
    pInfo->Flags |= PRINTER_ENUM_HIDE;
#endif

    // Set the string information.  First set the (pszString) pointer
    // to the first location at the end of the buffer which will store
    // the string.
    //
    pszString = ENDOFBUFFER(pInfo, cbSize);

    _ppinfo_set_str(&pInfo->pDescription, g_szDescription , &pszString);
    _ppinfo_set_str(&pInfo->pName       , g_szProviderName, &pszString);
    _ppinfo_set_str(&pInfo->pComment    , g_szComment     , &pszString);


    // Return the number of structures copied.
    //
    *pcbReturned = 1;

    return TRUE;
}


/*****************************************************************************\
* _ppinfo_net_get_info (Local Routine)
*
* Fills a supplied PRINTER_INFO_2 structure with all the information
* we can dig up on the specified IPP1 print server.
*
* Takes a pointer to PPRINTER_INFO_2 which is allocated to be the correct size
*
* Returns TRUE if successful, FALSE if otherwise.
*
\*****************************************************************************/
BOOL _ppinfo_net_get_info(
    IN  PCINETMONPORT   pIniPort,
    OUT PPRINTER_INFO_2 *ppInfo,
    OUT LPDWORD         lpBufAllocated,
    IN  ALLOCATORFN     pAllocator)
{
    PRINTER_INFO_2  pi2;
    PPRINTER_INFO_2 pInfo;
    LPTSTR          pszString;
    LPCTSTR          pszPortName;
    DWORD           dwAllocSize;
    BOOL            bRet = FALSE;


    // Make a server-call to get the printer-information.
    //
    DBG_ASSERT( ppInfo,         (TEXT("_ppinfo_net_get_info passed in NULL LPPI2 *")) );
    DBG_ASSERT( pAllocator,     (TEXT("_ppinfo_net_get_info passed in NULL Allocator")) );
    DBG_ASSERT( lpBufAllocated, (TEXT("_ppinfo_net_get_info passed in NULL buffer allocated return size")) );

    *ppInfo = NULL;             // NULL out ppInfo, just in case
    *lpBufAllocated = 0;        // Set allocated size to zero

    ZeroMemory(&pi2, sizeof(PRINTER_INFO_2));

    if (!ppinfo_Get(pIniPort, &pi2))
        goto BailOut;

    pszPortName = pIniPort->GetPortName();

    dwAllocSize = ( ( pi2.pPrinterName ? lstrlen( pi2.pPrinterName) + 1 : 0) +
                    ( pszPortName      ? lstrlen( pszPortName )     + 1 : 0) +
                    ( pi2.pDriverName  ? lstrlen( pi2.pDriverName ) + 1 : 0) +
                      7 * 1 ) * sizeof(TCHAR) + sizeof(PRINTER_INFO_2);

    pInfo = (PPRINTER_INFO_2)pAllocator( dwAllocSize );

    if (NULL == pInfo)
        goto Cleanup;

    pszString = ENDOFBUFFER( pInfo, dwAllocSize );

    // Set non-string entries.
    //
    pInfo->cJobs               = pi2.cJobs;
    pInfo->Status              = pi2.Status;
    pInfo->pDevMode            = NULL;
    pInfo->pSecurityDescriptor = NULL;
#if 0
    pInfo->Attributes          = PRINTER_ATTRIBUTE_SHARED;
#else
    pInfo->Attributes          = PRINTER_ATTRIBUTE_NETWORK;
#endif
    pInfo->Priority            = pi2.Priority;
    pInfo->StartTime           = pi2.StartTime;
    pInfo->UntilTime           = pi2.UntilTime;
    pInfo->AveragePPM          = pi2.AveragePPM;


    // Set any remaining fields that we can't fill to reasonable values.
    //
    _ppinfo_set_str(&pInfo->pPrinterName   , pi2.pPrinterName         , &pszString);
    _ppinfo_set_str(&pInfo->pShareName     , g_szEmptyString          , &pszString);
    _ppinfo_set_str(&pInfo->pPortName      , pszPortName              , &pszString);
    _ppinfo_set_str(&pInfo->pDriverName    , pi2.pDriverName          , &pszString);
    _ppinfo_set_str(&pInfo->pComment       , g_szEmptyString          , &pszString);
    _ppinfo_set_str(&pInfo->pLocation      , g_szEmptyString          , &pszString);
    _ppinfo_set_str(&pInfo->pSepFile       , g_szEmptyString          , &pszString);
    _ppinfo_set_str(&pInfo->pPrintProcessor, g_szEmptyString          , &pszString);
    _ppinfo_set_str(&pInfo->pDatatype      , g_szEmptyString          , &pszString);
    _ppinfo_set_str(&pInfo->pParameters    , g_szEmptyString          , &pszString);

    *lpBufAllocated = dwAllocSize;  // Set the size to what we have allocated
    *ppInfo = pInfo;                // Return the allocated structure
    // Since we've allocated our strings in ppinfo_get, we will need
    // to explicitly free them.
    //

    bRet = TRUE;

Cleanup:

    if (pi2.pPrinterName) memFreeStr(pi2.pPrinterName);
    if (pi2.pDriverName) memFreeStr(pi2.pDriverName);

BailOut:

    return bRet;
}


/*****************************************************************************\
* _ppinfo_calc_level1 (Local Routine)
*
* Calculates the amount of buffer space needed to store a single level 1
* GetPrinter() result buffer.
*
\*****************************************************************************/
DWORD _ppinfo_calc_level1(
    PPRINTER_INFO_2 pSrcInfo)
{
    DWORD cbSize;

    //
    // Figure out how many bytes of buffer space we're going to need.
    //
    cbSize = sizeof(PRINTER_INFO_1)             +
             utlStrSize(g_szEmptyString)        +  // description
             utlStrSize(pSrcInfo->pPrinterName) +  // name
             utlStrSize(pSrcInfo->pComment);       // comment

    return cbSize;
}


/*****************************************************************************\
* _ppinfo_calc_level2 (Local Routine)
*
* Calculates the amount of buffer space needed to
* store a single level 2 GetPrinter() result buffer.
*
\*****************************************************************************/
DWORD _ppinfo_calc_level2(
    LPCTSTR         pszServerName,
    PPRINTER_INFO_2 pSrcInfo)
{
    DWORD     cbSize;
    LPDEVMODE pDevmode;

    //
    // Figure out how many bytes of buffer space we're going to need.
    //
    cbSize = sizeof(PRINTER_INFO_2)                +
             utlStrSize(pszServerName)             +  // Server Name
             utlStrSize(pSrcInfo->pPrinterName)    +  // Printer Name
             utlStrSize(pSrcInfo->pShareName)      +  // Share Name
             utlStrSize(pSrcInfo->pPortName)       +  // Port Name
             utlStrSize(pSrcInfo->pDriverName)     +  // Driver Name
             utlStrSize(pSrcInfo->pComment)        +  // Comment
             utlStrSize(pSrcInfo->pLocation)       +  // Location
             utlStrSize(pSrcInfo->pSepFile)        +  // Separator file
             utlStrSize(pSrcInfo->pPrintProcessor) +  // Print processor
             utlStrSize(pSrcInfo->pDatatype)       +  // Data type
             utlStrSize(pSrcInfo->pParameters);       // Parameters

    if (pSrcInfo->pDevMode != NULL) {
        pDevmode = pSrcInfo->pDevMode;
        cbSize  += pDevmode->dmSize + pDevmode->dmDriverExtra;
    }

    return cbSize;
}


#if WINNT32
/*****************************************************************************\
* _ppinfo_calc_level4 (Local Routine)
*
* Calculates the amount of buffer space needed to
* store a single level 4 GetPrinter() result buffer.
*
\*****************************************************************************/
DWORD _ppinfo_calc_level4(
    PPRINTER_INFO_2 pSrcInfo)
{
    DWORD cbSize;

    //
    // Figure out how many bytes of buffer space we're going to need.
    //
    cbSize = sizeof(PRINTER_INFO_4)                +
             utlStrSize(pSrcInfo->pPrinterName)    +  // Printer Name
             utlStrSize(pSrcInfo->pServerName);


    return cbSize;
}
#endif


/*****************************************************************************\
* _ppinfo_calc_level2 (Local Routine)
*
* Calculates the amount of buffer space needed to
* store a single level 5 GetPrinter() result buffer.
*
\*****************************************************************************/
DWORD _ppinfo_calc_level5(
    PPRINTER_INFO_2 pSrcInfo)
{
    DWORD cbSize;


    //
    // Figure out how many bytes of buffer space we're going to need.
    //
    cbSize = sizeof(PRINTER_INFO_5)                +
             utlStrSize(pSrcInfo->pPrinterName)    +  // Printer Name
             utlStrSize(pSrcInfo->pPortName);


    return cbSize;
}


/*****************************************************************************\
* _ppinfo_build_level1 (Local Routine)
*
* Given a pointer to a source PRINTER_INFO_2 structure, a
* destination PRINTER_INFO_1 structure and a pointer to the
* start of string storage space, fills the PRINTER_INFO_1 structure.
*
* Called by GetPrinter and EnumPrinters, level 1.  Returns an
* LPSTR pointer to the last available data byte remaining in the
* buffer.
*
\*****************************************************************************/
LPTSTR _ppinfo_build_level1(
    PPRINTER_INFO_2 pSrcInfo,
    PPRINTER_INFO_1 pDstInfo,
    LPTSTR          pszString)
{
    // Flags.
    //
    pDstInfo->Flags = PRINTER_ENUM_CONTAINER;

#if WINNT32
    pDstInfo->Flags |= PRINTER_ENUM_HIDE;
#endif

    // Description
    //
    // CODEWORK - The Win32 structure has a field for "description" that has
    // no equivalent in the network printer info structure.  What do we
    // really want here?  For now, I'm copying in an empty string as a
    // placeholder.
    //
    _ppinfo_set_str(&pDstInfo->pDescription, g_szEmptyString       , &pszString);
    _ppinfo_set_str(&pDstInfo->pName       , pSrcInfo->pPrinterName, &pszString);
    _ppinfo_set_str(&pDstInfo->pComment    , pSrcInfo->pComment    , &pszString);

    return pszString;
}


/*****************************************************************************\
* _ppinfo_build_level2 (Local Routine)
*
* Given a server name, a pointer to a source PRINTER_INFO_2
* structure, a destination PRINTER_INFO_2 structure and a pointer to
* the start of string storage space, fills the PRINTER_INFO_2 structure.
*
* Called by GetPrinter and EnumPrinters, level 2.  Returns an
* LPTSTR pointer to the last available data char in the data buffer.
*
\*****************************************************************************/
LPTSTR _ppinfo_build_level2(
    LPCTSTR         pszServerName,
    PPRINTER_INFO_2 pSrcInfo,
    PPRINTER_INFO_2 pDstInfo,
    LPTSTR          pszString)
{

    // Set non-string entries.
    //
    pDstInfo->pSecurityDescriptor = NULL;
    pDstInfo->Attributes          = pSrcInfo->Attributes;
    pDstInfo->Priority            = pSrcInfo->Priority;
    pDstInfo->DefaultPriority     = pSrcInfo->Priority;
    pDstInfo->StartTime           = pSrcInfo->StartTime;
    pDstInfo->UntilTime           = pSrcInfo->UntilTime;
    pDstInfo->Status              = pSrcInfo->Status;
    pDstInfo->cJobs               = pSrcInfo->cJobs;
    pDstInfo->AveragePPM          = pSrcInfo->AveragePPM;


    // Copy the required data to the Win 32 PRINTER_INFO_2 structure.
    //
    // SPECWORK - several of these fields are filled with "" placeholders.
    // We probably need to put real information  in some of them.
    // The current inetpp protocol does not supply this information to us.
    //
    _ppinfo_set_str(&pDstInfo->pServerName    , pszServerName            , &pszString);
    _ppinfo_set_str(&pDstInfo->pPrinterName   , pSrcInfo->pPrinterName   , &pszString);
    _ppinfo_set_str(&pDstInfo->pShareName     , pSrcInfo->pShareName     , &pszString);
    _ppinfo_set_str(&pDstInfo->pPortName      , pSrcInfo->pPortName      , &pszString);
    _ppinfo_set_str(&pDstInfo->pDriverName    , pSrcInfo->pDriverName    , &pszString);
    _ppinfo_set_str(&pDstInfo->pComment       , pSrcInfo->pComment       , &pszString);
    _ppinfo_set_str(&pDstInfo->pLocation      , pSrcInfo->pLocation      , &pszString);
    _ppinfo_set_str(&pDstInfo->pSepFile       , pSrcInfo->pSepFile       , &pszString);
    _ppinfo_set_str(&pDstInfo->pPrintProcessor, pSrcInfo->pPrintProcessor, &pszString);
    _ppinfo_set_str(&pDstInfo->pDatatype      , pSrcInfo->pDatatype      , &pszString);
    _ppinfo_set_str(&pDstInfo->pParameters    , pSrcInfo->pParameters    , &pszString);

    // If a devmode exist, then it will need to be copied as well.
    //
    if (pSrcInfo->pDevMode != NULL) {

        memCopy((LPSTR *)&pDstInfo->pDevMode,
                (LPSTR)pSrcInfo->pDevMode,
                pSrcInfo->pDevMode->dmSize + pSrcInfo->pDevMode->dmDriverExtra,
                (LPSTR *)&pszString);

    } else {

        pDstInfo->pDevMode = NULL;
    }

    return pszString;
}


#if WINNT32
/*****************************************************************************\
* _ppinfo_build_level4 (Local Routine)
*
* Given a server name, a pointer to a source PRINTER_INFO_2
* structure, a destination PRINTER_INFO_5 structure and a pointer to
* the start of string storage space, fills the PRINTER_INFO_4 structure.
*
* Called by GetPrinter and EnumPrinters, level 2.  Returns an
* LPTSTR pointer to the last available data char in the data buffer.
*
\*****************************************************************************/
LPTSTR _ppinfo_build_level4(
    PPRINTER_INFO_2 pSrcInfo,
    PPRINTER_INFO_4 pDstInfo,
    LPTSTR          pszString)
{
    // Set non-string entries.
    //
    pDstInfo->Attributes = pSrcInfo->Attributes;


    // Copy the required data to the Win 32 PRINTER_INFO_4 structure.
    //
    _ppinfo_set_str(&pDstInfo->pPrinterName, pSrcInfo->pPrinterName, &pszString);
    _ppinfo_set_str(&pDstInfo->pServerName , pSrcInfo->pServerName , &pszString);

    return pszString;
}
#endif


/*****************************************************************************\
* _ppinfo_build_level5 (Local Routine)
*
* Given a server name, a pointer to a source PRINTER_INFO_2
* structure, a destination PRINTER_INFO_5 structure and a pointer to
* the start of string storage space, fills the PRINTER_INFO_5 structure.
*
* Called by GetPrinter and EnumPrinters, level 2.  Returns an
* LPTSTR pointer to the last available data char in the data buffer.
*
\*****************************************************************************/
LPTSTR _ppinfo_build_level5(
    PPRINTER_INFO_2 pSrcInfo,
    PPRINTER_INFO_5 pDstInfo,
    LPTSTR          pszString)
{
    // Set non-string entries.
    //
    pDstInfo->Attributes               = pSrcInfo->Attributes;
    pDstInfo->DeviceNotSelectedTimeout = 0;
    pDstInfo->TransmissionRetryTimeout = 0;


    // Copy the required data to the Win 32 PRINTER_INFO_5 structure.
    //
    _ppinfo_set_str(&pDstInfo->pPrinterName, pSrcInfo->pPrinterName, &pszString);
    _ppinfo_set_str(&pDstInfo->pPortName   , pSrcInfo->pPortName   , &pszString);

    return pszString;
}


/*****************************************************************************\
* _ppinfo_get_level1 (Local Routine)
*
* Given pInfo, a block of information on a printer returned by a
* DosPrintQGetInfo call, fill a PRINTER_INFO_1 structure.  Returns
* TRUE if successful, FALSE otherwise.  Places the number of bytes
* of (lpbBuffer) used in the DWORD pointed to by (pcbNeeded).
*
\*****************************************************************************/
BOOL _ppinfo_get_level1(
    PPRINTER_INFO_2 pSrcInfo,
    LPBYTE          lpbBuffer,
    DWORD           cbBuf,
    LPDWORD         pcbNeeded)
{
    // Figure out how many bytes of buffer space we're going to need.
    // Set error code and return failure if we don't have enough.
    //
    *pcbNeeded = _ppinfo_calc_level1(pSrcInfo);

    if (*pcbNeeded > cbBuf) {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }


    // Copy the required data from the structure to the Win32
    // structure.
    //
    _ppinfo_build_level1(pSrcInfo,
                         (PPRINTER_INFO_1)lpbBuffer,
                         ENDOFBUFFER(lpbBuffer, cbBuf));

    return TRUE;

}


/*****************************************************************************\
* _ppinfo_get_level2 (Local Routine)
*
* Given pInfo, a block of information on a printer returned by a
* PrintQGetInfo call, fill a PRINTER_INFO_2 structure.  Returns
* TRUE if successful, FALSE otherwise. Places the number of bytes of
* (lpbBuffer) used in the DWORD pointed to by (pcbNeeded).
*
\*****************************************************************************/
BOOL _ppinfo_get_level2(
    PPRINTER_INFO_2 pSrcInfo,
    LPBYTE          lpbBuffer,
    DWORD           cbBuf,
    LPDWORD         pcbNeeded)
{
    // Figure out how many bytes of buffer space we're going to need.
    // Set error code and return failure if we don't have enough.
    //
    *pcbNeeded = _ppinfo_calc_level2(g_szEmptyString, pSrcInfo);

    if (*pcbNeeded > cbBuf) {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }

    //
    // Copy the required data to the Win 32 PRINTER_INFO_2 structure.
    //
    _ppinfo_build_level2(g_szEmptyString,
                         pSrcInfo,
                         (PPRINTER_INFO_2)lpbBuffer,
                         ENDOFBUFFER(lpbBuffer, cbBuf));

    return TRUE;
}


#if WINNT32
/*****************************************************************************\
* _ppinfo_get_level4 (Local Routine)
*
* Given pInfo, a block of information on a printer returned by a
* PrintQGetInfo call, fill a PRINTER_INFO_4 structure.  Returns
* TRUE if successful, FALSE otherwise. Places the number of bytes of
* (lpbBuffer) used in the DWORD pointed to by (pcbNeeded).
*
\*****************************************************************************/
BOOL _ppinfo_get_level4(
    PPRINTER_INFO_2 pSrcInfo,
    LPBYTE          lpbBuffer,
    DWORD           cbBuf,
    LPDWORD         pcbNeeded)
{
    // Figure out how many bytes of buffer space we're going to need.
    // Set error code and return failure if we don't have enough.
    //
    *pcbNeeded = _ppinfo_calc_level4(pSrcInfo);

    if (*pcbNeeded > cbBuf) {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }

    //
    // Copy the required data to the Win 32 PRINTER_INFO_2 structure.
    //
    _ppinfo_build_level4(pSrcInfo,
                         (PPRINTER_INFO_4)lpbBuffer,
                         ENDOFBUFFER(lpbBuffer, cbBuf));

    return TRUE;
}
#endif


/*****************************************************************************\
* _ppinfo_get_level5 (Local Routine)
*
* Given pInfo, a block of information on a printer returned by a
* PrintQGetInfo call, fill a PRINTER_INFO_5 structure.  Returns
* TRUE if successful, FALSE otherwise. Places the number of bytes of
* (lpbBuffer) used in the DWORD pointed to by (pcbNeeded).
*
\*****************************************************************************/
BOOL _ppinfo_get_level5(
    PPRINTER_INFO_2 pSrcInfo,
    LPBYTE          lpbBuffer,
    DWORD           cbBuf,
    LPDWORD         pcbNeeded)
{
    // Figure out how many bytes of buffer space we're going to need.
    // Set error code and return failure if we don't have enough.
    //
    *pcbNeeded = _ppinfo_calc_level5(pSrcInfo);

    if (*pcbNeeded > cbBuf) {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }

    //
    // Copy the required data to the Win 32 PRINTER_INFO_2 structure.
    //
    _ppinfo_build_level5(pSrcInfo,
                         (PPRINTER_INFO_5)lpbBuffer,
                         ENDOFBUFFER(lpbBuffer, cbBuf));

    return TRUE;
}


#if WINNT32
/*****************************************************************************\
* _ppinfo_enumprinters_NT (Local Routine)
*
* This is the WinNT specific routine for EnumPrinters.
*
*
\*****************************************************************************/
BOOL _ppinfo_enumprinters(
    DWORD   dwType,
    LPTSTR  pszName,
    DWORD   dwLevel,
    LPBYTE  pPrinterEnum,
    DWORD   cbBuf,
    LPDWORD pcbNeeded,
    LPDWORD pcbReturned)
{
    BOOL bReturn = FALSE;


    // Throw back enumeration requests that we don't handle. The routing
    // layer above us is specifically looking for the ERROR_INVALID_NAME.
    //
    if (dwType & PRINTER_ENUM_NOTFORUS)
        goto enum_name_failure;


    // If the request is one that we handle, but the caller didn't supply
    // a printer name, we'll fail. Again, to keep things going as the
    // router expects, we must return an ERROR_INVALID_NAME condition.
    //
    if (utlStrSize(pszName) == 0) {

        if ((dwLevel == PRINT_LEVEL_1) && (dwType & PRINTER_ENUM_NAME)) {

            return _ppinfo_describe_provider((LPPRINTER_INFO_1)pPrinterEnum,
                                             cbBuf,
                                             pcbNeeded,
                                             pcbReturned);

        } else {

            goto enum_name_failure;
        }

    } else {

        if ((dwLevel == PRINT_LEVEL_1) && (dwType & PRINTER_ENUM_NAME)) {

            // In this case, the user has asked us to enumerate the
            // printers in some domain. Until we decide what we really want
            // to do.  We'll simply return success with an empty enumeration.
            //

            goto enum_empty_success;
        }
    }


    // Check Remote enumeration.  Remote enumeration valid only if
    // it's a level-1 printer.
    //
    if (dwType & PRINTER_ENUM_REMOTE) {

        if (dwLevel != PRINT_LEVEL_1) {

            goto enum_level_failure;

        } else {

            // In this case, the user has asked us to enumerate the
            // printers in our domain. Until we decide what we really
            // want to do, we'll simply return success with an empty
            // enumeration.
            //
            goto enum_empty_success;
        }

    } else if (dwType & PRINTER_ENUM_CONNECTIONS) {

        // In this case, the user has asked us to enumerate our favorite
        // connections.
        //

enum_empty_success:

        *pcbNeeded   = 0;
        *pcbReturned = 0;

        return TRUE;
    }


    DBG_MSG(DBG_LEV_INFO, (TEXT("Info: PPEnumPrinters: Type(%ld)  Name(%s)  Level(%ld)"), dwType, pszName, dwLevel));


    // Check print-levels.  These are error cases.  We should
    // really have performed the enumeration above.
    //
    switch (dwLevel) {

    case PRINT_LEVEL_1:
    case PRINT_LEVEL_2:

enum_name_failure:

        DBG_MSG(DBG_LEV_WARN, (TEXT("Warn: PPEnumPrinters: Invalid Name")));
        SetLastError(ERROR_INVALID_NAME);
        break;

    default:

enum_level_failure:

        DBG_MSG(DBG_LEV_WARN, (TEXT("Warn: PPEnumPrinters: Invalid Level: %d"), dwLevel));
        SetLastError(ERROR_INVALID_LEVEL);
        break;
    }

    return FALSE;
}

#else

/*****************************************************************************\
* _ppinfo_enumprinters_95 (Local Routine)
*
* This is the Win95 specific routine for EnumPrinters.
*
*
\*****************************************************************************/
BOOL _ppinfo_enumprinters(
    DWORD   dwType,
    LPTSTR  pszName,
    DWORD   dwLevel,
    LPBYTE  pPrinterEnum,
    DWORD   cbBuf,
    LPDWORD pcbNeeded,
    LPDWORD pcbReturned)
{
    BOOL bReturn = FALSE;

    // Throw back enumeration requests that we don't handle. The routing
    // layer above us is specifically looking for the ERROR_INVALID_NAME.
    //
    if (dwType & PRINTER_ENUM_NOTFORUS)
        goto enum_name_failure;


    // If the request is one that we handle, but the caller didn't supply
    // a printer name, we'll fail. Again, to keep things going as the
    // router expects, we must return an ERROR_INVALID_NAME condition.
    //
    if (utlStrSize(pszName) == 0) {

        if ((dwLevel == PRINT_LEVEL_1) && (dwType & PRINTER_ENUM_NAME)) {

            return _ppinfo_describe_provider((LPPRINTER_INFO_1)pPrinterEnum,
                                             cbBuf,
                                             pcbNeeded,
                                             pcbReturned);

        } else if (dwType & PRINTER_ENUM_REMOTE) {

            // In this case, the user has asked us to enumerate the printers
            // in our domain. Until we decide what we really want to do, we'll
            // simply return success with an empty enumeration.
            //
            *pcbNeeded   = 0;
            *pcbReturned = 0;

            return TRUE;

        } else {

            goto enum_name_failure;
        }
    }

    DBG_MSG(DBG_LEV_INFO, (TEXT("Info: PPEnumPrinters: Type(%ld)  Name(%s)  Level(%ld)"), dwType, pszName, dwLevel));


    // One last special case to test for -- did they ask us to
    // enumerate ourselves (the provider) by name?
    //
    if ((dwLevel == PRINT_LEVEL_1) && (dwType & PRINTER_ENUM_NAME)) {

        if (lstrcmp(pszName, g_szProviderName) == 0) {

            return _ppinfo_describe_provider((LPPRINTER_INFO_1)pPrinterEnum,
                                             cbBuf,
                                             pcbNeeded,
                                             pcbReturned);
        }
    }


    // Check print-levels.  These are error cases.  We should
    // really have performed the enumeration above.
    //
    switch (dwLevel) {

    case PRINT_LEVEL_1:
    case PRINT_LEVEL_2:

enum_name_failure:

        DBG_MSG(DBG_LEV_WARN, (TEXT("Warn: PPEnumPrinters: Invalid Name")));
        SetLastError(ERROR_INVALID_NAME);
        break;

    default:

        DBG_MSG(DBG_LEV_WARN, (TEXT("Warn: PPEnumPrinters: Invalid Level: %d"), dwLevel));
        SetLastError(ERROR_INVALID_LEVEL);
        break;
    }

    return FALSE;
}

#endif


/*****************************************************************************\
* PPEnumPrinters
*
* Enumerates the available printers.  Returns TRUE if successful.  Otherwise,
* it returns FALSE.
*
* NOTE: Supports level 2 PRINTER_INFO to provide Point-and-Print
*       functionality.
*
\*****************************************************************************/
BOOL PPEnumPrinters(
    DWORD   dwType,
    LPTSTR  pszName,
    DWORD   dwLevel,
    LPBYTE  pPrinterEnum,
    DWORD   cbBuf,
    LPDWORD pcbNeeded,
    LPDWORD pcbReturned)
{
    DBG_MSG(DBG_LEV_CALLTREE, (TEXT("Call: PPEnumPrinters: Type(%d) Level(%d) Name(%s)"), dwType, dwLevel, (pszName ? pszName : TEXT("<NULL>"))));

    return _ppinfo_enumprinters(dwType,
                                pszName,
                                dwLevel,
                                pPrinterEnum,
                                cbBuf,
                                pcbNeeded,
                                pcbReturned);
}


/*****************************************************************************\
* PPGetPrinter
*
* Retrieves information about a printer. Returns TRUE if successful, FALSE
* if an error occurred. NOTE: Supports level 2 Printer_INFO to provide
* Point and Print functionality for Chicago.
*
\*****************************************************************************/
BOOL PPGetPrinter(
    HANDLE  hPrinter,
    DWORD   dwLevel,
    LPBYTE  lpbPrinter,
    DWORD   cbBuf,
    LPDWORD pcbNeeded)
{
    PCINETMONPORT   pIniPort;
    PPRINTER_INFO_2 pSrcInfo;
    DWORD           cbSrcSize;
    DWORD           dwTemp;
    BOOL            bResult = FALSE;

    DBG_MSG(DBG_LEV_CALLTREE, (TEXT("Call: PPGetPrinter: Printer(%08lX) Level(%ld)"), hPrinter, dwLevel));

    if (pcbNeeded)
        *pcbNeeded = 0;

    semEnterCrit();

    // Make sure we have a valid printer handle.
    //
    if (pIniPort = utlValidatePrinterHandle(hPrinter)) {

        if (pIniPort->BeginReadGetPrinterCache (&pSrcInfo)) {

            // Reformat the data according to the requested info Level.
            //
            switch (dwLevel) {

            case PRINT_LEVEL_1:
                bResult = _ppinfo_get_level1(pSrcInfo, lpbPrinter, cbBuf, pcbNeeded);
                break;

            case PRINT_LEVEL_2:
                bResult = _ppinfo_get_level2(pSrcInfo, lpbPrinter, cbBuf, pcbNeeded);
                break;

#if WINNT32
            case PRINT_LEVEL_4:
                bResult = _ppinfo_get_level4(pSrcInfo, lpbPrinter, cbBuf, pcbNeeded);
                break;
#endif

            case PRINT_LEVEL_5:
                bResult = _ppinfo_get_level5(pSrcInfo, lpbPrinter, cbBuf, pcbNeeded);
                break;

            default:
                DBG_MSG(DBG_LEV_WARN, (TEXT("Warn: PPGetPrinter: Invalid Level")));
                SetLastError(ERROR_INVALID_LEVEL);
                bResult = FALSE;
                break;
            }


        }

        pIniPort->EndReadGetPrinterCache ();

        if (GetLastError() == ERROR_ACCESS_DENIED) {
            pIniPort->InvalidateGetPrinterCache ();
        }
    }

    if (GetLastError() == ERROR_INSUFFICIENT_BUFFER &&
        pcbNeeded &&
        *pcbNeeded == 0) {
        // We can't set ERROR_INSUFFICIENT_BUFFER here since it was an internal error
        // and we are not reporting a size
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    }


    semLeaveCrit();

    return bResult;
}