home *** CD-ROM | disk | FTP | other *** search
/ kermit.columbia.edu / kermit.columbia.edu.tar / kermit.columbia.edu / tmp9 / cknprt.c < prev    next >
C/C++ Source or Header  |  2006-04-03  |  13KB  |  454 lines
  1. /*
  2.   Author: Jeffrey Altman (jaltman@secure-endpoints.com),
  3.             Secure Endpoints Inc., New York City.
  4.  
  5.   Copyright (C) 1985, 2004, Trustees of Columbia University in the City of New
  6.   York.  All rights reserved.
  7. */
  8.  
  9. #include <windows.h>
  10. #include "ckcdeb.h"             /* Typedefs, debug formats, etc */
  11. #include "ckcker.h"             /* Kermit definitions */
  12. #include "ckucmd.h"
  13.  
  14. HANDLE hPrinter=NULL;
  15. DWORD  dwJob=0;
  16.  
  17. int
  18. Win32PrtOpen( char * prtname )
  19. {
  20.     DOC_INFO_1 DocInfo;
  21.  
  22.     if( ! OpenPrinter( prtname, &hPrinter, NULL ) ) {
  23.         int error = GetLastError();
  24.         debug(F111,"Win32PrtOpen OpenPrinter() failed",prtname,error);
  25.         printf("ERROR: Unable to open printer: %s (%d)\n",
  26.                 prtname,error);
  27.         return FALSE;
  28.     }
  29.  
  30.     // Fill in the structure with info about this "document"
  31.     DocInfo.pDocName = "Kermit-95";
  32.     DocInfo.pOutputFile = NULL;
  33.     DocInfo.pDatatype = "RAW";
  34.     // Inform the spooler the document is beginning
  35.     if( (dwJob = StartDocPrinter( hPrinter, 1, (LPSTR)&DocInfo )) == 0 )
  36.     {
  37.         int error = GetLastError();
  38.         debug(F111,"Win32PrtOpen StartDocPrinter() failed",prtname,error);
  39.         printf("ERROR: Unable to start doc on printer: %s (%d)\n",
  40.                 prtname,error);
  41.         ClosePrinter( hPrinter );
  42.         hPrinter = NULL;
  43.         return FALSE;
  44.     }
  45.     // Start a page
  46.     if( ! StartPagePrinter( hPrinter ) )
  47.     {
  48.         int error = GetLastError();
  49.         debug(F111,"Win32PrtOpen StartPagePrinter() failed",prtname,error);
  50.         printf("ERROR: Unable to start page on printer: %s (%d)\n",
  51.                 prtname,error);
  52.         EndDocPrinter( hPrinter );
  53.         ClosePrinter( hPrinter );
  54.         hPrinter = NULL;
  55.         return FALSE;
  56.     }
  57.     return TRUE;
  58. }
  59.  
  60.  
  61. int
  62. Win32PrtWrite( char * pData, int bytes )
  63. {
  64.     DWORD dwBytesWritten;
  65.  
  66.     if ( hPrinter == NULL )
  67.         return -1;
  68.  
  69.     // Send the data to the printer
  70.     if( ! WritePrinter( hPrinter, pData, bytes, &dwBytesWritten ) )
  71.     {
  72.         EndPagePrinter( hPrinter );
  73.         EndDocPrinter( hPrinter );
  74.         ClosePrinter( hPrinter );
  75.         hPrinter = NULL;
  76.         return -2;
  77.     }
  78.  
  79.     return (int) dwBytesWritten;
  80. }
  81.  
  82.  
  83. int
  84. Win32PrtClose( void )
  85. {
  86.     // End the page
  87.     if( ! EndPagePrinter( hPrinter ) )
  88.     {
  89.         EndDocPrinter( hPrinter );
  90.         ClosePrinter( hPrinter );
  91.         hPrinter = NULL;
  92.         return FALSE;
  93.     }
  94.     // Inform the spooler that the document is ending
  95.     if( ! EndDocPrinter( hPrinter ) )
  96.     {
  97.         ClosePrinter( hPrinter );
  98.         hPrinter = NULL;
  99.         return FALSE;
  100.     }
  101.     // Tidy up the printer handle
  102.     ClosePrinter( hPrinter );
  103.     hPrinter = NULL;
  104.  
  105.     return TRUE;
  106. }
  107.  
  108. int
  109. Win32PrtFile( char * filename, char * prtname )
  110. {
  111.     HANDLE     hPrinter,hFile;
  112.     SECURITY_ATTRIBUTES security ;
  113.     DOC_INFO_1 DocInfo;
  114.     DWORD      dwBytesWritten;
  115.     CHAR       lpData[4096];
  116.     DWORD      dwCount=0;
  117.  
  118.  
  119.     // First try to open the file
  120.     security.nLength = sizeof(SECURITY_ATTRIBUTES);
  121.     security.lpSecurityDescriptor = NULL ;
  122.     security.bInheritHandle = FALSE ;
  123.  
  124.     hFile = CreateFile( filename,
  125.                         GENERIC_READ,
  126.                         TRUE,
  127.                         &security,
  128.                         OPEN_EXISTING,
  129.                         FILE_ATTRIBUTE_NORMAL,
  130.                         NULL );
  131.     if ( !hFile )
  132.         return FALSE;
  133.  
  134.     // Need a handle to the printer
  135.     if( ! OpenPrinter( prtname, &hPrinter, NULL ) ) {
  136.         CloseHandle( hFile );
  137.         return FALSE;
  138.     }
  139.  
  140.     // Fill in the structure with info about this "document"
  141.     DocInfo.pDocName = filename;
  142.     DocInfo.pOutputFile = NULL;
  143.     DocInfo.pDatatype = "RAW";
  144.     // Inform the spooler the document is beginning
  145.     if( (dwJob = StartDocPrinter( hPrinter, 1, (LPSTR)&DocInfo )) == 0 )
  146.     {
  147.         ClosePrinter( hPrinter );
  148.         CloseHandle( hFile );
  149.         return FALSE;
  150.     }
  151.     // Start a page
  152.     if( ! StartPagePrinter( hPrinter ) )
  153.     {
  154.         EndDocPrinter( hPrinter );
  155.         ClosePrinter( hPrinter );
  156.         CloseHandle( hFile );
  157.         return FALSE;
  158.     }
  159.  
  160.     do {
  161.         // Read data from the file
  162.         if ( !ReadFile(hFile,
  163.                         lpData,
  164.                         4096,
  165.                         &dwCount,
  166.                         NULL) )
  167.         {
  168.             EndPagePrinter( hPrinter );
  169.             EndDocPrinter( hPrinter );
  170.             ClosePrinter( hPrinter );
  171.             CloseHandle( hFile );
  172.             return FALSE;
  173.         }
  174.  
  175.         // Send the data to the printer
  176.         if( ! WritePrinter( hPrinter, lpData, dwCount, &dwBytesWritten ) )
  177.         {
  178.             EndPagePrinter( hPrinter );
  179.             EndDocPrinter( hPrinter );
  180.             ClosePrinter( hPrinter );
  181.             CloseHandle( hFile );
  182.             return FALSE;
  183.         }
  184.     } while ( dwCount > 0 );
  185.     // End the page
  186.     if( ! EndPagePrinter( hPrinter ) )
  187.     {
  188.         EndDocPrinter( hPrinter );
  189.         ClosePrinter( hPrinter );
  190.         return FALSE;
  191.     }
  192.     // Inform the spooler that the document is ending
  193.     if( ! EndDocPrinter( hPrinter ) )
  194.     {
  195.         ClosePrinter( hPrinter );
  196.         CloseHandle( hFile );
  197.         return FALSE;
  198.     }
  199.     // Tidy up the printer handle
  200.     ClosePrinter( hPrinter );
  201.     CloseHandle( hFile );
  202.  
  203.     return TRUE;
  204.  
  205. }
  206.  
  207.  
  208. #ifdef COMMENT
  209. typedef struct _PRINTER_INFO_2 { // pri2
  210.     LPTSTR    pServerName;
  211.     LPTSTR    pPrinterName;
  212.     LPTSTR    pShareName;
  213.     LPTSTR    pPortName;
  214.     LPTSTR    pDriverName;
  215.     LPTSTR    pComment;
  216.     LPTSTR    pLocation;
  217.     LPDEVMODE pDevMode;
  218.     LPTSTR    pSepFile;
  219.     LPTSTR    pPrintProcessor;
  220.     LPTSTR    pDatatype;
  221.     LPTSTR    pParameters;
  222.     PSECURITY_DESCRIPTOR pSecurityDescriptor;
  223.     DWORD     Attributes;
  224.     DWORD     Priority;
  225.     DWORD     DefaultPriority;
  226.     DWORD     StartTime;
  227.     DWORD     UntilTime;
  228.     DWORD     Status;
  229.     DWORD     cJobs;
  230.     DWORD     AveragePPM;
  231. } PRINTER_INFO_2;
  232. #endif
  233.  
  234. int
  235. Win32EnumPrt( struct keytab ** pTable, struct keytab ** pTable2,
  236.              int * pN, int *pDefault )
  237. {
  238.     DWORD  dwBytesNeeded;
  239.     DWORD  dwPrtRet2;
  240.     DWORD  dwMaxPrt;
  241.     LPTSTR lpName = NULL;
  242.     DWORD  dwEnumFlags = PRINTER_ENUM_LOCAL;
  243.     DWORD  dwLevel = 2;
  244.     LPPRINTER_INFO_1 pPrtInfo1=NULL;
  245.     LPPRINTER_INFO_2 pPrtInfo2=NULL;
  246.     int i, n, rc ;
  247.     CHAR   szDefault[256]="";
  248.     int    iDefault = -1;
  249.  
  250.     BOOL (WINAPI * p_GetDefaultPrinter)( LPTSTR pszBuffer,   // printer name buffer
  251.                               LPDWORD pcchBuffer  // size of name buffer
  252.                               ) = NULL;
  253.     static HANDLE hWinSpool = INVALID_HANDLE_VALUE;
  254.  
  255.     if ( !p_GetDefaultPrinter ) {
  256.         if ( hWinSpool == INVALID_HANDLE_VALUE )
  257.             hWinSpool = LoadLibrary("winspool.drv");
  258.         if ( hWinSpool != INVALID_HANDLE_VALUE )
  259.             (FARPROC) p_GetDefaultPrinter =
  260.                 GetProcAddress( hWinSpool, "GetDefaultPrinterA" );
  261.     }
  262.  
  263.     if ( p_GetDefaultPrinter ) {
  264.         DWORD dwSize = 256;
  265.         debug(F100,"Win32EnumPrt calling GetDefaultPrinter","",0);
  266.         rc = p_GetDefaultPrinter( szDefault, &dwSize );
  267.         debug(F111,"Win32EnumPrt GetDefaultPrinter returns",szDefault,rc);
  268.     } else {
  269.         debug(F100,"Win32EnumPrt calling GetProfileString","",0);
  270.         rc = GetProfileString("windows","device",",,,",szDefault,256);
  271.         debug(F111,"Win32EnumPrt GetProfileString returns",szDefault,rc);
  272.     }
  273.     if (rc) {
  274.         for ( i=0;szDefault[i];i++ ) {
  275.             if ( szDefault[i] == ',' ) {
  276.                 szDefault[i] = '\0';
  277.                 break;
  278.             }
  279.         }
  280.     }
  281.  
  282.     if ( *pTable )
  283.     {
  284.         for ( i=0 ; i < *pN ; i++ )
  285.             free( (*pTable)[i].kwd ) ;
  286.         free ( *pTable )  ;
  287.     }
  288.     *pTable = NULL;
  289.     if ( *pTable2 )
  290.     {
  291.         for ( i=0 ; i < *pN ; i++ )
  292.             free( (*pTable2)[i].kwd ) ;
  293.         free ( *pTable2 )  ;
  294.     }
  295.     *pTable2 = NULL;
  296.     *pN = 0;
  297.     *pDefault = -1;
  298.  
  299.     if ( !isWin95() ) {
  300.         // dwEnumFlags |= PRINTER_ENUM_CONNECTIONS;
  301.         if ( dwLevel == 1 ) {
  302.             dwEnumFlags |= PRINTER_ENUM_NETWORK;
  303.             dwEnumFlags |= PRINTER_ENUM_REMOTE;
  304.         }
  305.         debug(F111,"Win32EnumPrt","dwEnumFlags",dwEnumFlags);
  306.     }
  307.  
  308.     //
  309.     // get byte count needed for buffer, alloc buffer, the enum the printers
  310.     //
  311.  
  312.     debug(F100,"Win32EnumPrt calling EnumPrinters","",0);
  313.     rc = EnumPrinters (dwEnumFlags, lpName, dwLevel, NULL, 0, &dwBytesNeeded,
  314.                    &dwPrtRet2);
  315.     debug(F101,"Win32EnumPrt EnumPrinters returns","",0);
  316.  
  317.     //
  318.     // (simple error checking, if these work assume rest will too)
  319.     //
  320.  
  321.     if ( dwLevel == 1 ) {
  322.         if (!(pPrtInfo1 = (LPPRINTER_INFO_1) LocalAlloc (LPTR, dwBytesNeeded)))
  323.         {
  324.             return(FALSE);
  325.         }
  326.     } else {
  327.         if (!(pPrtInfo2 = (LPPRINTER_INFO_2) LocalAlloc (LPTR, dwBytesNeeded)))
  328.         {
  329.             return(FALSE);
  330.         }
  331.     }
  332.  
  333.     debug(F100,"Win32EnumPrt calling EnumPrinters","",0);
  334.     rc = EnumPrinters (dwEnumFlags, lpName, dwLevel,
  335.                       (dwLevel == 1 ? (LPBYTE) pPrtInfo1 : (LPBYTE) pPrtInfo2),
  336.                         dwBytesNeeded, &dwBytesNeeded, &dwPrtRet2);
  337.     debug(F101,"Win32EnumPrt EnumPrinters returns","",0);
  338.     if (!rc || dwPrtRet2 == 0)
  339.     {
  340.         LocalFree( dwLevel == 1 ? (LPBYTE) pPrtInfo1 : (LPBYTE) pPrtInfo2 );
  341.         return(FALSE);
  342.     }
  343.  
  344.     /* we now have an enumeration of all printer names */
  345.  
  346.     (*pTable) = (struct keytab *) malloc( dwPrtRet2 * sizeof(struct keytab) );
  347.     if ( !(*pTable) )
  348.     {
  349.         LocalFree( dwLevel == 1 ? (LPBYTE) pPrtInfo1 : (LPBYTE) pPrtInfo2 );
  350.         return(FALSE);
  351.     }
  352.     (*pTable2) = (struct keytab *) malloc( dwPrtRet2 * sizeof(struct keytab) );
  353.     if ( !(*pTable2) )
  354.     {
  355.         free(pTable);
  356.         pTable = NULL;
  357.         LocalFree( dwLevel == 1 ? (LPBYTE) pPrtInfo1 : (LPBYTE) pPrtInfo2 );
  358.         return(FALSE);
  359.     }
  360.  
  361.     for ( i=0 ; i<dwPrtRet2 ; i++ ) {
  362.         char * s = NULL;
  363.         char * p1 = NULL, * p2 = NULL;
  364.         int j, k;
  365.  
  366.         if ( dwLevel == 1 ) {
  367.             debug(F111,"Win32EnumPrt queue",pPrtInfo1[i].pName,i);
  368.             if ( iDefault == -1 ) {
  369.                 if ( !strcmp(pPrtInfo1[i].pName,szDefault) )
  370.                     iDefault = i;
  371.             }
  372.             p1 = strdup( pPrtInfo1[i].pName );
  373.             p2 = strdup( pPrtInfo1[i].pName );
  374.         } else {
  375.             debug(F111,"Win32EnumPrt queue",pPrtInfo2[i].pPrinterName,i);
  376.             if (pPrtInfo2[i].Attributes & PRINTER_ATTRIBUTE_DEFAULT)
  377.                 iDefault = i;
  378.             if ( iDefault == -1 ) {
  379.                 if ( !strcmp(pPrtInfo2[i].pPrinterName,szDefault) )
  380.                     iDefault = i;
  381.             }
  382.             p1 = strdup( pPrtInfo2[i].pPrinterName );
  383.             p2 = strdup( pPrtInfo2[i].pPrinterName );
  384.         }
  385.  
  386.         /* Now we must remove illegal characters from the pTable2 kwd */
  387.         s = p2;
  388.         while ( *s ) {
  389.             switch ( *s ) {
  390.             case ' ':
  391.                 *s = '_';
  392.                 break;
  393.             case ',':
  394.                 *s = '.';
  395.                 break;
  396.             case ';':
  397.                 *s = ':';
  398.                 break;
  399.             case '\\':
  400.                 *s = '/';
  401.                 break;
  402.             case '?':
  403.                 *s = '!';
  404.                 break;
  405.             case '{':
  406.                 *s = '[';
  407.                 break;
  408.             case '}':
  409.                 *s = ']';
  410.                 break;
  411.             default:
  412.                 *s = tolower(*s);
  413.             }
  414.             s++;
  415.         }
  416.  
  417.         for ( j=0;j<i;j++ ) {
  418.             if ( _stricmp(p2,(*pTable2)[j].kwd) < 0 )
  419.                 break;
  420.         }
  421.         for ( k = i ; k > j ; k--) {
  422.             (*pTable)[k].kwd = (*pTable)[k-1].kwd;
  423.             (*pTable2)[k].kwd = (*pTable2)[k-1].kwd;
  424.             (*pTable)[k].kwval = (*pTable)[k-1].kwval;
  425.             (*pTable2)[k].kwval = (*pTable2)[k-1].kwval;
  426.             (*pTable)[k].flgs = (*pTable)[k-1].flgs;
  427.             (*pTable2)[k].flgs = (*pTable2)[k-1].flgs;
  428.         }
  429.         (*pTable)[j].kwd = p1;
  430.         (*pTable2)[j].kwd = p2;
  431.         (*pTable)[j].kwval = i;
  432.         (*pTable2)[j].kwval = i;
  433.         (*pTable)[j].flgs = 0;
  434.         (*pTable2)[j].flgs = 0;
  435.     }
  436.     *pN = dwPrtRet2 ;
  437.  
  438.     if ( iDefault == -1 )
  439.         *pDefault = 0;
  440.     else {
  441.         for ( i=0 ; i<dwPrtRet2 ; i++ )
  442.             if ( (*pTable)[i].kwval == iDefault ) {
  443.                 *pDefault = i;
  444.                 break;
  445.             }
  446.     }
  447.  
  448.     LocalFree( dwLevel == 1 ? (LPBYTE) pPrtInfo1 : (LPBYTE) pPrtInfo2 );
  449.     debug(F101,"Win32EnumPrt returns","",*pN);
  450.     return(TRUE);
  451. }
  452.  
  453.  
  454.