开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 打印编程 > 查看源码
util.c
资源名称：PopFaxPrinter_src_v2.01.zip　[点击查看]
上传用户：looem2003
上传日期：2014-07-20
资源大小：13733k
文件大小：26k
源码类别：

打印编程

开发平台：

Visual C++

util.c：源码内容
  1. /*++
  3. Copyright (c) 1990-2003 Microsoft Corporation
  4. All Rights Reserved
  6. Module Name:
  8.     util.c
  10. --*/
  12. #include "precomp.h"
  13. #pragma hdrstop
  16. #pragma prefast (suppress : __WARNING_INCORRECT_ANNOTATION_STRING, "The Pointer is part of an Array. This is the only way to annotate it")
  17. #pragma prefast (suppress : __WARNING_INCORRECT_ANNOTATION, "The Pointer is part of an Array. This is the only way to annotate it")
  19. extern PMONITORINIT g_pMonitorInit;
  20. extern WCHAR g_szPortsList[];
  21. extern WCHAR g_szPortsKey[];
  23. //
  24. // These globals are needed so that AddPort can call
  25. // SPOOLSS!EnumPorts to see whether the port to be added
  26. // already exists.
  28. typedef BOOL
  29. (WINAPI *FnEnumPortsW)(
  30.     LPWSTR   pName,
  31.     DWORD    Level,
  32.     LPBYTE   pPort,
  33.     DWORD    cbBuf,
  34.     LPDWORD  pcbNeeded,
  35.     LPDWORD  pcReturned
  36.     );
  38. HMODULE hSpoolssDll = NULL;
  39. FnEnumPortsW pfnSpoolssEnumPorts = NULL;
  41. VOID
  42. LcmRemoveColon(
  43.     __inout LPWSTR  pName
  44.     )
  45. {
  46.     DWORD   Length;
  48.     Length = wcslen(pName);
  50.     if (pName[Length-1] == L':')
  51.         pName[Length-1] = 0;
  52. }
  55. BOOL
  56. IsCOMPort(
  57.     __in    LPWSTR pPort
  58. )
  59. {
  60.     //
  61.     // Must begin with szLcmCOM
  62.     //
  63.     if ( _wcsnicmp( pPort, szLcmCOM, 3 ) )
  64.     {
  65.         return FALSE;
  66.     }
  68.     //
  69.     // wcslen guarenteed >= 3
  70.     //
  71.     return pPort[ wcslen( pPort ) - 1 ] == L':';
  72. }
  74. BOOL
  75. IsLPTPort(
  76.     __in    LPWSTR pPort
  77. )
  78. {
  79.     //
  80.     // Must begin with szLcmLPT
  81.     //
  82.     if ( _wcsnicmp( pPort, szLcmLPT, 3 ) )
  83.     {
  84.         return FALSE;
  85.     }
  87.     //
  88.     // wcslen guarenteed >= 3
  89.     //
  90.     return pPort[ wcslen( pPort ) - 1 ] == L':';
  91. }
  93. BOOL
  94. GetIniCommValues(
  95.     __in LPWSTR          pName,
  96.          LPDCB          pdcb,
  97.          LPCOMMTIMEOUTS pcto
  98. )
  99. {
  100.     BOOL    bRet = TRUE;
  101.     LPWSTR  pszEntry = NULL;
  103.     if (bRet)
  104.     {
  105.         bRet = GetIniCommValuesFromRegistry (pName, &pszEntry);
  106.     }
  107.     if (bRet)
  108.     {
  109.         bRet =  BuildCommDCB (pszEntry, pdcb);
  110.     }
  111.     if (bRet)
  112.     {
  113.         GetTransmissionRetryTimeoutFromRegistry (&pcto-> WriteTotalTimeoutConstant);
  114.         pcto->WriteTotalTimeoutConstant*=1000;
  115.     }
  116.     FreeSplMem(pszEntry);
  117.     return bRet;
  118. }
  120. HMODULE
  121. LoadSystemLibrary (
  122.     __in    LPCWSTR szDllName
  123.     )
  124. {
  125.     HMODULE hModule = NULL;
  126.     WCHAR szFullDllName [MAX_PATH] = L"";
  128.     if (GetSystemDirectory (szFullDllName, COUNTOF (szFullDllName)) &&
  129.         StringCchCat (szFullDllName, COUNTOF (szFullDllName), L"\") == S_OK &&
  130.         StringCchCat (szFullDllName, COUNTOF (szFullDllName), szDllName) == S_OK)
  131.     {
  132.         hModule = LoadLibrary (szFullDllName);
  133.     }
  135.     return hModule;
  136. }
  138. /* PortExists
  139.  *
  140.  * Calls EnumPorts to check whether the port name already exists.
  141.  * This asks every monitor, rather than just this one.
  142.  * The function will return TRUE if the specified port is in the list.
  143.  * If an error occurs, the return is FALSE and the variable pointed
  144.  * to by pError contains the return from GetLastError().
  145.  * The caller must therefore always check that *pError == NO_ERROR.
  146.  */
  147. BOOL
  148. PortExists(
  149.     __in_opt LPWSTR pName,
  150.     __in     LPWSTR pPortName,
  151.     __out    PDWORD pError
  152. )
  153. {
  154.     DWORD cbNeeded;
  155.     DWORD cReturned;
  156.     DWORD cbPorts;
  157.     LPPORT_INFO_1 pPorts;
  158.     DWORD i;
  159.     BOOL  Found = TRUE;
  161.     *pError = NO_ERROR;
  163.     if (!hSpoolssDll) {
  165.         hSpoolssDll = LoadSystemLibrary (L"SPOOLSS.DLL");
  167.         if (hSpoolssDll) {
  168.             pfnSpoolssEnumPorts = (FnEnumPortsW)GetProcAddress(hSpoolssDll,
  169.                                                  "EnumPortsW");
  170.             if (!pfnSpoolssEnumPorts) {
  172.                 *pError = GetLastError();
  173.                 FreeLibrary(hSpoolssDll);
  174.                 hSpoolssDll = NULL;
  175.             }
  177.         } else {
  179.             *pError = GetLastError();
  180.         }
  181.     }
  183.     if (!pfnSpoolssEnumPorts)
  184.         return FALSE;
  187.     if (!(*pfnSpoolssEnumPorts)(pName, 1, NULL, 0, &cbNeeded, &cReturned))
  188.     {
  189.         if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
  190.         {
  191.             cbPorts = cbNeeded;
  193.             pPorts = (LPPORT_INFO_1)AllocSplMem(cbPorts);
  195.             if (pPorts)
  196.             {
  197.                 if ((*pfnSpoolssEnumPorts)(pName, 1, (LPBYTE)pPorts, cbPorts,
  198.                                            &cbNeeded, &cReturned))
  199.                 {
  200.                     Found = FALSE;
  202.                     for (i = 0; i < cReturned; i++)
  203.                     {
  204.                         if (!lstrcmpi(pPorts[i].pName, pPortName))
  205.                             Found = TRUE;
  206.                     }
  207.                 }
  208.             }
  210.             FreeSplMem(pPorts);
  211.         }
  212.     }
  214.     else
  215.         Found = FALSE;
  218.     return Found;
  219. }
  222. VOID
  223. LcmSplInSem(
  224.    VOID
  225. )
  226. {
  227.     if (LcmSpoolerSection.OwningThread != (HANDLE) UIntToPtr(GetCurrentThreadId())) {
  228.         DBG_MSG(DBG_ERROR, ("Not in spooler semaphoren"));
  229.     }
  230. }
  232. VOID
  233. LcmSplOutSem(
  234.    VOID
  235. )
  236. {
  237.     if (LcmSpoolerSection.OwningThread == (HANDLE) UIntToPtr(GetCurrentThreadId())) {
  238.         DBG_MSG(DBG_ERROR, ("Inside spooler semaphore !!n"));
  239.     }
  240. }
  242. VOID
  243. LcmEnterSplSem(
  244.    VOID
  245. )
  246. {
  247.     EnterCriticalSection(&LcmSpoolerSection);
  248. }
  250. VOID
  251. LcmLeaveSplSem(
  252.    VOID
  253. )
  254. {
  255. #if DBG
  256.     LcmSplInSem();
  257. #endif
  258.     LeaveCriticalSection(&LcmSpoolerSection);
  259. }
  261. PINIENTRY
  262. LcmFindName(
  263.    __in PINIENTRY pIniKey,
  264.    __in LPWSTR pName
  265. )
  266. {
  267.     if (pName) {
  268.         while (pIniKey) {
  270.             if (!lstrcmpi(pIniKey->pName, pName)) {
  271.                 return pIniKey;
  272.             }
  274.             pIniKey=pIniKey->pNext;
  275.         }
  276.     }
  278.     return FALSE;
  279. }
  281. PINIENTRY
  282. LcmFindIniKey(
  283.    __in PINIENTRY pIniEntry,
  284.    __in LPWSTR pName
  285. )
  286. {
  287.    if (!pName)
  288.       return NULL;
  290.    LcmSplInSem();
  292.    while (pIniEntry && lstrcmpi(pName, pIniEntry->pName))
  293.       pIniEntry = pIniEntry->pNext;
  295.    return pIniEntry;
  296. }
  298. LPBYTE
  299. LcmPackStrings(
  300.    __in     LPWSTR *pSource,
  301.    __out    LPBYTE pDest,
  302.    __inout  DWORD *DestOffsets,
  303.    __inout  LPBYTE pEnd
  304. )
  305. {
  306.    while (*DestOffsets != -1) {
  307.       if (*pSource) {
  308.           size_t cbString = wcslen(*pSource)*sizeof(WCHAR) + sizeof(WCHAR);
  309.          pEnd-= cbString;
  310.          (VOID) StringCbCopy ((LPWSTR) pEnd, cbString, *pSource);
  311.          *(LPWSTR UNALIGNED *)(pDest+*DestOffsets)= (LPWSTR) pEnd;
  312.       } else
  313.          *(LPWSTR UNALIGNED *)(pDest+*DestOffsets)=0;
  314.       pSource++;
  315.       DestOffsets++;
  316.    }
  318.    return pEnd;
  319. }
  322. /* LcmMessage
  323.  *
  324.  * Displays a LcmMessage by loading the strings whose IDs are passed into
  325.  * the function, and substituting the supplied variable argument list
  326.  * using the varargs macros.
  327.  *
  328.  */
  329. int
  330. LcmMessage(
  331.     HWND hwnd,
  332.     DWORD Type,
  333.     int CaptionID,
  334.     int TextID,
  335.     ...
  336.     )
  337. {
  338.     WCHAR   MsgText[256];
  339.     WCHAR   MsgFormat[256];
  340.     WCHAR   MsgCaption[40];
  341.     va_list vargs;
  343.     if( ( LoadString( LcmhInst, TextID, MsgFormat,
  344.                       sizeof MsgFormat / sizeof *MsgFormat ) > 0 )
  345.      && ( LoadString( LcmhInst, CaptionID, MsgCaption,
  346.                       sizeof MsgCaption / sizeof *MsgCaption ) > 0 ) )
  347.     {
  348.         va_start( vargs, TextID );
  349.         (VOID) StringCchVPrintf (MsgText, COUNTOF (MsgText), MsgFormat, vargs );
  350.         va_end( vargs );
  352.         return MessageBox(hwnd, MsgText, MsgCaption, Type);
  353.     }
  354.     else
  355.         return 0;
  356. }
  359. /*
  360.  *
  361.  */
  362. LPTSTR
  363. LcmGetErrorString(
  364.     DWORD   Error
  365. )
  366. {
  367.     TCHAR   Buffer[1024];
  368.     LPTSTR  pErrorString = NULL;
  370.     if( FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM,
  371.                        NULL, Error, 0, Buffer,
  372.                        COUNTOF(Buffer), NULL )
  373.       == 0 )
  375.         LoadString( LcmhInst, IDS_UNKNOWN_ERROR,
  376.                     Buffer, COUNTOF(Buffer) );
  378.     pErrorString = AllocSplStr(Buffer);
  380.     return pErrorString;
  381. }
  383. DWORD
  384. ReportError(
  385.     HWND  hwndParent,
  386.     DWORD idTitle,
  387.     DWORD idDefaultError
  388.     )
  389. {
  390.     DWORD  ErrorID;
  391.     DWORD  MsgType;
  392.     LPTSTR pErrorString;
  394.     ErrorID = GetLastError( );
  396.     if( ErrorID == ERROR_ACCESS_DENIED )
  397.         MsgType = MSG_INFORMATION;
  398.     else
  399.         MsgType = MSG_ERROR;
  402.     pErrorString = LcmGetErrorString( ErrorID );
  404.     LcmMessage( hwndParent, MsgType, idTitle,
  405.              idDefaultError, pErrorString );
  407.     FreeSplStr( pErrorString );
  410.     return ErrorID;
  411. }
  413. DWORD
  414. WINAPIV
  415. StrNCatBuffW(
  416.     __out_ecount(cchBuffer) PWSTR       pszBuffer,
  417.     UINT        cchBuffer,
  418.     ...
  419.     )
  420. /*++
  422. Description:
  424.     This routine concatenates a set of null terminated strings
  425.     into the provided buffer.  The last argument must be a NULL
  426.     to signify the end of the argument list.  This only called
  427.         from LocalMon by functions that use WCHARS.
  429. Arguments:
  431.     pszBuffer  - pointer buffer where to place the concatenated
  432.                  string.
  433.     cchBuffer  - character count of the provided buffer including
  434.                  the null terminator.
  435.     ...        - variable number of string to concatenate.
  437. Returns:
  439.     ERROR_SUCCESS if new concatenated string is returned,
  440.     or ERROR_XXX if an error occurred.
  442. Notes:
  444.     The caller must pass valid strings as arguments to this routine,
  445.     if an integer or other parameter is passed the routine will either
  446.     crash or fail abnormally.  Since this is an internal routine
  447.     we are not in try except block for performance reasons.
  449. --*/
  450. {
  451.     DWORD   dwRetval    = ERROR_INVALID_PARAMETER;
  452.     PCWSTR  pszTemp     = NULL;
  453.     PWSTR   pszDest     = NULL;
  454.     va_list pArgs;
  456.     //
  457.     // Validate the pointer where to return the buffer.
  458.     //
  459.     if (pszBuffer && cchBuffer)
  460.     {
  461.         //
  462.         // Assume success.
  463.         //
  464.         dwRetval = ERROR_SUCCESS;
  466.         //
  467.         // Get pointer to argument frame.
  468.         //
  469.         va_start(pArgs, cchBuffer);
  471.         //
  472.         // Get temp destination pointer.
  473.         //
  474.         pszDest = pszBuffer;
  476.         //
  477.         // Insure we have space for the null terminator.
  478.         //
  479.         cchBuffer--;
  481.         //
  482.         // Collect all the arguments.
  483.         //
  484.         for ( ; ; )
  485.         {
  486.             //
  487.             // Get pointer to the next argument.
  488.             //
  489.             pszTemp = va_arg(pArgs, PCWSTR);
  491.             if (!pszTemp)
  492.             {
  493.                 break;
  494.             }
  496.             //
  497.             // Copy the data into the destination buffer.
  498.             //
  499.             for ( ; cchBuffer; cchBuffer-- )
  500.             {
  501.                 if (!(*pszDest = *pszTemp))
  502.                 {
  503.                     break;
  504.                 }
  506.                 pszDest++, pszTemp++;
  507.             }
  509.             //
  510.             // If were unable to write all the strings to the buffer,
  511.             // set the error code and nuke the incomplete copied strings.
  512.             //
  513.             if (!cchBuffer && pszTemp && *pszTemp)
  514.             {
  515.                 dwRetval = ERROR_BUFFER_OVERFLOW;
  516.                 *pszBuffer = L'';
  517.                 break;
  518.             }
  519.         }
  521.         //
  522.         // Terminate the buffer always.
  523.         //
  524.         *pszDest = L'';
  526.         va_end(pArgs);
  527.     }
  529.     //
  530.     // Set the last error in case the caller forgets to.
  531.     //
  532.     if (dwRetval != ERROR_SUCCESS)
  533.     {
  534.         SetLastError(dwRetval);
  535.     }
  537.     return dwRetval;
  539. }
  541. /* PortIsValid
  542.  *
  543.  * Validate the port by attempting to create/open it.
  544.  */
  545. BOOL
  546. PortIsValid(
  547.     __in    LPWSTR pPortName
  548. )
  549. {
  550.     HANDLE hFile;
  551.     BOOL   Valid = FALSE;
  552.     LPWSTR pAdjustedName = NULL;
  554.     //
  555.     // For COM and LPT ports, no verification
  556.     //
  557.     if ( IS_COM_PORT( pPortName ) ||
  558.         IS_LPT_PORT( pPortName ) ||
  559.         IS_FILE_PORT( pPortName ) ||
  560.         IS_POPFAX_PORT( pPortName ) )
  561.     {
  562.         return TRUE;
  563.     }
  565.     pAdjustedName = AdjustFileName( pPortName);
  567.     if (pAdjustedName)
  568.     {
  569.         hFile = CreateFile(pAdjustedName,
  570.                            GENERIC_WRITE,
  571.                            FILE_SHARE_READ,
  572.                            NULL,
  573.                            OPEN_EXISTING,
  574.                            FILE_ATTRIBUTE_NORMAL,
  575.                            NULL);
  577.         if (hFile == INVALID_HANDLE_VALUE) {
  578.             hFile = CreateFile(pAdjustedName,
  579.                                GENERIC_WRITE,
  580.                                FILE_SHARE_READ,
  581.                                NULL,
  582.                                OPEN_ALWAYS,
  583.                                FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE,
  584.                                NULL);
  585.         }
  587.         if (hFile != INVALID_HANDLE_VALUE) {
  588.             CloseHandle(hFile);
  589.             Valid = TRUE;
  590.         } else {
  591.             Valid = FALSE;
  592.         }
  594.         FreeSplMem(pAdjustedName);
  595.     }
  596.     else
  597.     {
  598.         SetLastError(ERROR_FILE_NOT_FOUND);
  599.     }
  601.     return Valid;
  602. }
  604. BOOL
  605. GetIniCommValuesFromRegistry (
  606.     __in        LPCWSTR     pszPortName,
  607.     __deref_out LPWSTR*     ppszCommValues
  608.     )
  609. /*++
  611. Description:
  612.     This function returns the communication parameters from the Registry
  613.     of the specified port in the format: "921600,8,n,1.5,x"
  615. Arguments:
  616.     pszPortName     - [in]  the name of the specific port
  617.     ppszCommValues  - [out] address of the pointer that will point to the string
  618.                             Note, if the function succeeds the caller is responsible for memory deletion by calling FreeSplMem.
  620. Returns:
  621.     Win32 error code
  622.     Note, if not ERROR_SUCCESS the output parameter stays unchanged.
  624. --*/
  625. {
  626.     LPWSTR pszCommValues = NULL;
  627.     DWORD  dwStatus       = ERROR_SUCCESS;
  628.     DWORD  cbData         = 64,
  629.            dwBlockSize;
  630.     HKEY   hPorts = NULL;
  632.     //
  633.     // open the registry key
  634.     //
  635.     dwStatus = g_pMonitorInit->pMonitorReg->fpCreateKey(g_pMonitorInit->hckRegistryRoot, 
  636.                                                         g_szPortsKey, 
  637.                                                         REG_OPTION_NON_VOLATILE,
  638.                                                         KEY_QUERY_VALUE,
  639.                                                         NULL,
  640.                                                         &hPorts, 
  641.                                                         NULL,
  642.                                                         g_pMonitorInit->hSpooler);
  644.     //
  645.     // allocate the initial memory based on COM ports: "921600,8,n,1.5,x" with some extra space
  646.     //
  647.     if (dwStatus == ERROR_SUCCESS)
  648.     {
  649.         dwStatus = (pszCommValues = (PWSTR)AllocSplMem (cbData + sizeof(WCHAR))) ? ERROR_SUCCESS : ERROR_OUTOFMEMORY;
  650.     }
  651.     
  652.     //
  653.     // get the string size
  654.     //
  655.     if (dwStatus == ERROR_SUCCESS)
  656.     {
  657.         DWORD dwType = 0;
  658.         dwBlockSize = cbData;
  659.         pszCommValues[cbData / sizeof(WCHAR)] = UNICODE_NULL;
  661.         dwStatus = g_pMonitorInit->pMonitorReg->fpQueryValue(hPorts, 
  662.                                                              pszPortName, 
  663.                                                              &dwType, 
  664.                                                              (BYTE*)pszCommValues, 
  665.                                                              &cbData,
  666.                                                              g_pMonitorInit->hSpooler);
  667.         //
  668.         // check the result
  669.         //
  670.         if (dwStatus == ERROR_MORE_DATA)
  671.         {
  672.             dwStatus = ERROR_SUCCESS;
  673.             //
  674.             // release the buffer
  675.             //
  676.             FreeSplMem (pszCommValues);
  677.             //
  678.             // allocate precise amount of memory
  679.             //
  680.             if (dwStatus == ERROR_SUCCESS)
  681.             {
  682.                 dwStatus = (pszCommValues = (PWSTR)AllocSplMem (cbData + sizeof(WCHAR))) ? ERROR_SUCCESS : ERROR_OUTOFMEMORY;
  683.             }
  684.             //
  685.             // get data again
  686.             //
  687.             if (dwStatus == ERROR_SUCCESS)
  688.             {
  689.                 dwBlockSize = cbData;
  690.                 pszCommValues[cbData / sizeof(WCHAR)] = UNICODE_NULL;
  691.                 dwStatus = g_pMonitorInit->pMonitorReg->fpQueryValue(hPorts, 
  692.                                                                      pszPortName, 
  693.                                                                      &dwType, 
  694.                                                                      (BYTE*)pszCommValues, 
  695.                                                                      &cbData,
  696.                                                                      g_pMonitorInit->hSpooler);
  697.                 if (dwStatus == ERROR_SUCCESS && dwType != REG_SZ)
  698.                 {
  699.                     //
  700.                     // unexpected data type
  701.                     //
  702.                     dwStatus = ERROR_INVALID_DATA;
  703.                 }
  704.             }
  705.         }
  706.         else if (dwStatus == ERROR_SUCCESS && dwType != REG_SZ)
  707.         {
  708.             //
  709.             // unexpected data type
  710.             //
  711.             dwStatus = ERROR_INVALID_DATA;
  712.         }
  713.     }
  714.     //
  715.     // update output parameter
  716.     //
  717.     if (dwStatus == ERROR_SUCCESS)
  718.     {
  719.         // Add a NULL terminator because RegQueryValueEx does not guarantee it
  720.         DWORD dwNullIndex = (dwBlockSize/2)-1;
  721.         pszCommValues[dwNullIndex] = 0x00;
  722.         *ppszCommValues = pszCommValues;
  723.         pszCommValues   = NULL;
  724.     }
  725.     //
  726.     // cleanup
  727.     //
  728.     if (pszCommValues)
  729.     {
  730.         FreeSplMem (pszCommValues);
  731.     }
  733.     if (hPorts)
  734.     {
  735.         RegCloseKey (hPorts);
  736.     }
  738.     return dwStatus == ERROR_SUCCESS;
  739. }
  741. VOID
  742. GetTransmissionRetryTimeoutFromRegistry (
  743.     __out DWORD*      pdwTimeout
  744.     )
  745. /*++
  747. Description:
  748.     This function returns the timeout value stored in Registry at
  749.     HKLMSoftwareMicrosoftWindows NTCurrentVersionWindows:TransmissionRetryTimeout
  751. Arguments:
  752.     pdwTimeout  - [out] pointer to DWORD that will receive the timeout value
  754. Returns:
  755.     Win32 error code;
  756.     Note, if not ERROR_SUCCESS the output parameter stays unchanged.
  758. --*/
  759. {
  760.     extern WCHAR gszWindows [];
  761.     DWORD  dwStatus     = ERROR_SUCCESS;
  762.     LPWSTR pszTimeout   = NULL;
  763.     DWORD  dwTimeout    = 0;
  764.     DWORD  cbData       = 10,
  765.            dwBlockSize;
  766.     HKEY   hWindows     = NULL;
  768.     //
  769.     // open the registry key
  770.     //
  771.     if (dwStatus == ERROR_SUCCESS)
  772.     {
  773.         dwStatus = RegOpenKeyEx (HKEY_LOCAL_MACHINE, gszWindows, 0, KEY_QUERY_VALUE, &hWindows);
  774.     }
  775.     //
  776.     // allocate the initial memory for timeout string
  777.     // this is a timeout period in seconds with initial value of 90
  778.     // it shouldn't be larger then four digits (four WCHARs)
  779.     //
  780.     if (dwStatus == ERROR_SUCCESS)
  781.     {
  782.         dwStatus = (pszTimeout = (PWSTR)AllocSplMem (cbData + sizeof(WCHAR))) ? ERROR_SUCCESS : ERROR_OUTOFMEMORY;
  783.     }
  784.     //
  785.     // get data
  786.     //
  787.     if (dwStatus == ERROR_SUCCESS)
  788.     {
  789.         DWORD dwType = 0;
  790.         dwBlockSize = cbData;
  791.         pszTimeout[cbData / sizeof(WCHAR)] = UNICODE_NULL;
  792.         dwStatus = RegQueryValueEx (hWindows, szINIKey_TransmissionRetryTimeout, 0, &dwType, (BYTE*)pszTimeout, &cbData);
  793.         //
  794.         // check the result
  795.         //
  796.         if (dwStatus == ERROR_MORE_DATA)
  797.         {
  798.             dwStatus = ERROR_SUCCESS;
  799.             //
  800.             // release the buffer
  801.             //
  802.             FreeSplMem (pszTimeout);
  803.             //
  804.             // allocate precise amount of memory
  805.             //
  806.             if (dwStatus == ERROR_SUCCESS)
  807.             {
  808.                 dwStatus = (pszTimeout = (PWSTR)AllocSplMem (cbData + sizeof(WCHAR)))? ERROR_SUCCESS : ERROR_OUTOFMEMORY;
  809.             }
  810.             //
  811.             // get data again
  812.             //
  813.             if (dwStatus == ERROR_SUCCESS)
  814.             {
  815.                 dwBlockSize = cbData;
  816.                 pszTimeout[cbData / sizeof(WCHAR)] = UNICODE_NULL;
  817.                 dwStatus = RegQueryValueEx (hWindows, szINIKey_TransmissionRetryTimeout, 0, &dwType, (BYTE*)pszTimeout, &cbData);
  818.                 if (dwStatus == ERROR_SUCCESS && dwType != REG_SZ)
  819.                 {
  820.                     //
  821.                     // unexpected data type
  822.                     //
  823.                     dwStatus = ERROR_INVALID_DATA;
  824.                 }
  825.             }
  826.         }
  827.         else if (dwStatus == ERROR_SUCCESS && dwType != REG_SZ)
  828.         {
  829.             //
  830.             // unexpected data type
  831.             //
  832.             dwStatus = ERROR_INVALID_DATA;
  833.         }
  834.     }
  835.     //
  836.     // retrieve timeout value from string
  837.     //
  838.     if (dwStatus == ERROR_SUCCESS)
  839.     {
  840.         // Add a NULL terminator because RegQueryValueEx does not guarantee it
  841.         DWORD dwNullIndex = (dwBlockSize/2)-1;
  842.         pszTimeout[dwNullIndex] = 0x00;
  843.         dwStatus = (swscanf (pszTimeout, L"%lu", &dwTimeout) == 1)? ERROR_SUCCESS : ERROR_INVALID_DATA;
  844.     }
  845.     //
  846.     // update output parameter
  847.     //
  848.     *pdwTimeout = (dwStatus == ERROR_SUCCESS)? dwTimeout : 45;
  849.     //
  850.     // cleanup
  851.     //
  852.     if (pszTimeout)
  853.     {
  854.         FreeSplMem (pszTimeout);
  855.     }
  856.     if (hWindows)
  857.     {
  858.         RegCloseKey (hWindows);
  859.     }
  860. }
  862. DWORD
  863. SetTransmissionRetryTimeoutInRegistry (
  864.     __in LPCWSTR       pszTimeout
  865.     )
  866. /*++
  868. Description:
  869.     This function returns sets the timeout value in the Registry at
  870.     HKLMSoftwareMicrosoftWindows NTCurrentVersionWindows:TransmissionRetryTimeout
  872. Arguments:
  873.     pdwTimeout  - [in] new timeout value
  875. Returns:
  876.     Win32 error code
  878. --*/
  879. {
  880.     extern WCHAR gszWindows [];
  881.     DWORD  dwStatus  = ERROR_SUCCESS;
  883.     //
  884.     // open the registry key
  885.     //
  886.     HKEY hWindows = NULL;
  887.     if (dwStatus == ERROR_SUCCESS)
  888.     {
  889.         dwStatus = RegOpenKeyEx (HKEY_LOCAL_MACHINE, gszWindows, 0, KEY_SET_VALUE, &hWindows);
  890.     }
  891.     //
  892.     // get data
  893.     //
  894.     if (dwStatus == ERROR_SUCCESS)
  895.     {
  896.         DWORD cbData = (wcslen (pszTimeout) + 1) * sizeof pszTimeout [0];
  897.         dwStatus = RegSetValueEx (hWindows, szINIKey_TransmissionRetryTimeout, 0, REG_SZ, (BYTE*)pszTimeout, cbData);
  898.     }
  899.     //
  900.     // cleanup
  901.     //
  902.     if (hWindows)
  903.     {
  904.         RegCloseKey (hWindows);
  905.     }
  907.     return dwStatus;
  908. }
  909. BOOL
  910. AddPortInRegistry (
  911.     __in LPCWSTR pszPortName
  912.     )
  913. /*++
  915. Description:
  916.     This function adds the port name in the Registry as
  917.     Note, no communcation parameters will be added.
  919. Arguments:
  920.     pszPortName     - [in] port name
  922. Returns:
  923.     Win32 error code
  925. --*/
  926. {
  927.     DWORD        dwStatus = ERROR_SUCCESS;
  928.     HANDLE       hToken = NULL;
  929.     HKEY         hPorts = NULL;
  931.     if (pszPortName == NULL)
  932.     {
  933.         dwStatus = ERROR_INVALID_DATA;
  934.         goto done;
  935.     }
  937.     // Note:  Port monitor writers need to think about what resources are being used and
  938.     //        what level of security should be required in the creation of a port.
  939.     {
  940.         hToken = RevertToPrinterSelf();
  941.     }
  942.     
  943.     //
  944.     // open the key
  945.     //
  946.     dwStatus = g_pMonitorInit->pMonitorReg->fpCreateKey(g_pMonitorInit->hckRegistryRoot, 
  947.                                                         g_szPortsKey, 
  948.                                                         REG_OPTION_NON_VOLATILE,
  949.                                                         KEY_SET_VALUE,
  950.                                                         NULL,
  951.                                                         &hPorts, 
  952.                                                         NULL,
  953.                                                         g_pMonitorInit->hSpooler);
  954.     //
  955.     // add the new value
  956.     //
  957.     if (dwStatus == ERROR_SUCCESS)
  958.     {
  959.         WCHAR szEmpty [] = L"";
  960.         dwStatus = g_pMonitorInit->pMonitorReg->fpSetValue(hPorts, 
  961.                                                            pszPortName, 
  962.                                                            REG_SZ, 
  963.                                                            (BYTE*) szEmpty, 
  964.                                                            sizeof szEmpty,
  965.                                                            g_pMonitorInit->hSpooler);
  966.     }
  968. done:
  969.     //
  970.     // cleanup
  971.     //
  972.     if (hPorts)
  973.     {
  974.         RegCloseKey (hPorts);
  975.     }
  977.     if (hToken)
  978.         ImpersonatePrinterClient(hToken);
  979.     return dwStatus == ERROR_SUCCESS;
  980. }
  983. VOID
  984. DeletePortFromRegistry (
  985.     __in LPCWSTR         pszPortName
  986.     )
  987. /*++
  989. Description:
  990.     This function deletes the port from the Registry. Basicaly, it deletes the Registry value
  992. Arguments:
  993.     pszPortName     - [in] port name
  995. Returns:
  996.     Win32 error code
  998. --*/
  999. {
  1000.     DWORD  dwStatus = ERROR_SUCCESS;
  1001.     HANDLE hToken = NULL;
  1002.     HKEY   hPorts = NULL;
  1004.     if (pszPortName == NULL)
  1005.     {
  1006.         dwStatus = ERROR_INVALID_DATA;
  1007.         goto done;
  1008.     }
  1010.     // Note:  Port monitor writers need to think about what resources are being used and
  1011.     //        what level of security should be required in the deletion of a port.
  1012.     {
  1013.         hToken = RevertToPrinterSelf();
  1014.     }
  1016.     //
  1017.     // open the key
  1018.     //
  1019.     dwStatus = g_pMonitorInit->pMonitorReg->fpCreateKey(g_pMonitorInit->hckRegistryRoot, 
  1020.                                                         g_szPortsKey, 
  1021.                                                         REG_OPTION_NON_VOLATILE,
  1022.                                                         KEY_SET_VALUE,
  1023.                                                         NULL,
  1024.                                                         &hPorts, 
  1025.                                                         NULL,
  1026.                                                         g_pMonitorInit->hSpooler);
  1028.     //
  1029.     // remove the new value
  1030.     //
  1031.     if (dwStatus == ERROR_SUCCESS)
  1032.     {
  1033.         dwStatus = g_pMonitorInit->pMonitorReg->fpDeleteValue(hPorts, 
  1034.                                                               pszPortName,
  1035.                                                               g_pMonitorInit->hSpooler);
  1036.     }
  1037.     
  1038. done:
  1039.     //
  1040.     // cleanup
  1041.     //
  1042.     if (hPorts)
  1043.     {
  1044.         RegCloseKey (hPorts);
  1045.     }
  1047.     if (hToken)
  1048.         ImpersonatePrinterClient(hToken);
  1049. }
  1052. LPWSTR
  1053. AdjustFileName(
  1054.     __in LPWSTR pFileName
  1055.     )
  1056. {
  1057.     LPWSTR pNewName    = NULL;
  1059.     pNewName = AllocSplStr( pFileName);
  1061.     return pNewName;
  1062. }