vcl/source/gdi/jobset.cxx

   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 #include <rtl/alloc.h>
  21 #include <rtl/ustring.hxx>
  22 #include <tools/stream.hxx>
  23 #include <vcl/jobset.hxx>
  24 #include <jobset.h>
  25 #include <memory>
  26 #include <rtl/instance.hxx>
  27
  28 #define JOBSET_FILE364_SYSTEM   ((sal_uInt16)0xFFFF)
  29 #define JOBSET_FILE605_SYSTEM   ((sal_uInt16)0xFFFE)
  30
  31 struct ImplOldJobSetupData
  32 {
  33     char    cPrinterName[64];
  34     char    cDeviceName[32];
  35     char    cPortName[32];
  36     char    cDriverName[32];
  37 };
  38
  39 struct Impl364JobSetupData
  40 {
  41     SVBT16  nSize;
  42     SVBT16  nSystem;
  43     SVBT32  nDriverDataLen;
  44     SVBT16  nOrientation;
  45     SVBT16  nPaperBin;
  46     SVBT16  nPaperFormat;
  47     SVBT32  nPaperWidth;
  48     SVBT32  nPaperHeight;
  49 };
  50
  51 ImplJobSetup::ImplJobSetup()
  52 {
  53     mnSystem            = 0;
  54     meOrientation       = Orientation::Portrait;
  55     meDuplexMode        = DuplexMode::Unknown;
  56     mnPaperBin          = 0;
  57     mePaperFormat       = PAPER_USER;
  58     mnPaperWidth        = 0;
  59     mnPaperHeight       = 0;
  60     mnDriverDataLen     = 0;
  61     mpDriverData        = nullptr;
  62     mbPapersizeFromSetup = false;
  63 }
  64
  65 ImplJobSetup::ImplJobSetup( const ImplJobSetup& rJobSetup ) :
  66     mnSystem( rJobSetup.GetSystem() ),
  67     maPrinterName( rJobSetup.GetPrinterName() ),
  68     maDriver( rJobSetup.GetDriver() ),
  69     meOrientation( rJobSetup.GetOrientation() ),
  70     meDuplexMode( rJobSetup.GetDuplexMode() ),
  71     mnPaperBin( rJobSetup.GetPaperBin() ),
  72     mePaperFormat( rJobSetup.GetPaperFormat() ),
  73     mnPaperWidth( rJobSetup.GetPaperWidth() ),
  74     mnPaperHeight( rJobSetup.GetPaperHeight() ),
  75     mnDriverDataLen( rJobSetup.GetDriverDataLen() ),
  76     mbPapersizeFromSetup( rJobSetup.GetPapersizeFromSetup() ),
  77     maValueMap( rJobSetup.GetValueMap() )
  78  {
  79     if ( rJobSetup.GetDriverData() )
  80     {
  81         mpDriverData = static_cast<sal_uInt8*>(rtl_allocateMemory( mnDriverDataLen ));
  82         memcpy( mpDriverData, rJobSetup.GetDriverData(), mnDriverDataLen );
  83     }
  84     else
  85         mpDriverData = nullptr;
  86 }
  87
  88 ImplJobSetup::~ImplJobSetup()
  89 {
  90     rtl_freeMemory( mpDriverData );
  91 }
  92
  93 void ImplJobSetup::SetSystem(sal_uInt16 nSystem)
  94 {
  95     mnSystem = nSystem;
  96 }
  97
  98 void ImplJobSetup::SetPrinterName(const OUString& rPrinterName)
  99 {
 100     maPrinterName = rPrinterName;
 101 }
 102
 103 void ImplJobSetup::SetDriver(const OUString& rDriver)
 104 {
 105     maDriver = rDriver;
 106 }
 107
 108 void ImplJobSetup::SetOrientation(Orientation eOrientation)
 109 {
 110     meOrientation = eOrientation;
 111 }
 112
 113 void ImplJobSetup::SetDuplexMode(DuplexMode eDuplexMode)
 114 {
 115     meDuplexMode = eDuplexMode;
 116 }
 117
 118 void ImplJobSetup::SetPaperBin(sal_uInt16 nPaperBin)
 119 {
 120     mnPaperBin = nPaperBin;
 121 }
 122
 123 void ImplJobSetup::SetPaperFormat(Paper ePaperFormat)
 124 {
 125     mePaperFormat = ePaperFormat;
 126 }
 127
 128 void ImplJobSetup::SetPaperWidth(long nPaperWidth)
 129 {
 130     mnPaperWidth = nPaperWidth;
 131 }
 132
 133 void ImplJobSetup::SetPaperHeight(long nPaperHeight)
 134 {
 135     mnPaperHeight = nPaperHeight;
 136 }
 137
 138 void ImplJobSetup::SetDriverDataLen(sal_uInt32 nDriverDataLen)
 139 {
 140     mnDriverDataLen = nDriverDataLen;
 141 }
 142
 143 void ImplJobSetup::SetDriverData(sal_uInt8* pDriverData)
 144 {
 145     mpDriverData = pDriverData;
 146 }
 147
 148 void ImplJobSetup::SetPapersizeFromSetup(bool bPapersizeFromSetup)
 149 {
 150     mbPapersizeFromSetup = bPapersizeFromSetup;
 151 }
 152
 153 void ImplJobSetup::SetValueMap( const OUString& rKey, const OUString& rValue )
 154 {
 155     maValueMap [ rKey ] = rValue;
 156 }
 157
 158 JobSetup& JobSetup::operator=( const JobSetup& rJobSetup )
 159 {
 160     mpData = rJobSetup.mpData;
 161     return *this;
 162 }
 163
 164 JobSetup& JobSetup::operator=( JobSetup&& rJobSetup )
 165 {
 166     mpData = std::move(rJobSetup.mpData);
 167     return *this;
 168 }
 169
 170 bool ImplJobSetup::operator==( const ImplJobSetup& rImplJobSetup ) const
 171 {
 172     return mnSystem          == rImplJobSetup.mnSystem        &&
 173          maPrinterName     == rImplJobSetup.maPrinterName   &&
 174          maDriver          == rImplJobSetup.maDriver        &&
 175          meOrientation     == rImplJobSetup.meOrientation   &&
 176          meDuplexMode      == rImplJobSetup.meDuplexMode    &&
 177          mnPaperBin        == rImplJobSetup.mnPaperBin      &&
 178          mePaperFormat     == rImplJobSetup.mePaperFormat   &&
 179          mnPaperWidth      == rImplJobSetup.mnPaperWidth    &&
 180          mnPaperHeight     == rImplJobSetup.mnPaperHeight   &&
 181          mnDriverDataLen   == rImplJobSetup.mnDriverDataLen &&
 182          maValueMap        == rImplJobSetup.maValueMap      &&
 183          memcmp( mpDriverData, rImplJobSetup.mpDriverData, mnDriverDataLen ) == 0;
 184 }
 185
 186 namespace
 187 {
 188     struct theGlobalDefault :
 189         public rtl::Static< JobSetup::ImplType, theGlobalDefault > {};
 190 }
 191
 192 JobSetup::JobSetup() : mpData(theGlobalDefault::get())
 193 {
 194 }
 195
 196 JobSetup::JobSetup( const JobSetup& rJobSetup ) : mpData(rJobSetup.mpData)
 197 {
 198 }
 199
 200 JobSetup::~JobSetup()
 201 {
 202 }
 203
 204 bool JobSetup::operator==( const JobSetup& rJobSetup ) const
 205 {
 206     return mpData == rJobSetup.mpData;
 207 }
 208
 209 const ImplJobSetup& JobSetup::ImplGetConstData() const
 210 {
 211     return *mpData;
 212 }
 213
 214 ImplJobSetup& JobSetup::ImplGetData()
 215 {
 216     return *mpData;
 217 }
 218
 219 OUString JobSetup::GetPrinterName() const
 220 {
 221     return mpData->GetPrinterName();
 222 }
 223
 224 bool JobSetup::IsDefault() const
 225 {
 226     return mpData.same_object(theGlobalDefault::get());
 227 }
 228
 229 SvStream& ReadJobSetup( SvStream& rIStream, JobSetup& rJobSetup )
 230 {
 231     {
 232         sal_uInt16 nLen = 0;
 233         rIStream.ReadUInt16( nLen );
 234         if (nLen <= 4)
 235             return rIStream;
 236
 237         sal_uInt16 nSystem = 0;
 238         rIStream.ReadUInt16( nSystem );
 239         size_t nRead = nLen - sizeof(nLen) - sizeof(nSystem);
 240         if (nRead > rIStream.remainingSize())
 241         {
 242             SAL_WARN("vcl", "Parsing error: " << rIStream.remainingSize() <<
 243                      " max possible entries, but " << nRead << " claimed, truncating");
 244             return rIStream;
 245         }
 246         sal_uInt64 const nFirstPos = rIStream.Tell();
 247         std::unique_ptr<char[]> pTempBuf(new char[nRead]);
 248         nRead = rIStream.ReadBytes(pTempBuf.get(), nRead);
 249         if (nRead >= sizeof(ImplOldJobSetupData))
 250         {
 251             ImplOldJobSetupData* pData = reinterpret_cast<ImplOldJobSetupData*>(pTempBuf.get());
 252
 253             rtl_TextEncoding aStreamEncoding = RTL_TEXTENCODING_UTF8;
 254             if( nSystem == JOBSET_FILE364_SYSTEM )
 255                 aStreamEncoding = rIStream.GetStreamCharSet();
 256
 257             ImplJobSetup& rJobData = rJobSetup.ImplGetData();
 258
 259             rJobData.SetPrinterName( OStringToOUString(pData->cPrinterName, aStreamEncoding) );
 260             rJobData.SetDriver( OStringToOUString(pData->cDriverName, aStreamEncoding) );
 261
 262             // Are these our new JobSetup files?
 263             if ( nSystem == JOBSET_FILE364_SYSTEM ||
 264                  nSystem == JOBSET_FILE605_SYSTEM )
 265             {
 266                 Impl364JobSetupData* pOldJobData    = reinterpret_cast<Impl364JobSetupData*>(pTempBuf.get() + sizeof( ImplOldJobSetupData ));
 267                 sal_uInt16 nOldJobDataSize          = SVBT16ToShort( pOldJobData->nSize );
 268                 rJobData.SetSystem( SVBT16ToShort( pOldJobData->nSystem ) );
 269                 rJobData.SetDriverDataLen( SVBT32ToUInt32( pOldJobData->nDriverDataLen ) );
 270                 rJobData.SetOrientation( (Orientation)SVBT16ToShort( pOldJobData->nOrientation ) );
 271                 rJobData.SetDuplexMode( DuplexMode::Unknown );
 272                 rJobData.SetPaperBin( SVBT16ToShort( pOldJobData->nPaperBin ) );
 273                 rJobData.SetPaperFormat( (Paper)SVBT16ToShort( pOldJobData->nPaperFormat ) );
 274                 rJobData.SetPaperWidth( (long)SVBT32ToUInt32( pOldJobData->nPaperWidth ) );
 275                 rJobData.SetPaperHeight( (long)SVBT32ToUInt32( pOldJobData->nPaperHeight ) );
 276                 if ( rJobData.GetDriverDataLen() )
 277                 {
 278                     const char* pDriverData = reinterpret_cast<const char*>(pOldJobData) + nOldJobDataSize;
 279                     const char* pDriverDataEnd = pDriverData + rJobData.GetDriverDataLen();
 280                     if (pDriverDataEnd > pTempBuf.get() + nRead)
 281                     {
 282                         SAL_WARN("vcl", "corrupted job setup");
 283                     }
 284                     else
 285                     {
 286                         sal_uInt8* pNewDriverData = static_cast<sal_uInt8*>(
 287                             rtl_allocateMemory( rJobData.GetDriverDataLen() ));
 288                         memcpy( pNewDriverData, pDriverData, rJobData.GetDriverDataLen() );
 289                         rJobData.SetDriverData( pNewDriverData );
 290                     }
 291                 }
 292                 if( nSystem == JOBSET_FILE605_SYSTEM )
 293                 {
 294                     rIStream.Seek( nFirstPos + sizeof( ImplOldJobSetupData ) +
 295                         sizeof( Impl364JobSetupData ) + rJobData.GetDriverDataLen() );
 296                     while( rIStream.Tell() < nFirstPos + nRead )
 297                     {
 298                         OUString aKey = read_uInt16_lenPrefixed_uInt8s_ToOUString(rIStream, RTL_TEXTENCODING_UTF8);
 299                         OUString aValue = read_uInt16_lenPrefixed_uInt8s_ToOUString(rIStream, RTL_TEXTENCODING_UTF8);
 300                         if( aKey == "COMPAT_DUPLEX_MODE" )
 301                         {
 302                             if( aValue == "DuplexMode::Unknown" )
 303                                 rJobData.SetDuplexMode( DuplexMode::Unknown );
 304                             else if( aValue == "DuplexMode::Off" )
 305                                 rJobData.SetDuplexMode( DuplexMode::Off );
 306                             else if( aValue == "DuplexMode::ShortEdge" )
 307                                 rJobData.SetDuplexMode( DuplexMode::ShortEdge );
 308                             else if( aValue == "DuplexMode::LongEdge" )
 309                                 rJobData.SetDuplexMode( DuplexMode::LongEdge );
 310                         }
 311                         else
 312                             rJobData.SetValueMap(aKey, aValue);
 313                     }
 314                     SAL_WARN_IF( rIStream.Tell() != nFirstPos+nRead, "vcl", "corrupted job setup" );
 315                     // ensure correct stream position
 316                     rIStream.Seek(nFirstPos + nRead);
 317                 }
 318             }
 319         }
 320     }
 321
 322     return rIStream;
 323 }
 324
 325 SvStream& WriteJobSetup( SvStream& rOStream, const JobSetup& rJobSetup )
 326 {
 327     {
 328         sal_uInt16 nLen = 0;
 329         if ( rJobSetup.IsDefault() )
 330             rOStream.WriteUInt16( nLen );
 331         else
 332         {
 333             sal_uInt16 nSystem = JOBSET_FILE605_SYSTEM;
 334
 335             const ImplJobSetup& rJobData = rJobSetup.ImplGetConstData();
 336             Impl364JobSetupData aOldJobData;
 337             sal_uInt16 nOldJobDataSize = sizeof( aOldJobData );
 338             ShortToSVBT16( nOldJobDataSize, aOldJobData.nSize );
 339             ShortToSVBT16( rJobData.GetSystem(), aOldJobData.nSystem );
 340             UInt32ToSVBT32( rJobData.GetDriverDataLen(), aOldJobData.nDriverDataLen );
 341             ShortToSVBT16( (sal_uInt16)(rJobData.GetOrientation()), aOldJobData.nOrientation );
 342             ShortToSVBT16( rJobData.GetPaperBin(), aOldJobData.nPaperBin );
 343             ShortToSVBT16( (sal_uInt16)(rJobData.GetPaperFormat()), aOldJobData.nPaperFormat );
 344             UInt32ToSVBT32( (sal_uLong)(rJobData.GetPaperWidth()), aOldJobData.nPaperWidth );
 345             UInt32ToSVBT32( (sal_uLong)(rJobData.GetPaperHeight()), aOldJobData.nPaperHeight );
 346
 347             ImplOldJobSetupData aOldData;
 348             memset( &aOldData, 0, sizeof( aOldData ) );
 349             OString aPrnByteName(OUStringToOString(rJobData.GetPrinterName(), RTL_TEXTENCODING_UTF8));
 350             strncpy( aOldData.cPrinterName, aPrnByteName.getStr(), 63 );
 351             OString aDriverByteName(OUStringToOString(rJobData.GetDriver(), RTL_TEXTENCODING_UTF8));
 352             strncpy( aOldData.cDriverName, aDriverByteName.getStr(), 31 );
 353             int nPos = rOStream.Tell();
 354             rOStream.WriteUInt16( 0 );
 355             rOStream.WriteUInt16( nSystem );
 356             rOStream.WriteBytes( &aOldData, sizeof( aOldData ) );
 357             rOStream.WriteBytes( &aOldJobData, nOldJobDataSize );
 358             rOStream.WriteBytes( rJobData.GetDriverData(), rJobData.GetDriverDataLen() );
 359
 360             std::unordered_map< OUString, OUString, OUStringHash >::const_iterator it;
 361             const std::unordered_map< OUString, OUString, OUStringHash >& rValueMap(
 362                 rJobData.GetValueMap());
 363
 364             for( it = rValueMap.begin(); it != rValueMap.end(); ++it )
 365             {
 366                 write_uInt16_lenPrefixed_uInt8s_FromOUString(rOStream, it->first, RTL_TEXTENCODING_UTF8);
 367                 write_uInt16_lenPrefixed_uInt8s_FromOUString(rOStream, it->second, RTL_TEXTENCODING_UTF8);
 368             }
 369             write_uInt16_lenPrefixed_uInt8s_FromOString(rOStream, "COMPAT_DUPLEX_MODE");
 370             switch( rJobData.GetDuplexMode() )
 371             {
 372                 case DuplexMode::Unknown:
 373                     write_uInt16_lenPrefixed_uInt8s_FromOString(rOStream, "DuplexMode::Unknown");
 374                     break;
 375                 case DuplexMode::Off:
 376                     write_uInt16_lenPrefixed_uInt8s_FromOString(rOStream, "DuplexMode::Off");
 377                     break;
 378                 case DuplexMode::ShortEdge:
 379                     write_uInt16_lenPrefixed_uInt8s_FromOString(rOStream, "DuplexMode::ShortEdge");
 380                     break;
 381                 case DuplexMode::LongEdge:
 382                     write_uInt16_lenPrefixed_uInt8s_FromOString(rOStream, "DuplexMode::LongEdge");
 383                     break;
 384             }
 385             nLen = sal::static_int_cast<sal_uInt16>(rOStream.Tell() - nPos);
 386             rOStream.Seek( nPos );
 387             rOStream.WriteUInt16( nLen );
 388             rOStream.Seek( nPos + nLen );
 389         }
 390     }
 391
 392     return rOStream;
 393 }
 394
 395 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */