LCOV - code coverage report
Current view: top level - libreoffice/vcl/unx/generic/printer - cupsmgr.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 49 389 12.6 %
Date: 2012-12-27 Functions: 7 31 22.6 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include <cups/cups.h>
      22             : #include <cups/http.h>
      23             : #include <cups/ipp.h>
      24             : #include <cups/ppd.h>
      25             : 
      26             : #include <unistd.h>
      27             : 
      28             : #include "cupsmgr.hxx"
      29             : 
      30             : #include "osl/thread.h"
      31             : #include "osl/diagnose.h"
      32             : #include "osl/conditn.hxx"
      33             : 
      34             : #include "rtl/ustrbuf.hxx"
      35             : 
      36             : #include <officecfg/Office/Common.hxx>
      37             : 
      38             : #include <algorithm>
      39             : 
      40             : using namespace psp;
      41             : using namespace osl;
      42             : 
      43             : using ::rtl::OUString;
      44             : using ::rtl::OUStringBuffer;
      45             : using ::rtl::OUStringToOString;
      46             : using ::rtl::OStringToOUString;
      47             : using ::rtl::OUStringHash;
      48             : using ::rtl::OString;
      49             : 
      50             : struct GetPPDAttribs
      51             : {
      52             :     osl::Condition      m_aCondition;
      53             :     OString             m_aParameter;
      54             :     OString             m_aResult;
      55             :     oslThread           m_aThread;
      56             :     int                 m_nRefs;
      57             :     bool*               m_pResetRunning;
      58             :     osl::Mutex*         m_pSyncMutex;
      59             : 
      60           0 :     GetPPDAttribs( const char * m_pParameter,
      61             :                    bool* pResetRunning, osl::Mutex* pSyncMutex )
      62             :             : m_aParameter( m_pParameter ),
      63             :               m_pResetRunning( pResetRunning ),
      64           0 :               m_pSyncMutex( pSyncMutex )
      65             :     {
      66           0 :         m_nRefs = 2;
      67           0 :         m_aCondition.reset();
      68           0 :     }
      69             : 
      70           0 :     ~GetPPDAttribs()
      71           0 :     {
      72           0 :         if( !m_aResult.isEmpty() )
      73           0 :             unlink( m_aResult.getStr() );
      74           0 :     }
      75             : 
      76           0 :     void unref()
      77             :     {
      78           0 :         if( --m_nRefs == 0 )
      79             :         {
      80           0 :             *m_pResetRunning = false;
      81           0 :             delete this;
      82             :         }
      83           0 :     }
      84             : 
      85           0 :     void executeCall()
      86             :     {
      87             :         // This CUPS method is not at all thread-safe we need
      88             :         // to dup the pointer to a static buffer it returns ASAP
      89           0 :         OString aResult = cupsGetPPD(m_aParameter.getStr());
      90           0 :         MutexGuard aGuard( *m_pSyncMutex );
      91           0 :         m_aResult = aResult;
      92           0 :         m_aCondition.set();
      93           0 :         unref();
      94           0 :     }
      95             : 
      96           0 :     OString waitResult( TimeValue *pDelay )
      97             :     {
      98           0 :         m_pSyncMutex->release();
      99             : 
     100           0 :         if (m_aCondition.wait( pDelay ) != Condition::result_ok
     101             :             )
     102             :         {
     103             :             #if OSL_DEBUG_LEVEL > 1
     104             :             fprintf( stderr, "cupsGetPPD %s timed out\n", m_aParameter.getStr() );
     105             :             #endif
     106             :         }
     107           0 :         m_pSyncMutex->acquire();
     108             : 
     109           0 :         OString aRetval = m_aResult;
     110           0 :         m_aResult = OString();
     111           0 :         unref();
     112             : 
     113           0 :         return aRetval;
     114             :     }
     115             : };
     116             : 
     117             : extern "C" {
     118           0 :     static void getPPDWorker(void* pData)
     119             :     {
     120           0 :         GetPPDAttribs* pAttribs = (GetPPDAttribs*)pData;
     121           0 :         pAttribs->executeCall();
     122           0 :     }
     123             : }
     124             : 
     125           0 : OString CUPSManager::threadedCupsGetPPD( const char* pPrinter )
     126             : {
     127           0 :     OString aResult;
     128             : 
     129           0 :     m_aGetPPDMutex.acquire();
     130             :     // if one thread hangs in cupsGetPPD already, don't start another
     131           0 :     if( ! m_bPPDThreadRunning )
     132             :     {
     133           0 :         m_bPPDThreadRunning = true;
     134             :         GetPPDAttribs* pAttribs = new GetPPDAttribs( pPrinter,
     135             :                                                      &m_bPPDThreadRunning,
     136           0 :                                                      &m_aGetPPDMutex );
     137             : 
     138           0 :         oslThread aThread = osl_createThread( getPPDWorker, pAttribs );
     139             : 
     140             :         TimeValue aValue;
     141           0 :         aValue.Seconds = 5;
     142           0 :         aValue.Nanosec = 0;
     143             : 
     144             :         // NOTE: waitResult release and acquires the GetPPD mutex
     145           0 :         aResult = pAttribs->waitResult( &aValue );
     146           0 :         osl_destroyThread( aThread );
     147             :     }
     148           0 :     m_aGetPPDMutex.release();
     149             : 
     150           0 :     return aResult;
     151             : }
     152             : 
     153           0 : static const char* setPasswordCallback( const char* pIn )
     154             : {
     155           0 :     const char* pRet = NULL;
     156             : 
     157           0 :     PrinterInfoManager& rMgr = PrinterInfoManager::get();
     158           0 :     if( rMgr.getType() == PrinterInfoManager::CUPS ) // sanity check
     159           0 :         pRet = static_cast<CUPSManager&>(rMgr).authenticateUser( pIn );
     160           0 :     return pRet;
     161             : }
     162             : 
     163             : /*
     164             :  *  CUPSManager class
     165             :  */
     166             : 
     167           9 : CUPSManager* CUPSManager::tryLoadCUPS()
     168             : {
     169           9 :     CUPSManager* pManager = NULL;
     170           9 :     static const char* pEnv = getenv("SAL_DISABLE_CUPS");
     171             : 
     172           9 :     if (!pEnv || !*pEnv)
     173           9 :         pManager = new CUPSManager();
     174           9 :     return pManager;
     175             : }
     176             : 
     177             : extern "C"
     178             : {
     179           9 : static void run_dest_thread_stub( void* pThis )
     180             : {
     181           9 :     CUPSManager::runDestThread( pThis );
     182           9 : }
     183             : }
     184             : 
     185           9 : CUPSManager::CUPSManager() :
     186             :         PrinterInfoManager( CUPS ),
     187             :         m_nDests( 0 ),
     188             :         m_pDests( NULL ),
     189             :         m_bNewDests( false ),
     190           9 :         m_bPPDThreadRunning( false )
     191             : {
     192           9 :     m_aDestThread = osl_createThread( run_dest_thread_stub, this );
     193           9 : }
     194             : 
     195           0 : CUPSManager::~CUPSManager()
     196             : {
     197           0 :     if( m_aDestThread )
     198             :     {
     199             :         // if the thread is still running here, then
     200             :         // cupsGetDests is hung; terminate the thread instead of joining
     201           0 :         osl_terminateThread( m_aDestThread );
     202           0 :         osl_destroyThread( m_aDestThread );
     203             :     }
     204             : 
     205           0 :     if (m_nDests && m_pDests)
     206           0 :         cupsFreeDests( m_nDests, (cups_dest_t*)m_pDests );
     207           0 : }
     208             : 
     209           9 : void CUPSManager::runDestThread( void* pThis )
     210             : {
     211           9 :     ((CUPSManager*)pThis)->runDests();
     212           9 : }
     213             : 
     214           9 : void CUPSManager::runDests()
     215             : {
     216             : #if OSL_DEBUG_LEVEL > 1
     217             :     fprintf( stderr, "starting cupsGetDests\n" );
     218             : #endif
     219           9 :     cups_dest_t* pDests = NULL;
     220             : 
     221             :     // n#722902 - do a fast-failing check for cups working *at all* first
     222             :     http_t* p_http;
     223           9 :     if( (p_http=httpConnectEncrypt(
     224             :              cupsServer(),
     225             :              ippPort(),
     226           9 :              cupsEncryption())) != NULL )
     227             :     {
     228             :         // neat, cups is up, clean up the canary
     229           9 :         httpClose(p_http);
     230             : 
     231           9 :         int nDests = cupsGetDests( &pDests );
     232             : #if OSL_DEBUG_LEVEL > 1
     233             :         fprintf( stderr, "came out of cupsGetDests\n" );
     234             : #endif
     235             : 
     236           9 :         osl::MutexGuard aGuard( m_aCUPSMutex );
     237           9 :         m_nDests = nDests;
     238           9 :         m_pDests = pDests;
     239           9 :         m_bNewDests = true;
     240             : #if OSL_DEBUG_LEVEL > 1
     241             :         fprintf( stderr, "finished cupsGetDests\n" );
     242             : #endif
     243             :     }
     244           9 : }
     245             : 
     246          18 : void CUPSManager::initialize()
     247             : {
     248             :     // get normal printers, clear printer list
     249          18 :     PrinterInfoManager::initialize();
     250             : 
     251             :     // check whether thread has completed
     252             :     // if not behave like old printing system
     253          18 :     osl::MutexGuard aGuard( m_aCUPSMutex );
     254             : 
     255          18 :     if( ! m_bNewDests )
     256             :         return;
     257             : 
     258             :     // dest thread has run, clean up
     259           9 :     if( m_aDestThread )
     260             :     {
     261           0 :         osl_joinWithThread( m_aDestThread );
     262           0 :         osl_destroyThread( m_aDestThread );
     263           0 :         m_aDestThread = NULL;
     264             :     }
     265           9 :     m_bNewDests = false;
     266             : 
     267             :     // clear old stuff
     268           9 :     m_aCUPSDestMap.clear();
     269             : 
     270           9 :     if( ! (m_nDests && m_pDests ) )
     271             :         return;
     272             : 
     273           0 :     if( isCUPSDisabled() )
     274             :         return;
     275             : 
     276             :     // check for CUPS server(?) > 1.2
     277             :     // since there is no API to query, check for options that were
     278             :     // introduced in dests with 1.2
     279             :     // this is needed to check for %%IncludeFeature support
     280             :     // (#i65684#, #i65491#)
     281           0 :     bool bUsePDF = false;
     282           0 :     cups_dest_t* pDest = ((cups_dest_t*)m_pDests);
     283             :     const char* pOpt = cupsGetOption( "printer-info",
     284             :                                                       pDest->num_options,
     285           0 :                                                       pDest->options );
     286           0 :     if( pOpt )
     287             :     {
     288           0 :         m_bUseIncludeFeature = true;
     289           0 :         bUsePDF = officecfg::Office::Common::Print::Option::Printer::PDFAsStandardPrintJobFormat::get();
     290             :     }
     291             : 
     292           0 :     m_aGlobalDefaults.setDefaultBackend(bUsePDF);
     293             : 
     294             :     // do not send include JobPatch; CUPS will insert that itself
     295             :     // TODO: currently unknown which versions of CUPS insert JobPatches
     296             :     // so currently it is assumed CUPS = don't insert JobPatch files
     297           0 :     m_bUseJobPatch = false;
     298             : 
     299           0 :     rtl_TextEncoding aEncoding = osl_getThreadTextEncoding();
     300           0 :     int nPrinter = m_nDests;
     301             : 
     302             :     // reset global default PPD options; these are queried on demand from CUPS
     303           0 :     m_aGlobalDefaults.m_pParser = NULL;
     304           0 :     m_aGlobalDefaults.m_aContext = PPDContext();
     305             : 
     306             :     // add CUPS printers, should there be a printer
     307             :     // with the same name as a CUPS printer, overwrite it
     308           0 :     while( nPrinter-- )
     309             :     {
     310           0 :         pDest = ((cups_dest_t*)m_pDests)+nPrinter;
     311           0 :         OUString aPrinterName = OStringToOUString( pDest->name, aEncoding );
     312           0 :         if( pDest->instance && *pDest->instance )
     313             :         {
     314           0 :             OUStringBuffer aBuf( 256 );
     315           0 :             aBuf.append( aPrinterName );
     316           0 :             aBuf.append( sal_Unicode( '/' ) );
     317           0 :             aBuf.append( OStringToOUString( pDest->instance, aEncoding ) );
     318           0 :             aPrinterName = aBuf.makeStringAndClear();
     319             :         }
     320             : 
     321             :         // initialize printer with possible configuration from psprint.conf
     322           0 :         bool bSetToGlobalDefaults = m_aPrinters.find( aPrinterName ) == m_aPrinters.end();
     323           0 :         Printer aPrinter = m_aPrinters[ aPrinterName ];
     324           0 :         if( bSetToGlobalDefaults )
     325           0 :             aPrinter.m_aInfo = m_aGlobalDefaults;
     326           0 :         aPrinter.m_aInfo.m_aPrinterName = aPrinterName;
     327           0 :         if( pDest->is_default )
     328           0 :             m_aDefaultPrinter = aPrinterName;
     329             : 
     330           0 :         for( int k = 0; k < pDest->num_options; k++ )
     331             :         {
     332           0 :             if(!strcmp(pDest->options[k].name, "printer-info"))
     333           0 :                 aPrinter.m_aInfo.m_aComment=OStringToOUString(pDest->options[k].value, aEncoding);
     334           0 :             if(!strcmp(pDest->options[k].name, "printer-location"))
     335           0 :                 aPrinter.m_aInfo.m_aLocation=OStringToOUString(pDest->options[k].value, aEncoding);
     336             :         }
     337             : 
     338             : 
     339           0 :         OUStringBuffer aBuf( 256 );
     340           0 :         aBuf.appendAscii( "CUPS:" );
     341           0 :         aBuf.append( aPrinterName );
     342             :         // note: the parser that goes with the PrinterInfo
     343             :         // is created implicitly by the JobData::operator=()
     344             :         // when it detects the NULL ptr m_pParser.
     345             :         // if we wanted to fill in the parser here this
     346             :         // would mean we'd have to download PPDs for each and
     347             :         // every printer - which would be really bad runtime
     348             :         // behaviour
     349           0 :         aPrinter.m_aInfo.m_pParser = NULL;
     350           0 :         aPrinter.m_aInfo.m_aContext.setParser( NULL );
     351           0 :         boost::unordered_map< OUString, PPDContext, OUStringHash >::const_iterator c_it = m_aDefaultContexts.find( aPrinterName );
     352           0 :         if( c_it != m_aDefaultContexts.end() )
     353             :         {
     354           0 :             aPrinter.m_aInfo.m_pParser = c_it->second.getParser();
     355           0 :             aPrinter.m_aInfo.m_aContext = c_it->second;
     356             :         }
     357           0 :         aPrinter.m_aInfo.setDefaultBackend(bUsePDF);
     358           0 :         aPrinter.m_aInfo.m_aDriverName = aBuf.makeStringAndClear();
     359           0 :         aPrinter.m_bModified = false;
     360             : 
     361           0 :         m_aPrinters[ aPrinter.m_aInfo.m_aPrinterName ] = aPrinter;
     362           0 :         m_aCUPSDestMap[ aPrinter.m_aInfo.m_aPrinterName ] = nPrinter;
     363           0 :     }
     364             : 
     365             :     // remove everything that is not a CUPS printer and not
     366             :     // a special purpose printer (PDF, Fax)
     367           0 :     std::list< OUString > aRemovePrinters;
     368           0 :     for( boost::unordered_map< OUString, Printer, OUStringHash >::iterator it = m_aPrinters.begin();
     369           0 :          it != m_aPrinters.end(); ++it )
     370             :     {
     371           0 :         if( m_aCUPSDestMap.find( it->first ) != m_aCUPSDestMap.end() )
     372           0 :             continue;
     373             : 
     374           0 :         if( !it->second.m_aInfo.m_aFeatures.isEmpty() )
     375           0 :             continue;
     376           0 :         aRemovePrinters.push_back( it->first );
     377             :     }
     378           0 :     while( aRemovePrinters.begin() != aRemovePrinters.end() )
     379             :     {
     380           0 :         m_aPrinters.erase( aRemovePrinters.front() );
     381           0 :         aRemovePrinters.pop_front();
     382             :     }
     383             : 
     384           0 :     cupsSetPasswordCB( setPasswordCallback );
     385             : }
     386             : 
     387           0 : static void updatePrinterContextInfo( ppd_group_t* pPPDGroup, PPDContext& rContext )
     388             : {
     389           0 :     rtl_TextEncoding aEncoding = osl_getThreadTextEncoding();
     390           0 :     for( int i = 0; i < pPPDGroup->num_options; i++ )
     391             :     {
     392           0 :         ppd_option_t* pOption = pPPDGroup->options + i;
     393           0 :         for( int n = 0; n < pOption->num_choices; n++ )
     394             :         {
     395           0 :             ppd_choice_t* pChoice = pOption->choices + n;
     396           0 :             if( pChoice->marked )
     397             :             {
     398           0 :                 const PPDKey* pKey = rContext.getParser()->getKey( OStringToOUString( pOption->keyword, aEncoding ) );
     399           0 :                 if( pKey )
     400             :                 {
     401           0 :                     const PPDValue* pValue = pKey->getValue( OStringToOUString( pChoice->choice, aEncoding ) );
     402           0 :                     if( pValue )
     403             :                     {
     404           0 :                         if( pValue != pKey->getDefaultValue() )
     405             :                         {
     406           0 :                             rContext.setValue( pKey, pValue, true );
     407             : #if OSL_DEBUG_LEVEL > 1
     408             :                             fprintf( stderr, "key %s is set to %s\n", pOption->keyword, pChoice->choice );
     409             : #endif
     410             : 
     411             :                         }
     412             : #if OSL_DEBUG_LEVEL > 1
     413             :                         else
     414             :                             fprintf( stderr, "key %s is defaulted to %s\n", pOption->keyword, pChoice->choice );
     415             : #endif
     416             :                     }
     417             : #if OSL_DEBUG_LEVEL > 1
     418             :                     else
     419             :                         fprintf( stderr, "caution: value %s not found in key %s\n", pChoice->choice, pOption->keyword );
     420             : #endif
     421             :                 }
     422             : #if OSL_DEBUG_LEVEL > 1
     423             :                 else
     424             :                     fprintf( stderr, "caution: key %s not found in parser\n", pOption->keyword );
     425             : #endif
     426             :             }
     427             :         }
     428             :     }
     429             : 
     430             :     // recurse through subgroups
     431           0 :     for( int g = 0; g < pPPDGroup->num_subgroups; g++ )
     432             :     {
     433           0 :         updatePrinterContextInfo( pPPDGroup->subgroups + g, rContext );
     434             :     }
     435           0 : }
     436             : 
     437           0 : const PPDParser* CUPSManager::createCUPSParser( const OUString& rPrinter )
     438             : {
     439           0 :     const PPDParser* pNewParser = NULL;
     440           0 :     OUString aPrinter;
     441             : 
     442           0 :     if( rPrinter.compareToAscii( "CUPS:", 5 ) == 0 )
     443           0 :         aPrinter = rPrinter.copy( 5 );
     444             :     else
     445           0 :         aPrinter = rPrinter;
     446             : 
     447           0 :     if( m_aCUPSMutex.tryToAcquire() )
     448             :     {
     449           0 :         if( m_nDests && m_pDests && ! isCUPSDisabled() )
     450             :         {
     451             :             boost::unordered_map< OUString, int, OUStringHash >::iterator dest_it =
     452           0 :             m_aCUPSDestMap.find( aPrinter );
     453           0 :             if( dest_it != m_aCUPSDestMap.end() )
     454             :             {
     455           0 :                 cups_dest_t* pDest = ((cups_dest_t*)m_pDests) + dest_it->second;
     456           0 :                 OString aPPDFile = threadedCupsGetPPD( pDest->name );
     457             :                 #if OSL_DEBUG_LEVEL > 1
     458             :                 fprintf( stderr, "PPD for %s is %s\n", OUStringToOString( aPrinter, osl_getThreadTextEncoding() ).getStr(), aPPDFile.getStr() );
     459             :                 #endif
     460           0 :                 if( !aPPDFile.isEmpty() )
     461             :                 {
     462           0 :                     rtl_TextEncoding aEncoding = osl_getThreadTextEncoding();
     463           0 :                     OUString aFileName( OStringToOUString( aPPDFile, aEncoding ) );
     464             :                     // update the printer info with context information
     465           0 :                     ppd_file_t* pPPD = ppdOpenFile( aPPDFile.getStr() );
     466           0 :                     if( pPPD )
     467             :                     {
     468             :                         // create the new parser
     469           0 :                         PPDParser* pCUPSParser = new PPDParser( aFileName );
     470           0 :                         pCUPSParser->m_aFile = rPrinter;
     471           0 :                         pNewParser = pCUPSParser;
     472             : 
     473           0 :                         /*int nConflicts =*/ cupsMarkOptions( pPPD, pDest->num_options, pDest->options );
     474             :                         #if OSL_DEBUG_LEVEL > 1
     475             :                         fprintf( stderr, "processing the following options for printer %s (instance %s):\n",
     476             :                         pDest->name, pDest->instance );
     477             :                         for( int k = 0; k < pDest->num_options; k++ )
     478             :                             fprintf( stderr, "   \"%s\" = \"%s\"\n",
     479             :                         pDest->options[k].name,
     480             :                         pDest->options[k].value );
     481             :                         #endif
     482           0 :                         PrinterInfo& rInfo = m_aPrinters[ aPrinter ].m_aInfo;
     483             : 
     484             :                         // remember the default context for later use
     485           0 :                         PPDContext& rContext = m_aDefaultContexts[ aPrinter ];
     486           0 :                         rContext.setParser( pNewParser );
     487             :                         // set system default paper; printer CUPS PPD options
     488             :                         // may overwrite it
     489           0 :                         setDefaultPaper( rContext );
     490           0 :                         for( int i = 0; i < pPPD->num_groups; i++ )
     491           0 :                             updatePrinterContextInfo( pPPD->groups + i, rContext );
     492             : 
     493           0 :                         rInfo.m_pParser = pNewParser;
     494           0 :                         rInfo.m_aContext = rContext;
     495             : 
     496             :                         // clean up the mess
     497           0 :                         ppdClose( pPPD );
     498             :                     }
     499             :                     #if OSL_DEBUG_LEVEL > 1
     500             :                     else
     501             :                         fprintf( stderr, "ppdOpenFile failed, falling back to generic driver\n" );
     502             :                     #endif
     503             : 
     504             :                     // remove temporary PPD file
     505           0 :                     unlink( aPPDFile.getStr() );
     506           0 :                 }
     507             :                 #if OSL_DEBUG_LEVEL > 1
     508             :                 else
     509             :                     fprintf( stderr, "cupsGetPPD failed, falling back to generic driver\n" );
     510             :                 #endif
     511             :             }
     512             :             #if OSL_DEBUG_LEVEL > 1
     513             :             else
     514             :                 fprintf( stderr, "no dest found for printer %s\n", OUStringToOString( aPrinter, osl_getThreadTextEncoding() ).getStr() );
     515             :             #endif
     516             :         }
     517           0 :         m_aCUPSMutex.release();
     518             :     }
     519             :     #if OSL_DEBUG_LEVEL >1
     520             :     else
     521             :         fprintf( stderr, "could not acquire CUPS mutex !!!\n" );
     522             :     #endif
     523             : 
     524           0 :     if( ! pNewParser )
     525             :     {
     526             :         // get the default PPD
     527           0 :         pNewParser = PPDParser::getParser( String( RTL_CONSTASCII_USTRINGPARAM( "SGENPRT" ) ) );
     528             : 
     529           0 :         PrinterInfo& rInfo = m_aPrinters[ aPrinter ].m_aInfo;
     530             : 
     531           0 :         rInfo.m_pParser = pNewParser;
     532           0 :         rInfo.m_aContext.setParser( pNewParser );
     533             :     }
     534             : 
     535           0 :     return pNewParser;
     536             : }
     537             : 
     538           0 : void CUPSManager::setupJobContextData( JobData& rData )
     539             : {
     540             :     boost::unordered_map< OUString, int, OUStringHash >::iterator dest_it =
     541           0 :         m_aCUPSDestMap.find( rData.m_aPrinterName );
     542             : 
     543           0 :     if( dest_it == m_aCUPSDestMap.end() )
     544           0 :         return PrinterInfoManager::setupJobContextData( rData );
     545             : 
     546             :     boost::unordered_map< OUString, Printer, OUStringHash >::iterator p_it =
     547           0 :         m_aPrinters.find( rData.m_aPrinterName );
     548           0 :     if( p_it == m_aPrinters.end() ) // huh ?
     549             :     {
     550             : #if OSL_DEBUG_LEVEL > 1
     551             :         fprintf( stderr, "CUPS printer list in disorder, no dest for printer %s !\n", OUStringToOString( rData.m_aPrinterName, osl_getThreadTextEncoding() ).getStr() );
     552             : #endif
     553             :         return;
     554             :     }
     555             : 
     556           0 :     if( p_it->second.m_aInfo.m_pParser == NULL )
     557             :     {
     558             :         // in turn calls createCUPSParser
     559             :         // which updates the printer info
     560           0 :         p_it->second.m_aInfo.m_pParser = PPDParser::getParser( p_it->second.m_aInfo.m_aDriverName );
     561             :     }
     562           0 :     if( p_it->second.m_aInfo.m_aContext.getParser() == NULL )
     563             :     {
     564           0 :         OUString aPrinter;
     565           0 :         if( p_it->second.m_aInfo.m_aDriverName.compareToAscii( "CUPS:", 5 ) == 0 )
     566           0 :             aPrinter = p_it->second.m_aInfo.m_aDriverName.copy( 5 );
     567             :         else
     568           0 :             aPrinter = p_it->second.m_aInfo.m_aDriverName;
     569             : 
     570           0 :         p_it->second.m_aInfo.m_aContext = m_aDefaultContexts[ aPrinter ];
     571             :     }
     572             : 
     573           0 :     rData.m_pParser     = p_it->second.m_aInfo.m_pParser;
     574           0 :     rData.m_aContext    = p_it->second.m_aInfo.m_aContext;
     575             : }
     576             : 
     577           0 : FILE* CUPSManager::startSpool( const OUString& rPrintername, bool bQuickCommand )
     578             : {
     579             :     OSL_TRACE( "endSpool: %s, %s",
     580             :                rtl::OUStringToOString( rPrintername, RTL_TEXTENCODING_UTF8 ).getStr(),
     581             :               bQuickCommand ? "true" : "false" );
     582             : 
     583           0 :     if( m_aCUPSDestMap.find( rPrintername ) == m_aCUPSDestMap.end() )
     584             :     {
     585             :         OSL_TRACE( "defer to PrinterInfoManager::startSpool" );
     586           0 :         return PrinterInfoManager::startSpool( rPrintername, bQuickCommand );
     587             :     }
     588             : 
     589           0 :     OUString aTmpURL, aTmpFile;
     590           0 :     osl_createTempFile( NULL, NULL, &aTmpURL.pData );
     591           0 :     osl_getSystemPathFromFileURL( aTmpURL.pData, &aTmpFile.pData );
     592           0 :     OString aSysFile = OUStringToOString( aTmpFile, osl_getThreadTextEncoding() );
     593           0 :     FILE* fp = fopen( aSysFile.getStr(), "w" );
     594           0 :     if( fp )
     595           0 :         m_aSpoolFiles[fp] = aSysFile;
     596             : 
     597           0 :     return fp;
     598             : }
     599             : 
     600             : struct less_ppd_key : public ::std::binary_function<double, double, bool>
     601             : {
     602           0 :     bool operator()(const PPDKey* left, const PPDKey* right)
     603           0 :     { return left->getOrderDependency() < right->getOrderDependency(); }
     604             : };
     605             : 
     606           0 : void CUPSManager::getOptionsFromDocumentSetup( const JobData& rJob, bool bBanner, int& rNumOptions, void** rOptions ) const
     607             : {
     608           0 :     rNumOptions = 0;
     609           0 :     *rOptions = NULL;
     610             : 
     611             :     // emit features ordered to OrderDependency
     612             :     // ignore features that are set to default
     613             : 
     614             :     // sanity check
     615           0 :     if( rJob.m_pParser == rJob.m_aContext.getParser() && rJob.m_pParser )
     616             :     {
     617             :         int i;
     618           0 :         int nKeys = rJob.m_aContext.countValuesModified();
     619           0 :         ::std::vector< const PPDKey* > aKeys( nKeys );
     620           0 :         for(  i = 0; i < nKeys; i++ )
     621           0 :             aKeys[i] = rJob.m_aContext.getModifiedKey( i );
     622           0 :         ::std::sort( aKeys.begin(), aKeys.end(), less_ppd_key() );
     623             : 
     624           0 :         for( i = 0; i < nKeys; i++ )
     625             :         {
     626           0 :             const PPDKey* pKey = aKeys[i];
     627           0 :             const PPDValue* pValue = rJob.m_aContext.getValue( pKey );
     628           0 :             if(pValue && pValue->m_eType == eInvocation && pValue->m_aValue.Len() )
     629             :             {
     630           0 :                 OString aKey = OUStringToOString( pKey->getKey(), RTL_TEXTENCODING_ASCII_US );
     631           0 :                 OString aValue = OUStringToOString( pValue->m_aOption, RTL_TEXTENCODING_ASCII_US );
     632           0 :                 rNumOptions = cupsAddOption( aKey.getStr(), aValue.getStr(), rNumOptions, (cups_option_t**)rOptions );
     633             :             }
     634           0 :         }
     635             :     }
     636             : 
     637           0 :     if( rJob.m_nPDFDevice > 0 && rJob.m_nCopies > 1 )
     638             :     {
     639           0 :         rtl::OString aVal( rtl::OString::valueOf( sal_Int32( rJob.m_nCopies ) ) );
     640           0 :         rNumOptions = cupsAddOption( "copies", aVal.getStr(), rNumOptions, (cups_option_t**)rOptions );
     641             :     }
     642           0 :     if( ! bBanner )
     643             :     {
     644           0 :         rNumOptions = cupsAddOption( "job-sheets", "none", rNumOptions, (cups_option_t**)rOptions );
     645             :     }
     646           0 : }
     647             : 
     648           0 : int CUPSManager::endSpool( const OUString& rPrintername, const OUString& rJobTitle, FILE* pFile, const JobData& rDocumentJobData, bool bBanner )
     649             : {
     650             :     OSL_TRACE( "endSpool: %s, %s, copy count = %d",
     651             :                rtl::OUStringToOString( rPrintername, RTL_TEXTENCODING_UTF8 ).getStr(),
     652             :                rtl::OUStringToOString( rJobTitle, RTL_TEXTENCODING_UTF8 ).getStr(),
     653             :                rDocumentJobData.m_nCopies
     654             :                );
     655             : 
     656           0 :     int nJobID = 0;
     657             : 
     658           0 :     osl::MutexGuard aGuard( m_aCUPSMutex );
     659             : 
     660             :     boost::unordered_map< OUString, int, OUStringHash >::iterator dest_it =
     661           0 :         m_aCUPSDestMap.find( rPrintername );
     662           0 :     if( dest_it == m_aCUPSDestMap.end() )
     663             :     {
     664             :         OSL_TRACE( "defer to PrinterInfoManager::endSpool" );
     665           0 :         return PrinterInfoManager::endSpool( rPrintername, rJobTitle, pFile, rDocumentJobData, bBanner );
     666             :     }
     667             : 
     668           0 :     boost::unordered_map< FILE*, OString, FPtrHash >::const_iterator it = m_aSpoolFiles.find( pFile );
     669           0 :     if( it != m_aSpoolFiles.end() )
     670             :     {
     671           0 :         fclose( pFile );
     672           0 :         rtl_TextEncoding aEnc = osl_getThreadTextEncoding();
     673             : 
     674             :         // setup cups options
     675           0 :         int nNumOptions = 0;
     676           0 :         cups_option_t* pOptions = NULL;
     677           0 :         getOptionsFromDocumentSetup( rDocumentJobData, bBanner, nNumOptions, (void**)&pOptions );
     678             : 
     679           0 :         cups_dest_t* pDest = ((cups_dest_t*)m_pDests) + dest_it->second;
     680             :         nJobID = cupsPrintFile( pDest->name,
     681           0 :         it->second.getStr(),
     682             :         OUStringToOString( rJobTitle, aEnc ).getStr(),
     683           0 :         nNumOptions, pOptions );
     684             : #if OSL_DEBUG_LEVEL > 1
     685             :         fprintf( stderr, "cupsPrintFile( %s, %s, %s, %d, %p ) returns %d\n",
     686             :                     pDest->name,
     687             :                     it->second.getStr(),
     688             :                     OUStringToOString( rJobTitle, aEnc ).getStr(),
     689             :                     nNumOptions,
     690             :                     pOptions,
     691             :                     nJobID
     692             :                     );
     693             :         for( int n = 0; n < nNumOptions; n++ )
     694             :             fprintf( stderr, "    option %s=%s\n", pOptions[n].name, pOptions[n].value );
     695             :         OString aCmd( "cp " );
     696             :         aCmd = aCmd + it->second;
     697             :         aCmd = aCmd + OString( " $HOME/cupsprint.ps" );
     698             :         system( aCmd.getStr() );
     699             : #endif
     700             : 
     701           0 :         unlink( it->second.getStr() );
     702           0 :         m_aSpoolFiles.erase( pFile );
     703           0 :         if( pOptions )
     704           0 :             cupsFreeOptions( nNumOptions, pOptions );
     705             :     }
     706             : 
     707           0 :     return nJobID;
     708             : }
     709             : 
     710             : 
     711           0 : void CUPSManager::changePrinterInfo( const OUString& rPrinter, const PrinterInfo& rNewInfo )
     712             : {
     713           0 :     PrinterInfoManager::changePrinterInfo( rPrinter, rNewInfo );
     714           0 : }
     715             : 
     716           9 : bool CUPSManager::checkPrintersChanged( bool bWait )
     717             : {
     718           9 :     bool bChanged = false;
     719           9 :     if( bWait )
     720             :     {
     721           9 :         if(  m_aDestThread )
     722             :         {
     723             :             // initial asynchronous detection still running
     724             :             #if OSL_DEBUG_LEVEL > 1
     725             :             fprintf( stderr, "syncing cups discovery thread\n" );
     726             :             #endif
     727           9 :             osl_joinWithThread( m_aDestThread );
     728           9 :             osl_destroyThread( m_aDestThread );
     729           9 :             m_aDestThread = NULL;
     730             :             #if OSL_DEBUG_LEVEL > 1
     731             :             fprintf( stderr, "done: syncing cups discovery thread\n" );
     732             :             #endif
     733             :         }
     734             :         else
     735             :         {
     736             :             // #i82321# check for cups printer updates
     737             :             // with this change the whole asynchronous detection in a thread is
     738             :             // almost useless. The only relevance left is for some stalled systems
     739             :             // where the user can set SAL_DISABLE_SYNCHRONOUS_PRINTER_DETECTION
     740             :             // (see vcl/unx/source/gdi/salprnpsp.cxx)
     741             :             // so that checkPrintersChanged( true ) will never be called
     742             : 
     743             :             // there is no way to query CUPS whether the printer list has changed
     744             :             // so get the dest list anew
     745           0 :             if( m_nDests && m_pDests )
     746           0 :                 cupsFreeDests( m_nDests, (cups_dest_t*)m_pDests );
     747           0 :             m_nDests = 0;
     748           0 :             m_pDests = NULL;
     749           0 :             runDests();
     750             :         }
     751             :     }
     752           9 :     if( m_aCUPSMutex.tryToAcquire() )
     753             :     {
     754           9 :         bChanged = m_bNewDests;
     755           9 :         m_aCUPSMutex.release();
     756             :     }
     757             : 
     758           9 :     if( ! bChanged )
     759             :     {
     760           0 :         bChanged = PrinterInfoManager::checkPrintersChanged( bWait );
     761             :         // #i54375# ensure new merging with CUPS list in :initialize
     762           0 :         if( bChanged )
     763           0 :             m_bNewDests = true;
     764             :     }
     765             : 
     766           9 :     if( bChanged )
     767           9 :         initialize();
     768             : 
     769           9 :     return bChanged;
     770             : }
     771             : 
     772           0 : bool CUPSManager::addPrinter( const OUString& rName, const OUString& rDriver )
     773             : {
     774             :     // don't touch the CUPS printers
     775           0 :     if( m_aCUPSDestMap.find( rName ) != m_aCUPSDestMap.end() ||
     776           0 :         rDriver.compareToAscii( "CUPS:", 5 ) == 0
     777             :         )
     778           0 :         return false;
     779           0 :     return PrinterInfoManager::addPrinter( rName, rDriver );
     780             : }
     781             : 
     782           0 : bool CUPSManager::removePrinter( const OUString& rName, bool bCheck )
     783             : {
     784             :     // don't touch the CUPS printers
     785           0 :     if( m_aCUPSDestMap.find( rName ) != m_aCUPSDestMap.end() )
     786           0 :         return false;
     787           0 :     return PrinterInfoManager::removePrinter( rName, bCheck );
     788             : }
     789             : 
     790           0 : bool CUPSManager::setDefaultPrinter( const OUString& rName )
     791             : {
     792           0 :     bool bSuccess = false;
     793             :     boost::unordered_map< OUString, int, OUStringHash >::iterator nit =
     794           0 :         m_aCUPSDestMap.find( rName );
     795           0 :     if( nit != m_aCUPSDestMap.end() && m_aCUPSMutex.tryToAcquire() )
     796             :     {
     797           0 :         cups_dest_t* pDests = (cups_dest_t*)m_pDests;
     798           0 :         for( int i = 0; i < m_nDests; i++ )
     799           0 :             pDests[i].is_default = 0;
     800           0 :         pDests[ nit->second ].is_default = 1;
     801           0 :         cupsSetDests( m_nDests, (cups_dest_t*)m_pDests );
     802           0 :         m_aDefaultPrinter = rName;
     803           0 :         m_aCUPSMutex.release();
     804           0 :         bSuccess = true;
     805             :     }
     806             :     else
     807           0 :         bSuccess = PrinterInfoManager::setDefaultPrinter( rName );
     808             : 
     809           0 :     return bSuccess;
     810             : }
     811             : 
     812           0 : bool CUPSManager::writePrinterConfig()
     813             : {
     814           0 :     bool bDestModified = false;
     815           0 :     rtl_TextEncoding aEncoding = osl_getThreadTextEncoding();
     816             : 
     817           0 :     for( boost::unordered_map< OUString, Printer, OUStringHash >::iterator prt =
     818           0 :              m_aPrinters.begin(); prt != m_aPrinters.end(); ++prt )
     819             :     {
     820             :         boost::unordered_map< OUString, int, OUStringHash >::iterator nit =
     821           0 :             m_aCUPSDestMap.find( prt->first );
     822           0 :         if( nit == m_aCUPSDestMap.end() )
     823           0 :             continue;
     824             : 
     825           0 :         if( ! prt->second.m_bModified )
     826           0 :             continue;
     827             : 
     828           0 :         if( m_aCUPSMutex.tryToAcquire() )
     829             :         {
     830           0 :             bDestModified = true;
     831           0 :             cups_dest_t* pDest = ((cups_dest_t*)m_pDests) + nit->second;
     832           0 :             PrinterInfo& rInfo = prt->second.m_aInfo;
     833             : 
     834             :             // create new option list
     835           0 :             int nNewOptions = 0;
     836           0 :             cups_option_t* pNewOptions = NULL;
     837           0 :             int nValues = rInfo.m_aContext.countValuesModified();
     838           0 :             for( int i = 0; i < nValues; i++ )
     839             :             {
     840           0 :                 const PPDKey* pKey = rInfo.m_aContext.getModifiedKey( i );
     841           0 :                 const PPDValue* pValue = rInfo.m_aContext.getValue( pKey );
     842           0 :                 if( pKey && pValue ) // sanity check
     843             :                 {
     844           0 :                     OString aName = OUStringToOString( pKey->getKey(), aEncoding );
     845           0 :                     OString aValue = OUStringToOString( pValue->m_aOption, aEncoding );
     846           0 :                     nNewOptions = cupsAddOption( aName.getStr(), aValue.getStr(), nNewOptions, &pNewOptions );
     847             :                 }
     848             :             }
     849             :             // set PPD options on CUPS dest
     850           0 :             cupsFreeOptions( pDest->num_options, pDest->options );
     851           0 :             pDest->num_options = nNewOptions;
     852           0 :             pDest->options = pNewOptions;
     853           0 :             m_aCUPSMutex.release();
     854             :         }
     855             :     }
     856           0 :     if( bDestModified && m_aCUPSMutex.tryToAcquire() )
     857             :     {
     858           0 :         cupsSetDests( m_nDests, (cups_dest_t*)m_pDests );
     859           0 :         m_aCUPSMutex.release();
     860             :     }
     861             : 
     862           0 :     return PrinterInfoManager::writePrinterConfig();
     863             : }
     864             : 
     865           0 : bool CUPSManager::addOrRemovePossible() const
     866             : {
     867           0 :     return (m_nDests && m_pDests && ! isCUPSDisabled())? false : PrinterInfoManager::addOrRemovePossible();
     868             : }
     869             : 
     870           0 : const char* CUPSManager::authenticateUser( const char* /*pIn*/ )
     871             : {
     872           0 :     const char* pRet = NULL;
     873             : 
     874           0 :     OUString aLib(_XSALSET_LIBNAME );
     875           0 :     oslModule pLib = osl_loadModule( aLib.pData, SAL_LOADMODULE_LAZY );
     876           0 :     if( pLib )
     877             :     {
     878           0 :         OUString aSym( "Sal_authenticateQuery"  );
     879             :         bool (*getpw)( const OString& rServer, OString& rUser, OString& rPw) =
     880           0 :             (bool(*)(const OString&,OString&,OString&))osl_getFunctionSymbol( pLib, aSym.pData );
     881           0 :         if( getpw )
     882             :         {
     883           0 :             osl::MutexGuard aGuard( m_aCUPSMutex );
     884             : 
     885           0 :             OString aUser = cupsUser();
     886           0 :             OString aServer = cupsServer();
     887           0 :             OString aPassword;
     888           0 :             if( getpw( aServer, aUser, aPassword ) )
     889             :             {
     890           0 :                 m_aPassword = aPassword;
     891           0 :                 m_aUser = aUser;
     892           0 :                 cupsSetUser( m_aUser.getStr() );
     893           0 :                 pRet = m_aPassword.getStr();
     894           0 :             }
     895             :         }
     896           0 :         osl_unloadModule( pLib );
     897             :     }
     898             : #if OSL_DEBUG_LEVEL > 1
     899             :     else fprintf( stderr, "loading of module %s failed\n", OUStringToOString( aLib, osl_getThreadTextEncoding() ).getStr() );
     900             : #endif
     901             : 
     902           0 :     return pRet;
     903             : }
     904             : 
     905             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10