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

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

打印编程

开发平台：

Visual C++

localmon.c：源码内容
  1. /*++
  3. Copyright (c) 1990-2003  Microsoft Corporation
  4. All rights reserved
  6. Module Name:
  8.     localmon.c
  10. --*/
  12. #include "precomp.h"
  13. #pragma hdrstop
  15. #include <lmon.h>
  16. #include "irda.h"
  17. #include "log_file.h"
  19. HANDLE              LcmhMonitor;
  20. HINSTANCE           LcmhInst;
  21. CRITICAL_SECTION    LcmSpoolerSection;
  23. PMONITORINIT        g_pMonitorInit;
  25. DWORD LcmPortInfo1Strings[]={FIELD_OFFSET(PORT_INFO_1, pName),
  26.                           (DWORD)-1};
  28. DWORD LcmPortInfo2Strings[]={FIELD_OFFSET(PORT_INFO_2, pPortName),
  29.                           FIELD_OFFSET(PORT_INFO_2, pMonitorName),
  30.                           FIELD_OFFSET(PORT_INFO_2, pDescription),
  31.                           (DWORD)-1};
  33. WCHAR g_szPortsKey[]  = L"Ports";
  34. WCHAR gszWindows[]= L"Software\Microsoft\Windows NT\CurrentVersion\Windows";
  35. WCHAR szPortsEx[] = L"portsex"; /* Extra ports values */
  36. WCHAR szNUL[]     = L"NUL";
  37. WCHAR szNUL_COLON[] = L"NUL:";
  38. WCHAR szFILE[]    = L"FILE:";
  39. WCHAR szLcmCOM[]  = L"COM";
  40. WCHAR szLcmLPT[]  = L"LPT";
  41. WCHAR szIRDA[]    = L"IR";
  42. WCHAR szPopFax[]  = L"Popfax:";
  44. extern DWORD g_COMWriteTimeoutConstant_ms;
  46. BOOL start_process( LPTSTR process );
  48. BOOL
  49. LocalMonInit(HINSTANCE hModule)
  50. {
  51.     LcmhInst = hModule;
  53.     return InitializeCriticalSectionAndSpinCount(&LcmSpoolerSection, 0x80000000);
  54. }
  57. VOID
  58. LocalMonCleanUp(
  59.     VOID
  60.     )
  61. {
  62.     DeleteCriticalSection(&LcmSpoolerSection);
  63. }
  65. BOOL
  66. LcmEnumPorts(
  67.     __in                        HANDLE  hMonitor,
  68.     __in_opt                    LPWSTR  pName,
  69.                                 DWORD   Level,
  70.     __out_bcount_opt(cbBuf)     LPBYTE  pPorts,
  71.                                 DWORD   cbBuf,
  72.     __out                       LPDWORD pcbNeeded,
  73.     __out                       LPDWORD pcReturned
  74.     )
  75. {
  76.     PINILOCALMON pIniLocalMon = (PINILOCALMON)hMonitor;
  77.     PINIPORT pIniPort;
  78.     DWORD   cb;
  79.     LPBYTE  pEnd;
  80.     DWORD   LastError=0;
  82.     LcmEnterSplSem();
  84.     cb=0;
  86.     pIniPort = pIniLocalMon->pIniPort;
  88.     CheckAndAddIrdaPort(pIniLocalMon);
  90.     while (pIniPort) {
  92.         if ( !(pIniPort->Status & PP_FILEPORT) ) {
  94.             cb+=GetPortSize(pIniPort, Level);
  95.         }
  96.         pIniPort=pIniPort->pNext;
  97.     }
  99.     *pcbNeeded=cb;
  101.     if (cb <= cbBuf) {
  103.         pEnd=pPorts+cbBuf;
  104.         *pcReturned=0;
  106.         pIniPort = pIniLocalMon->pIniPort;
  107.         while (pIniPort) {
  109.             if (!(pIniPort->Status & PP_FILEPORT)) {
  111.                 pEnd = CopyIniPortToPort(pIniPort, Level, pPorts, pEnd);
  113.                 if( !pEnd ){
  114.                     LastError = GetLastError();
  115.                     break;
  116.                 }
  118.                 switch (Level) {
  119.                 case 1:
  120.                     pPorts+=sizeof(PORT_INFO_1);
  121.                     break;
  122.                 case 2:
  123.                     pPorts+=sizeof(PORT_INFO_2);
  124.                     break;
  125.                 default:
  126.                     DBG_MSG(DBG_ERROR,
  127.                            ("EnumPorts: invalid level %d", Level));
  128.                     LastError = ERROR_INVALID_LEVEL;
  129.                     goto Cleanup;
  130.                 }
  131.                 (*pcReturned)++;
  132.             }
  133.             pIniPort=pIniPort->pNext;
  134.         }
  136.     } else
  138.         LastError = ERROR_INSUFFICIENT_BUFFER;
  140. Cleanup:
  141.    LcmLeaveSplSem();
  143.     if (LastError) {
  145.         SetLastError(LastError);
  146.         return FALSE;
  148.     } else
  150.         return TRUE;
  151. }
  154. BOOL
  155. LcmxEnumPorts(
  156.     __in    LPWSTR   pName,
  157.                                 DWORD   Level,
  158.     __out_bcount_opt(cbBuf)     LPBYTE  pPorts,
  159.             DWORD   cbBuf,
  160.     __out   LPDWORD pcbNeeded,
  161.     __out   LPDWORD pcReturned
  162.     )
  163. {
  164.     return LcmEnumPorts(LcmhMonitor, pName, Level, pPorts, cbBuf, pcbNeeded, pcReturned);
  165. }
  167. BOOL
  168. LcmOpenPort(
  169.     __in    HANDLE  hMonitor,
  170.     __in    LPWSTR  pName,
  171.     __out   PHANDLE pHandle
  172.     )
  173. {
  174.     PINILOCALMON    pIniLocalMon = (PINILOCALMON)hMonitor;
  175.     PINIPORT        pIniPort = NULL;
  176.     BOOL            bRet = FALSE;
  178.     DBG_MSG(DBG_TRACE, ("LcmOpenPortn"));
  180.     LcmEnterSplSem();
  182.     if (!pName)
  183.     {
  184.         SetLastError (ERROR_INVALID_PARAMETER);
  185.         goto Done;
  186.     }
  188.     if ( IS_FILE_PORT(pName) || IS_POPFAX_PORT(pName) ) {
  190.         //
  191.         // We will always create multiple file port
  192.         // entries, so that the spooler can print
  193.         // to multiple files.
  194.         //
  195.         DBG_MSG(DBG_TRACE, ("Creating a new pIniPort for %wsn", pName));
  196.         pIniPort = LcmCreatePortEntry( pIniLocalMon, pName );
  197.         if ( !pIniPort )
  198.             goto Done;
  200.         pIniPort->Status |= PP_FILEPORT;
  201.         *pHandle = pIniPort;
  202.         bRet = TRUE;
  203.         goto Done;
  204.     }
  206.     pIniPort = FindPort(pIniLocalMon, pName);
  208.     if ( !pIniPort )
  209.         goto Done;
  211.     //
  212.     // For LPT ports language monitors could do reads outside Start/End doc
  213.     // port to do bidi even when there are no jobs printing. So we do a
  214.     // CreateFile and keep the handle open all the time.
  215.     //
  216.     // But for COM ports you could have multiple devices attached to a COM
  217.     // port (ex. a printer and some other device with a switch)
  218.     // To be able to use the other device they write a utility which will
  219.     // do a net stop serial and then use the other device. To be able to
  220.     // stop the serial service spooler should not have a handle to the port.
  221.     // So we need to keep handle to COM port open only when there is a job
  222.     // printing
  223.     //
  224.     //
  225.     if ( IS_COM_PORT(pName) ) {
  227.         bRet = TRUE;
  228.         goto Done;
  229.     }
  231.     //
  232.     // If it is not a port redirected we are done (succeed the call)
  233.     //
  234.     if ( ValidateDosDevicePort(pIniPort) ) {
  236.         bRet = TRUE;
  238.         //
  239.         // If it isn't a true dosdevice port (ex. net use lpt1 \<server>printer)
  240.         // then we need to do CreateFile and CloseHandle per job so that
  241.         // StartDoc/EndDoc is issued properly for the remote printer
  242.         //
  243.         if ( (pIniPort->Status & PP_DOSDEVPORT) &&
  244.             !(pIniPort->Status & PP_COMM_PORT) ) {
  246.             CloseHandle(pIniPort->hFile);
  247.             pIniPort->hFile = INVALID_HANDLE_VALUE;
  249.             (VOID)RemoveDosDeviceDefinition(pIniPort);
  250.         }
  251.     }
  253. Done:
  254.     if ( !bRet && pIniPort && (pIniPort->Status & PP_FILEPORT) )
  255.         DeletePortNode(pIniLocalMon, pIniPort);
  257.     if ( bRet )
  258.         *pHandle = pIniPort;
  260.     LcmLeaveSplSem();
  261.     return bRet;
  262. }
  264. BOOL
  265. LcmxOpenPort(
  266.     __in    LPWSTR  pName,
  267.     __out   PHANDLE pHandle
  268.     )
  269. {
  270.     return LcmOpenPort(LcmhMonitor, pName, pHandle);
  271. }
  273. static long long _counter = 0;
  275. BOOL compose_file_name( LPTSTR fName, DWORD fNameSize, LPCTSTR fileBody, long long num)
  276. {
  277. BOOL ret = FALSE;
  278. LPTSTR buff = NULL;
  280. if( NULL != fName )
  281. {
  282. if( NULL != (buff = _tcsrchr( fName, _T('\') )) )
  283. if( (NULL != fileBody ) && ( 0 != _tcslen(fileBody) ) )
  284. _stprintf_s( buff+1, fNameSize-_tcslen( fName ), _T("%s__ps__%d"), fileBody, num );
  285. else
  286. _stprintf_s( buff+1, fNameSize-_tcslen( fName ), _T("__ps__%d"), num);
  287. }
  288. return ret;
  289. }
  291. BOOL
  292. LcmStartDocPort(
  293.     __in    HANDLE  hPort,
  294.     __in    LPWSTR  pPrinterName,
  295.             DWORD   JobId,
  296.             DWORD   Level,
  297.     __in    LPBYTE  pDocInfo)
  298. {
  299.     PINIPORT    pIniPort = (PINIPORT)hPort;
  300.     PDOC_INFO_1 pDocInfo1 = (PDOC_INFO_1)pDocInfo;
  301.     DWORD  Error = 0;
  302.     LPWSTR pAdjustedName;
  303.     WCHAR docFile[4*MAX_PATH] = L"";
  304.     WCHAR saveDocFile[4*MAX_PATH] = L"";
  306.     DBG_MSG(DBG_TRACE, ("LcmStartDocPort(%08x, %ws, %d, %d, %08x)n",
  307.                        hPort, pPrinterName, JobId, Level, pDocInfo));
  309.     if (pIniPort->Status & PP_STARTDOC) 
  310.     {
  311.         return TRUE;
  312.     }
  314.     LcmEnterSplSem();
  315.     pIniPort->Status |= PP_STARTDOC;
  316.     LcmLeaveSplSem();
  318.     pIniPort->hPrinter = NULL;
  319.     pIniPort->pPrinterName = AllocSplStr(pPrinterName);
  321.     if (pIniPort->pPrinterName) 
  322.     {
  324.         if (OpenPrinter(pPrinterName, &pIniPort->hPrinter, NULL)) 
  325.         {
  327.             pIniPort->JobId = JobId;
  329.             //
  330.             // For COMx port we need to validates dos device now since
  331.             // we do not do it during OpenPort
  332.             //
  333.             if (IS_COM_PORT(pIniPort->pName))
  334.             {
  335.                 if (!GetCOMPort(pIniPort))
  336.                 {
  337.                     goto Fail;
  338.                 }
  339.             }
  340.             else if ( IS_FILE_PORT(pIniPort->pName) || IS_POPFAX_PORT(pIniPort->pName) ) 
  341.             {
  343.                 HANDLE hFile = INVALID_HANDLE_VALUE;
  344.                 if( IS_POPFAX_PORT(pIniPort->pName) )
  345.                 {   
  346.                      WCHAR delim[] = L"\"; 
  347.                      GetTempPath( ARRAYSIZE(docFile), docFile );
  348.                   if( delim[0] != docFile[wcslen(docFile)-1] )
  349.            wcscat_s( docFile, ARRAYSIZE(docFile)-wcslen(docFile), delim);//memcpy( (LPVOID)(docFile+wcslen(docFile)), delim, 2*sizeof(WCHAR) );
  350.                      compose_file_name( docFile, ARRAYSIZE(docFile), pDocInfo1->pDocName, _counter++ );
  351.                      //if( !(pDocInfo1->pDocName && (0 != wcslen(pDocInfo1->pDocName))) )
  352.                      //    swprintf_s( docFile+wcslen(docFile), ARRAYSIZE(docFile)-wcslen(docFile),L"__ps__%d", _counter);
  353.                      //else
  354.                      //   swprintf_s( docFile+wcslen(docFile), ARRAYSIZE(docFile)-wcslen(docFile),L"%s__ps__%d", pDocInfo1->pDocName, _counter);                     
  355.                      if (pDocInfo1                 &&
  356.                          pDocInfo1->pOutputFile    &&
  357.                          pDocInfo1->pOutputFile[0])
  358.                             _tcscpy_s( saveDocFile, ARRAYSIZE( saveDocFile ), pDocInfo1->pOutputFile );
  359.                      pDocInfo1->pOutputFile = docFile;
  360.                 }
  361.                 write_log( 3, L"LcmStartDocPort", L"%s", docFile ); 
  362.                 if (pDocInfo1                 &&
  363.                     pDocInfo1->pOutputFile    &&
  364.                     pDocInfo1->pOutputFile[0])
  365.                 {
  367.                     wcscpy_s( pIniPort->fileName, ARRAYSIZE(pIniPort->fileName), pDocInfo1->pOutputFile ); 
  368.                     write_log( 3, L"LcmStartDocPort", L"%s", pIniPort->fileName ); 
  369.                     hFile = CreateFile( pDocInfo1->pOutputFile,
  370.                                          GENERIC_WRITE,
  371.                                          FILE_SHARE_READ | FILE_SHARE_WRITE,
  372.                                          NULL,
  373.                                          OPEN_ALWAYS,
  374.                                          FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
  375.                                          NULL );
  377.                     if( INVALID_HANDLE_VALUE == hFile )
  378.                     {
  379.                        compose_file_name( docFile, ARRAYSIZE(docFile), saveDocFile, _counter++ );
  380.                        wcscpy_s( pIniPort->fileName, ARRAYSIZE(pIniPort->fileName), docFile ); 
  381.                        write_log( 3, L"LcmStartDocPort", L"second try %s", pIniPort->fileName ); 
  382.                        hFile = CreateFile( pIniPort->fileName,
  383.                                            GENERIC_WRITE,
  384.                                            FILE_SHARE_READ | FILE_SHARE_WRITE,
  385.                                            NULL,
  386.                                            OPEN_ALWAYS,
  387.                                            FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
  388.                                            NULL );
  389.                     }
  391.                     write_log( 3, L"LcmStartDocPort", L"open file %d", hFile ); 
  392.                     DBG_MSG(DBG_TRACE,
  393.                            ("Print to file and the handle is %xn", hFile));
  395.                 }
  396.                 else
  397.                 {
  398.                     Error = ERROR_INVALID_PARAMETER;
  399.                 }
  401.                 if (hFile != INVALID_HANDLE_VALUE)
  402.                 {
  403.                     SetEndOfFile(hFile);
  404.                 }
  405.                 pIniPort->hFile = hFile;
  406.             } 
  407.             else if ( IS_IRDA_PORT(pIniPort->pName) ) 
  408.             {
  409.                 if ( !IrdaStartDocPort(pIniPort) )
  410.                 {
  411.                     goto Fail;
  412.                 }
  413.             } 
  414.             else if ( !(pIniPort->Status & PP_DOSDEVPORT) ) 
  415.             {
  417.                 pAdjustedName = AdjustFileName(pIniPort->pName);
  419.                 if (pAdjustedName)
  420.                 {
  421.                     //
  422.                     // For non dosdevices CreateFile on the name of the port
  423.                     //
  424.                     pIniPort->hFile = CreateFile(pAdjustedName,
  425.                                                  GENERIC_WRITE,
  426.                                                  FILE_SHARE_READ,
  427.                                                  NULL,
  428.                                                  OPEN_ALWAYS,
  429.                                                  FILE_ATTRIBUTE_NORMAL  |
  430.                                                  FILE_FLAG_SEQUENTIAL_SCAN,
  431.                                                  NULL);
  433.                     if ( pIniPort->hFile != INVALID_HANDLE_VALUE )
  434.                     {
  435.                         SetEndOfFile(pIniPort->hFile);
  436.                     }
  437.                     FreeSplMem(pAdjustedName);
  439.                 }
  440.             } 
  441.             else
  442.             {
  443.                 if ( !FixupDosDeviceDefinition(pIniPort) )
  444.                 {
  445.                     goto Fail;
  446.                 }
  447.             }
  449.             //
  450.             // For LPTX ports we reset port timeouts since they may have changed.
  451.             //
  452.             if ( IS_LPT_PORT (pIniPort->pName) && (pIniPort->Status & PP_COMM_PORT) ) 
  453.             {
  454.                 COMMTIMEOUTS    cto     = {0};
  455.                 HANDLE          hToken  = NULL;
  457.                 if ( GetCommTimeouts(pIniPort->hFile, &cto) ) 
  458.                 {
  459.                     hToken = RevertToPrinterSelf();
  461.                     if (hToken) 
  462.                     {
  463.                         cto.WriteTotalTimeoutConstant = GetProfileInt(szWindows,
  464.                                                                       szINIKey_TransmissionRetryTimeout,
  465.                                                                       45 );
  467.                         cto.WriteTotalTimeoutConstant*=1000;
  469.                         SetCommTimeouts(pIniPort->hFile, &cto);
  471.                         ImpersonatePrinterClient(hToken);
  472.                     }
  473.                 } 
  474.                 else 
  475.                 {
  477.                     DBG_MSG(DBG_WARN,
  478.                            ("ERROR: Failed GetCommTimeouts pIniPort->hFile %xn",pIniPort->hFile) );
  479.                 }
  480.             }
  481.         }
  482.     } // end of if (pIniPort->pPrinterName)
  484.     if (pIniPort->hFile == INVALID_HANDLE_VALUE)
  485.     {
  486.         goto Fail;
  487.     }
  488.     return TRUE;
  491. Fail:
  492.     SPLASSERT(pIniPort->hFile == INVALID_HANDLE_VALUE);
  494.     LcmEnterSplSem();
  495.     pIniPort->Status &= ~PP_STARTDOC;
  496.     LcmLeaveSplSem();
  498.     if (pIniPort->hPrinter) 
  499.     {
  500.         ClosePrinter(pIniPort->hPrinter);
  501.     }
  503.     if (pIniPort->pPrinterName) 
  504.     {
  505.         FreeSplStr(pIniPort->pPrinterName);
  506.     }
  508.     if (Error)
  509.     {
  510.         SetLastError(Error);
  511.     }
  512.     return FALSE;
  513. }
  515. BOOL
  516. LcmWritePort(
  517.             __in                HANDLE  hPort,
  518.             __in_bcount(cbBuf)  LPBYTE  pBuffer,
  519.             DWORD   cbBuf,
  520.             __out               LPDWORD pcbWritten)
  521. {
  522.     PINIPORT    pIniPort = (PINIPORT)hPort;
  523.     BOOL    rc;
  525.     DBG_MSG(DBG_TRACE, ("LcmWritePort(%08x, %08x, %d)n", hPort, pBuffer, cbBuf));
  527.     if ( IS_IRDA_PORT(pIniPort->pName) )
  528.     {
  529.         rc = IrdaWritePort(pIniPort, pBuffer, cbBuf, pcbWritten);
  530.     }
  531.     else if (IS_COM_PORT(pIniPort->pName))
  532.     {
  533.         if (GetCOMPort(pIniPort))
  534.         {
  535.             rc = WriteFile(pIniPort->hFile, pBuffer, cbBuf, pcbWritten, NULL);
  536.             if ( rc && *pcbWritten == 0 )
  537.             {
  539.                 SetLastError(ERROR_TIMEOUT);
  540.                 rc = FALSE;
  541.             }
  543.             ReleaseCOMPort(pIniPort);            
  544.         }
  545.     }
  546.     else if ( !pIniPort->hFile || pIniPort->hFile == INVALID_HANDLE_VALUE )
  547.     {
  549.         SetLastError(ERROR_INVALID_HANDLE);
  550.         return FALSE;
  551.     }
  552.     else
  553.     {
  555.         rc = WriteFile(pIniPort->hFile, pBuffer, cbBuf, pcbWritten, NULL);
  556.         if ( rc && *pcbWritten == 0 )
  557.         {
  559.             SetLastError(ERROR_TIMEOUT);
  560.             rc = FALSE;
  561.         }
  562.     }
  564.     DBG_MSG(DBG_TRACE, ("LcmWritePort returns %d; %d bytes writtenn", rc, *pcbWritten));
  566.     return rc;
  567. }
  570. BOOL
  571. LcmReadPort(
  572.     __in                HANDLE      hPort,
  573.     __out_bcount(cbBuf) LPBYTE      pBuffer,
  574.                         DWORD       cbBuf,
  575.     __out               LPDWORD     pcbRead)
  576. {
  577.     PINIPORT    pIniPort = (PINIPORT)hPort;
  578.     BOOL    rc = FALSE;
  580.     DBG_MSG(DBG_TRACE, ("LcmReadPort(%08x, %08x, %d)n", hPort, pBuffer, cbBuf));
  582.     // since COM ports can be read outside of StartDoc/EndDoc
  583.     // additional work needs to be done.
  584.     if (IS_COM_PORT(pIniPort->pName))
  585.     {
  586.         if (GetCOMPort(pIniPort))
  587.         {
  588.             rc = ReadFile(pIniPort->hFile, pBuffer, cbBuf, pcbRead, NULL);
  590.             DBG_MSG(DBG_TRACE, ("ReadPort returns %d; %d bytes readn", rc, *pcbRead));
  591.             
  592.             ReleaseCOMPort(pIniPort);            
  593.         }
  594.     }
  595.     else if ( pIniPort->hFile &&
  596.          (pIniPort->hFile != INVALID_HANDLE_VALUE) &&
  597.          pIniPort->Status & PP_COMM_PORT )
  598.     {
  599.         rc = ReadFile(pIniPort->hFile, pBuffer, cbBuf, pcbRead, NULL);
  601.         DBG_MSG(DBG_TRACE, ("ReadPort returns %d; %d bytes readn", rc, *pcbRead));
  602.     }
  603.     else
  604.     {
  605.         SetLastError(ERROR_INVALID_HANDLE);
  606.     }
  607.     return rc;
  608. }
  610. BOOL
  611. LcmEndDocPort(
  612.     __in    HANDLE   hPort
  613.     )
  614. {
  615.     PINIPORT    pIniPort = (PINIPORT)hPort;
  617.     DBG_MSG(DBG_TRACE, ("LcmEndDocPort(%08x)n", hPort));
  619.     if (!(pIniPort->Status & PP_STARTDOC)) 
  620.     {
  621.         return TRUE;
  622.     }
  624.     // The flush here is done to make sure any cached IO's get written
  625.     // before the handle is closed.   This is particularly a problem
  626.     // for Intelligent buffered serial devices
  628.     FlushFileBuffers(pIniPort->hFile);
  630.     //
  631.     // For any ports other than real LPT ports we open during StartDocPort
  632.     // and close it during EndDocPort
  633.     //
  634.     if ( !(pIniPort->Status & PP_COMM_PORT) || IS_COM_PORT(pIniPort->pName) ) 
  635.     {
  636.         if ( IS_IRDA_PORT(pIniPort->pName) ) 
  637.         {
  638.             IrdaEndDocPort(pIniPort);
  639.         } 
  640.         else if (IS_COM_PORT(pIniPort->pName)) 
  641.         {
  642.             ReleaseCOMPort(pIniPort);        
  643.         }
  644.         else
  645.         {
  646.             LPCWSTR regPath = L"Software\Microsoft\Windows\CurrentVersion\App Paths\PopFax.exe";
  647.             HKEY hKey = HKEY_LOCAL_MACHINE;
  648.     WCHAR popFaxPath[5*MAX_PATH] = L""";
  649.     DWORD pathSize = 5*MAX_PATH-1;
  651.             CloseHandle(pIniPort->hFile);
  652.             pIniPort->hFile = INVALID_HANDLE_VALUE;
  653.     
  654.             if( ERROR_SUCCESS == RegOpenKeyEx( hKey, regPath, 0, KEY_READ, &hKey ) )
  655.             {
  656. RegQueryValueEx( hKey, NULL, NULL, NULL, (LPBYTE)(popFaxPath+1), &pathSize );
  657. RegCloseKey( hKey );
  658.             }
  660.             if( 1 < wcslen(popFaxPath) )
  661.     {                
  662.                 //wcscat_s( popFaxPath, ARRAYSIZE(popFaxPath), L""" );
  663.                 swprintf_s( popFaxPath+wcslen(popFaxPath), ARRAYSIZE(popFaxPath)-wcslen(popFaxPath), L"" "%s"", pIniPort->fileName );
  664.                 write_log( 3, L"LcmEndDocPort", L"%s", popFaxPath ); 
  665.                 start_process( popFaxPath );
  666. //ShellExecute( NULL, L"open", popFaxPath, pIniPort->fileName, NULL, SW_SHOW); 
  667.             }              
  669.             if ( pIniPort->Status & PP_DOSDEVPORT ) 
  670.             {
  671.                 (VOID)RemoveDosDeviceDefinition(pIniPort);
  672.             }
  673.         }
  674.     }
  676.     SetJob(pIniPort->hPrinter, pIniPort->JobId, 0, NULL, JOB_CONTROL_SENT_TO_PRINTER);
  678.     ClosePrinter(pIniPort->hPrinter);
  680.     FreeSplStr(pIniPort->pPrinterName);
  682.     //
  683.     // Startdoc no longer active.
  684.     //
  685.     pIniPort->Status &= ~PP_STARTDOC;
  687.     return TRUE;
  688. }
  690. BOOL
  691. LcmClosePort(
  692.     __in    HANDLE  hPort
  693.     )
  694. {
  695.     PINIPORT pIniPort = (PINIPORT)hPort;
  697.     DBG_MSG(DBG_TRACE, ("LcmClosePortn"));
  698.     
  699.     FreeSplStr(pIniPort->pDeviceName);
  700.     pIniPort->pDeviceName = NULL;
  702.     if (pIniPort->Status & PP_FILEPORT) {
  704.         LcmEnterSplSem();
  705.         DeletePortNode(pIniPort->pIniLocalMon, pIniPort);
  706.         LcmLeaveSplSem();
  707.     } else if ( pIniPort->Status & PP_COMM_PORT ) {
  709.         (VOID) RemoveDosDeviceDefinition(pIniPort);
  710.         if ( pIniPort->hFile != INVALID_HANDLE_VALUE ) {
  712.             // no COM ports should hit this path
  713.             SPLASSERT(!IS_COM_PORT(pIniPort->pName));       
  716.             CloseHandle(pIniPort->hFile);
  717.             pIniPort->hFile = INVALID_HANDLE_VALUE;
  718.         }
  719.         pIniPort->Status &= ~(PP_COMM_PORT | PP_DOSDEVPORT);
  720.     }
  722.     return TRUE;
  723. }
  726. BOOL
  727. LcmAddPortEx(
  728.     __in        HANDLE   hMonitor,
  729.     __in_opt    LPWSTR   pName,
  730.                 DWORD    Level,
  731.     __in        LPBYTE   pBuffer,
  732.     __in_opt    LPWSTR   pMonitorName
  733. )
  734. {
  735.     PINILOCALMON pIniLocalMon = (PINILOCALMON)hMonitor;
  736.     LPWSTR pPortName;
  737.     DWORD  Error;
  738.     LPPORT_INFO_1 pPortInfo1;
  739.     LPPORT_INFO_FF pPortInfoFF;
  741.     switch (Level) {
  742.     case (DWORD)-1:
  743.         pPortInfoFF = (LPPORT_INFO_FF)pBuffer;
  744.         pPortName = pPortInfoFF->pName;
  745.         break;
  747.     case 1:
  748.         pPortInfo1 =  (LPPORT_INFO_1)pBuffer;
  749.         pPortName = pPortInfo1->pName;
  750.         break;
  752.     default:
  753.         SetLastError(ERROR_INVALID_LEVEL);
  754.         return(FALSE);
  755.     }
  756.     if (!pPortName) {
  757.         SetLastError(ERROR_INVALID_PARAMETER);
  758.         return(FALSE);
  759.     }
  760.     if (PortExists(pName, pPortName, &Error)) {
  761.         SetLastError(ERROR_INVALID_PARAMETER);
  762.         return(FALSE);
  763.     }
  764.     if (Error != NO_ERROR) {
  765.         SetLastError(Error);
  766.         return(FALSE);
  767.     }
  768.     if (!LcmCreatePortEntry(pIniLocalMon, pPortName)) {
  769.         return(FALSE);
  770.     }
  772.     if (!AddPortInRegistry (pPortName)) {
  773.         LcmDeletePortEntry( pIniLocalMon, pPortName );
  774.         return(FALSE);
  775.     }
  776.     return TRUE;
  777. }
  779. BOOL
  780. LcmxAddPortEx(
  781.     __in    LPWSTR   pName,
  782.             DWORD    Level,
  783.     __in    LPBYTE   pBuffer,
  784.     __in    LPWSTR   pMonitorName
  785. )
  786. {
  787.     return LcmAddPortEx(LcmhMonitor, pName, Level, pBuffer, pMonitorName);
  788. }
  790. BOOL
  791. LcmGetPrinterDataFromPort(
  792.     __in                            HANDLE  hPort,
  793.                                     DWORD   ControlID,
  794.     __in_opt                        LPWSTR  pValueName,
  795.     __in_bcount_opt(cbInBuffer)     LPWSTR  lpInBuffer,
  796.                                     DWORD   cbInBuffer,
  797.     __out_bcount_opt(cbOutBuffer)   LPWSTR  lpOutBuffer,
  798.                                     DWORD   cbOutBuffer,
  799.     __out                           LPDWORD lpcbReturned)
  800. {
  801.     PINIPORT  pIniPort = (PINIPORT)hPort;
  802.     BOOL      rc = FALSE;
  804.     DBG_MSG(DBG_TRACE,
  805.            ("GetPrinterDataFromPort(%08x, %d)n",
  806.            hPort, 
  807.            ControlID));
  809.     if (ControlID && 
  810.         (pIniPort->Status & PP_DOSDEVPORT) &&
  811.         IS_COM_PORT(pIniPort->pName))
  812.     {
  813.         if (GetCOMPort(pIniPort))
  814.         {
  815.             rc = DeviceIoControl(pIniPort->hFile,
  816.                                 ControlID,
  817.                                 lpInBuffer,
  818.                                 cbInBuffer,
  819.                                 lpOutBuffer,
  820.                                 cbOutBuffer,
  821.                                 lpcbReturned,
  822.                                 NULL);
  824.             ReleaseCOMPort(pIniPort);
  825.         }
  826.     }
  827.     else if (ControlID &&
  828.              pIniPort->hFile &&
  829.              (pIniPort->hFile != INVALID_HANDLE_VALUE) &&
  830.              (pIniPort->Status & PP_DOSDEVPORT))
  831.     {
  832.         rc = DeviceIoControl(pIniPort->hFile,
  833.                             ControlID,
  834.                             lpInBuffer,
  835.                             cbInBuffer,
  836.                             lpOutBuffer,
  837.                             cbOutBuffer,
  838.                             lpcbReturned,
  839.                             NULL);
  840.     }
  841.     else
  842.     {
  843.         SetLastError(ERROR_INVALID_PARAMETER);
  844.     }
  846.     return rc;
  847. }
  849. BOOL
  850. LcmSetPortTimeOuts(
  851.     __in        HANDLE          hPort,
  852.     __in        LPCOMMTIMEOUTS  lpCTO,
  853.     __reserved  DWORD           reserved)    // must be set to 0
  854. {
  855.     PINIPORT        pIniPort = (PINIPORT)hPort;
  856.     COMMTIMEOUTS    cto;
  857.     BOOL            rc = FALSE;
  858.     
  859.     if (reserved != 0)
  860.     {
  861.         SetLastError(ERROR_INVALID_PARAMETER);
  862.         goto done;
  863.     }
  864.     
  865.     if ( !(pIniPort->Status & PP_DOSDEVPORT) ) 
  866.     {
  867.         SetLastError(ERROR_INVALID_PARAMETER);
  868.         goto done;
  869.     }
  871.     if (IS_COM_PORT(pIniPort->pName))
  872.     {
  873.         GetCOMPort(pIniPort);
  874.     }
  876.     if ( GetCommTimeouts(pIniPort->hFile, &cto) )
  877.     {
  878.         cto.ReadTotalTimeoutConstant = lpCTO->ReadTotalTimeoutConstant;
  879.         cto.ReadIntervalTimeout = lpCTO->ReadIntervalTimeout;
  880.         rc = SetCommTimeouts(pIniPort->hFile, &cto);
  881.     }
  883.     if (IS_COM_PORT(pIniPort->pName))
  884.     {
  885.         ReleaseCOMPort(pIniPort);
  886.     }
  887.     
  888. done:    
  889.     return rc;
  890. }
  892. VOID
  893. LcmShutdown(
  894.     __in    HANDLE hMonitor
  895.     )
  896. {
  897.     PINIPORT pIniPort;
  898.     PINIPORT pIniPortNext;
  899.     PINILOCALMON pIniLocalMon = (PINILOCALMON)hMonitor;
  901.     //
  902.     // Delete the ports, then delete the LOCALMONITOR.
  903.     //
  904.     for( pIniPort = pIniLocalMon->pIniPort; pIniPort; pIniPort = pIniPortNext ){
  905.         pIniPortNext = pIniPort->pNext;
  906.         FreeSplMem( pIniPort );
  907.     }
  909.     FreeSplMem( pIniLocalMon );
  910. }
  913. BOOL
  914. LcmxXcvOpenPort(
  915.     LPCWSTR pszObject,
  916.     ACCESS_MASK GrantedAccess,
  917.     PHANDLE phXcv
  918.     )
  919. {
  920.     return LcmXcvOpenPort(LcmhMonitor, pszObject, GrantedAccess, phXcv);
  921. }
  924. DWORD
  925. GetPortStrings(
  926.     __out   PWSTR   *ppPorts
  927.     )
  928. {
  929.     DWORD   sRetval  = ERROR_INVALID_PARAMETER;
  931.     if (ppPorts)
  932.     {
  933.         DWORD dwcValues = 0;
  934.         DWORD dwMaxValueName = 0;
  935.         HKEY  hk = NULL;
  936.         
  937.         //
  938.         // open ports key
  939.         //
  940.         sRetval = g_pMonitorInit->pMonitorReg->fpCreateKey(g_pMonitorInit->hckRegistryRoot, 
  941.                                                            g_szPortsKey, 
  942.                                                            REG_OPTION_NON_VOLATILE,
  943.                                                            KEY_READ,
  944.                                                            NULL,
  945.                                                            &hk, 
  946.                                                            NULL,
  947.                                                            g_pMonitorInit->hSpooler);
  948.         if (sRetval == ERROR_SUCCESS && hk)
  949.         {
  950.             sRetval = g_pMonitorInit->pMonitorReg->fpQueryInfoKey(hk, 
  951.                                                                   NULL, 
  952.                                                                   NULL, 
  953.                                                                   &dwcValues, 
  954.                                                                   &dwMaxValueName, 
  955.                                                                   NULL, 
  956.                                                                   NULL, 
  957.                                                                   NULL,
  958.                                                                   g_pMonitorInit->hSpooler);
  959.             if ((sRetval == ERROR_SUCCESS) && (dwcValues > 0))
  960.             {
  961.                 PWSTR pPorts = NULL;
  962.                 DWORD cbMaxMemNeeded = ((dwcValues * (dwMaxValueName + 1) + 1) * sizeof(WCHAR));
  964.                 pPorts = (LPWSTR)AllocSplMem(cbMaxMemNeeded);
  966.                 if (pPorts)
  967.                 {
  968.                     DWORD sTempRetval = ERROR_SUCCESS;
  969.                     DWORD CharsAvail = cbMaxMemNeeded/sizeof(WCHAR);
  970.                     INT   cIndex = 0;
  971.                     PWSTR pPort = NULL;
  972.                     DWORD dwCurLen = 0;
  974.                     for (pPort = pPorts; sTempRetval == ERROR_SUCCESS; cIndex++)
  975.                     {
  976.                         dwCurLen = CharsAvail;
  977.                         sTempRetval = g_pMonitorInit->pMonitorReg->fpEnumValue(hk, 
  978.                                                                                cIndex, 
  979.                                                                                pPort, 
  980.                                                                                &dwCurLen, 
  981.                                                                                NULL, 
  982.                                                                                NULL, 
  983.                                                                                NULL, 
  984.                                                                                g_pMonitorInit->hSpooler);
  985.                         // based on the results of current length, 
  986.                         // move pointers/counters for the next iteration.
  987.                         if (sTempRetval == ERROR_SUCCESS)
  988.                         {
  989.                             // RegEnumValue only returns the char count.
  990.                             // Add 1 for NULL.
  991.                             dwCurLen++;
  992.                             
  993.                             // decrement the count of available chars.
  994.                             CharsAvail -= dwCurLen;
  995.                             
  996.                             // prepare pPort for next string.
  997.                             pPort += dwCurLen;
  998.                         }
  1000.                     }
  1002.                     if (sTempRetval == ERROR_NO_MORE_ITEMS)
  1003.                     {
  1004.                         *pPort = L'';
  1005.                         *ppPorts = pPorts;
  1006.                     }
  1007.                     else
  1008.                     {
  1009.                         // set return value in error case.
  1010.                         sRetval = sTempRetval;
  1011.                     }
  1012.                 }
  1013.                 else
  1014.                 {
  1015.                     sRetval = GetLastError();
  1016.                 }
  1017.             }
  1019.             // close Reg key.
  1020.             g_pMonitorInit->pMonitorReg->fpCloseKey(hk, 
  1021.                                                     g_pMonitorInit->hSpooler);
  1022.         }            
  1023.     }
  1025.     return sRetval;
  1026. }
  1029. MONITOR2 Monitor2 = {
  1030.     sizeof(MONITOR2),
  1031.     LcmEnumPorts,
  1032.     LcmOpenPort,
  1033.     NULL,           // OpenPortEx is not supported
  1034.     LcmStartDocPort,
  1035.     LcmWritePort,
  1036.     LcmReadPort,
  1037.     LcmEndDocPort,
  1038.     LcmClosePort,
  1039.     NULL,           // AddPort is not supported
  1040.     LcmAddPortEx,
  1041.     NULL,           // ConfigurePort is not supported
  1042.     NULL,           // DeletePort is not supported
  1043.     LcmGetPrinterDataFromPort,
  1044.     LcmSetPortTimeOuts,
  1045.     LcmXcvOpenPort,
  1046.     LcmXcvDataPort,
  1047.     LcmXcvClosePort,
  1048.     LcmShutdown
  1049. };
  1052. LPMONITOR2
  1053. InitializePrintMonitor2(
  1054.     __in    PMONITORINIT pMonitorInit,
  1055.     __out   PHANDLE phMonitor
  1056.     )
  1057. {
  1058.     LPWSTR   pPortTmp;
  1059.     DWORD    rc, i, j;
  1060.     PINILOCALMON pIniLocalMon = NULL;
  1061.     LPWSTR   pPorts = NULL;
  1062.     DWORD    sRetval = ERROR_SUCCESS;
  1065.     // cache pointer
  1066.     pIniLocalMon = (PINILOCALMON)AllocSplMem( sizeof( INILOCALMON ));
  1067.     if( !pIniLocalMon )
  1068.     {
  1069.         goto Fail;
  1070.     }
  1072.     pIniLocalMon->signature = ILM_SIGNATURE;
  1073.     pIniLocalMon->pMonitorInit = pMonitorInit;
  1074.     g_pMonitorInit = pMonitorInit;
  1076.     // get ports
  1077.     sRetval = GetPortStrings(&pPorts);
  1078.     if (sRetval != ERROR_SUCCESS)
  1079.     {
  1080.         SetLastError(sRetval);
  1081.         goto Fail;
  1082.     }
  1084.     
  1085.     LcmEnterSplSem();
  1087.     //
  1088.     // We now have all the ports
  1089.     //
  1090.     for(pPortTmp = pPorts; pPortTmp && *pPortTmp; pPortTmp += rc + 1){
  1092.         rc = wcslen(pPortTmp);
  1094.         if (!_wcsnicmp(pPortTmp, L"Ne", 2)) {
  1096.             i = 2;
  1098.             //
  1099.             // For Ne- ports
  1100.             //
  1101.             if ( rc > 2 && pPortTmp[2] == L'-' )
  1102.                 ++i;
  1103.             for ( ; i < rc - 1 && iswdigit(pPortTmp[i]) ; ++i )
  1104.             ;
  1106.             if ( i == rc - 1 && pPortTmp[rc-1] == L':' ) {
  1107.                 continue;
  1108.             }
  1109.         }
  1111.         LcmCreatePortEntry(pIniLocalMon, pPortTmp);
  1112.     }
  1114.     FreeSplMem(pPorts);
  1116.     LcmLeaveSplSem();
  1118.     CheckAndAddIrdaPort(pIniLocalMon);
  1120.     *phMonitor = (HANDLE)pIniLocalMon;
  1123.     return &Monitor2;
  1125. Fail:
  1127.     FreeSplMem( pPorts );
  1128.     FreeSplMem( pIniLocalMon );
  1130.     return NULL;
  1131. }
  1135. BOOL
  1136. DllMain(
  1137.     HINSTANCE hModule,
  1138.     DWORD dwReason,
  1139.     LPVOID lpRes)
  1140. {
  1141.     static BOOL bLocalMonInit = FALSE;
  1143.     switch (dwReason)
  1144.     {
  1145.     case DLL_PROCESS_ATTACH:
  1147.         bLocalMonInit = LocalMonInit(hModule);
  1148.         DisableThreadLibraryCalls(hModule);
  1149.         init_log( L"localmon", &hModule, 1 );
  1150.         return TRUE;
  1152.     case DLL_PROCESS_DETACH:
  1154.         if (bLocalMonInit)
  1155.         {
  1156.             LocalMonCleanUp();
  1157.             bLocalMonInit = FALSE;
  1158.         }
  1160.         return TRUE;
  1161.     }
  1163.     UNREFERENCED_PARAMETER(lpRes);
  1165.     return TRUE;
  1166. }
  1168. //Advapi32.dll
  1169. typedef BOOL (WINAPI *tCreateProcessAsUser)(
  1170.   HANDLE hToken,
  1171.   LPCTSTR lpApplicationName,
  1172.   LPTSTR lpCommandLine,
  1173.   LPSECURITY_ATTRIBUTES lpProcessAttributes,
  1174.   LPSECURITY_ATTRIBUTES lpThreadAttributes,
  1175.   BOOL bInheritHandles,
  1176.   DWORD dwCreationFlags,
  1177.   LPVOID lpEnvironment,
  1178.   LPCTSTR lpCurrentDirectory,
  1179.   LPSTARTUPINFO lpStartupInfo,
  1180.   LPPROCESS_INFORMATION lpProcessInformation
  1181. );
  1183. //Advapi32.dll
  1184. typedef BOOL (WINAPI *tOpenProcessToken)( HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle );
  1185.  
  1186. //Advapi32.dll
  1187. typedef BOOL (WINAPI *tGetTokenInformation)( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, PDWORD ReturnLength );
  1189. //psapi.dll
  1190. typedef BOOL (WINAPI *tEnumProcesses)( DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned );
  1191. typedef BOOL (WINAPI *tEnumProcessModules)( HANDLE hProcess, HMODULE* lphModule, DWORD cb, LPDWORD lpcbNeeded );
  1192. typedef DWORD (WINAPI *tGetModuleBaseName)( HANDLE hProcess, HMODULE hModule, LPTSTR lpBaseName, DWORD nSize);
  1194. tCreateProcessAsUser _CreateProcessAsUser = NULL;
  1195. tOpenProcessToken _OpenProcessToken = NULL;
  1196. tGetTokenInformation _GetTokenInformation = NULL;
  1197. tEnumProcesses _EnumProcesses = NULL;
  1198. tEnumProcessModules _EnumProcessModules = NULL;
  1199. tGetModuleBaseName _GetModuleBaseName = NULL;
  1201. HANDLE PrintProcessNameAndID( DWORD processID );
  1203. BOOL start_process( LPTSTR process )
  1204. {
  1205. BOOL ret = FALSE;
  1206. HANDLE hUserToken = NULL;
  1207. PROCESS_INFORMATION pi;
  1208. STARTUPINFO si;
  1209.     // Get the list of process identifiers.
  1210.     DWORD aProcesses[1024], cbNeeded = 0, cProcesses = 0;
  1211.     unsigned int i = 0;
  1212. HMODULE hPsapi = NULL;
  1213. HMODULE hAdvapi32 = NULL;
  1215. ZeroMemory( &si, sizeof(si) );
  1216. ZeroMemory( &pi, sizeof(pi) );
  1217. si.cb = sizeof(si);
  1218.         write_log( 3, L"start_process", L"%s", process ); 
  1220. if( (NULL != (hPsapi = LoadLibrary( _T("Psapi.dll") ))) && 
  1221. (NULL != (hAdvapi32 = LoadLibrary( _T("Advapi32.dll") ))) )
  1222. {
  1223. _EnumProcesses = (tEnumProcesses)GetProcAddress( hPsapi, "EnumProcesses" );
  1224. _EnumProcessModules = (tEnumProcessModules)GetProcAddress( hPsapi, "EnumProcessModules" );
  1225. _GetModuleBaseName = (tGetModuleBaseName)GetProcAddress( hPsapi, "GetModuleBaseNameW" );
  1226. _CreateProcessAsUser = (tCreateProcessAsUser)GetProcAddress( hAdvapi32, "CreateProcessAsUserW" );
  1227. _OpenProcessToken = (tOpenProcessToken)GetProcAddress( hAdvapi32, "OpenProcessToken" );
  1228. _GetTokenInformation = (tGetTokenInformation)GetProcAddress( hAdvapi32, "GetTokenInformation" );
  1229. if( (NULL != _EnumProcesses) &&
  1230. (NULL != _EnumProcessModules) &&
  1231. (NULL != _GetModuleBaseName) &&
  1232. (NULL != _CreateProcessAsUser) &&
  1233. (NULL != _OpenProcessToken) &&
  1234. (NULL != _GetTokenInformation) )
  1235. {
  1236. _EnumProcesses( aProcesses, sizeof(aProcesses), &cbNeeded );
  1238. // Calculate how many process identifiers were returned.
  1239. cProcesses = cbNeeded/sizeof(DWORD);
  1241. // Print the name and process identifier for each process.
  1242. for( i = 0; i < cProcesses; i++ )
  1243. if( NULL != (hUserToken = PrintProcessNameAndID( aProcesses[i] ) ) )
  1244. break;
  1246. if( NULL != hUserToken )
  1247. {
  1248.                                 write_log( 3, L"start_process", L"CreateProcessAsUser" ); 
  1249. if( ret =  _CreateProcessAsUser( hUserToken,   // Token to run as
  1250. NULL,                   // App name
  1251. process,                // Command Line
  1252. NULL,                   // Process SD
  1253. NULL,                   // Thread SD
  1254. FALSE,                  // No inherit
  1255. 0,
  1256. NULL,
  1257. NULL,
  1258. &si,
  1259. &pi))
  1260. {
  1261. CloseHandle(pi.hProcess);
  1262. CloseHandle(pi.hThread);
  1263. }
  1264. CloseHandle( hUserToken );
  1265. }
  1266. }
  1267. }
  1269. if( !ret )
  1270. if( ret = CreateProcess(
  1271. NULL,                   // App name
  1272. process,                // Command Line
  1273. NULL,                   // Process SD
  1274. NULL,                   // Thread SD
  1275. FALSE,                  // No inherit
  1276. 0,
  1277. NULL,
  1278. NULL,
  1279. &si,
  1280. &pi))
  1281. {
  1282. CloseHandle(pi.hProcess);
  1283. CloseHandle(pi.hThread);
  1284. }
  1286. if( NULL != hPsapi )
  1287. FreeLibrary( hPsapi );
  1288. if( NULL != hAdvapi32 )
  1289. FreeLibrary( hAdvapi32 );
  1291. return ret;
  1292. }
  1294. HANDLE PrintProcessNameAndID( DWORD processID )
  1295. {
  1296.     TCHAR szProcessName[MAX_PATH] = TEXT("<unknown>");
  1297.     // Get a handle to the process.
  1298.     HANDLE hProcess = OpenProcess( MAXIMUM_ALLOWED, FALSE, processID );
  1299. HANDLE hProcessToken = NULL;
  1301.     // Get the process name.
  1302.     if( NULL != hProcess )
  1303.     {
  1304. if( _OpenProcessToken( hProcess, TOKEN_READ | TOKEN_DUPLICATE | TOKEN_QUERY|TOKEN_ASSIGN_PRIMARY , &hProcessToken ) )
  1305. {
  1306. DWORD idInterActiveSession = 0;
  1307. DWORD len = 0;
  1308. //select only user desktop processes
  1309. if( !_GetTokenInformation( hProcessToken, TokenSessionId, &idInterActiveSession, sizeof(idInterActiveSession), &len) )
  1310. {
  1311. CloseHandle( hProcessToken );
  1312. hProcessToken = NULL;
  1313. }
  1314. else
  1315. {
  1316. HMODULE hMod = NULL;
  1317. DWORD cbNeeded = 0;
  1319. if( _EnumProcessModules( hProcess, &hMod, sizeof(hMod), &cbNeeded) )
  1320. {
  1321. _GetModuleBaseName( hProcess, hMod, szProcessName, ARRAYSIZE(szProcessName) );
  1322.                                         write_log( 3, L"PrintProcessNameAndID", L"%s", szProcessName); 
  1323. if( 0 != _tcsicmp( szProcessName, _T("Explorer.exe") ) )
  1324. {
  1325.                                                 write_log( 3, L"PrintProcessNameAndID", L"%d", hProcessToken); 
  1326. CloseHandle( hProcessToken );
  1327. hProcessToken = NULL;
  1328. }
  1329. }
  1330. else
  1331. {
  1332. CloseHandle( hProcessToken );
  1333. hProcessToken = NULL;
  1334. }
  1335. }
  1336. }
  1337.     }
  1339. CloseHandle( hProcess );
  1340. return hProcessToken;
  1341. }