hwpfilter/source/hwpfile.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 <memory>
  21 #include "precompile.h"
  22
  23 #include <algorithm>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <errno.h>
  28
  29 #include <o3tl/safeint.hxx>
  30
  31 #include "hwplib.h"
  32 #include "hwpfile.h"
  33 #include "hiodev.h"
  34 #include "hfont.h"
  35 #include "hstyle.h"
  36 #include "hbox.h"
  37 #include "hpara.h"
  38 #include "htags.h"
  39 #include "hcode.h"
  40 #include "hstream.hxx"
  41
  42
  43 HWPFile *HWPFile::cur_doc = nullptr;
  44 static int ccount = 0;
  45 static int pcount = 0;
  46 static int datecodecount = 0;
  47
  48 HWPFile::HWPFile()
  49     : version(HWP_V30)
  50     , compressed(false)
  51     , encrypted(false)
  52     , linenumber(0)
  53     , info_block_len(0)
  54     , error_code(HWP_NoError)
  55     , readdepth(0)
  56     , m_nCurrentPage(1)
  57     , m_nMaxSettedPage(0)
  58     , currenthyper(0)
  59 {
  60     SetCurrentDoc(this);
  61 }
  62
  63 HWPFile::~HWPFile()
  64 {
  65     oledata.reset();
  66     hiodev.reset();
  67 }
  68
  69 int HWPFile::ReadHwpFile(std::unique_ptr<HStream> stream)
  70 {
  71     if (Open(std::move(stream)) != HWP_NoError)
  72         return State();
  73     InfoRead();
  74     FontRead();
  75     StyleRead();
  76     AddColumnInfo();
  77     ParaListRead();
  78     TagsRead();
  79
  80     return State();
  81 }
  82
  83 int detect_hwp_version(const char *str)
  84 {
  85     if (memcmp(V20SIGNATURE, str, HWPIDLen) == 0)
  86         return HWP_V20;
  87     else if (memcmp(V21SIGNATURE, str, HWPIDLen) == 0)
  88         return HWP_V21;
  89     else if (memcmp(V30SIGNATURE, str, HWPIDLen) == 0)
  90         return HWP_V30;
  91     return 0;
  92 }
  93
  94 // HIODev wrapper
  95
  96 int HWPFile::Open(std::unique_ptr<HStream> stream)
  97 {
  98     std::unique_ptr<HStreamIODev> hstreamio(new HStreamIODev(std::move(stream)));
  99
 100     if (!hstreamio->open())
 101     {
 102         return SetState(HWP_EMPTY_FILE);
 103     }
 104
 105     SetIODevice(std::move(hstreamio));
 106
 107     char idstr[HWPIDLen];
 108
 109     if (ReadBlock(idstr, HWPIDLen) < HWPIDLen)
 110         return SetState(HWP_UNSUPPORTED_VERSION);
 111     version = detect_hwp_version(idstr);
 112     if (HWP_V30 != version)
 113         return SetState(HWP_UNSUPPORTED_VERSION);
 114     return HWP_NoError;
 115 }
 116
 117 int HWPFile::SetState(int errcode)
 118 {
 119     error_code = errcode;
 120     return error_code;
 121 }
 122
 123 bool HWPFile::Read1b(unsigned char &out)
 124 {
 125     return hiodev && hiodev->read1b(out);
 126 }
 127
 128 bool HWPFile::Read1b(char &out)
 129 {
 130     unsigned char tmp8;
 131     if (!hiodev || !hiodev->read1b(tmp8))
 132         return false;
 133     out = tmp8;
 134     return true;
 135 }
 136
 137 bool HWPFile::Read2b(unsigned short &out)
 138 {
 139     return hiodev && hiodev->read2b(out);
 140 }
 141
 142 bool HWPFile::Read4b(unsigned int &out)
 143 {
 144     return hiodev && hiodev->read4b(out);
 145 }
 146
 147 bool HWPFile::Read4b(int &out)
 148 {
 149     unsigned int tmp32;
 150     if (!Read4b(tmp32))
 151         return false;
 152     out = tmp32;
 153     return true;
 154 }
 155
 156 size_t HWPFile::Read2b(void *ptr, size_t nmemb)
 157 {
 158     return hiodev ? hiodev->read2b(ptr, nmemb) : 0;
 159 }
 160
 161 void HWPFile::Read4b(void *ptr, size_t nmemb)
 162 {
 163     if (hiodev)
 164         hiodev->read4b(ptr, nmemb);
 165 }
 166
 167 size_t HWPFile::ReadBlock(void *ptr, size_t size)
 168 {
 169     return hiodev ? hiodev->readBlock(ptr, size) : 0;
 170 }
 171
 172 size_t HWPFile::SkipBlock(size_t size)
 173 {
 174     return hiodev ? hiodev->skipBlock(size) : 0;
 175 }
 176
 177 void HWPFile::SetCompressed(bool flag)
 178 {
 179     if (hiodev)
 180         hiodev->setCompressed(flag);
 181 }
 182
 183
 184 std::unique_ptr<HIODev> HWPFile::SetIODevice(std::unique_ptr<HIODev> new_hiodev)
 185 {
 186     std::swap(hiodev, new_hiodev);
 187     return new_hiodev;
 188 }
 189
 190
 191 // end of HIODev wrapper
 192
 193 void HWPFile::InfoRead()
 194 {
 195     _hwpInfo.Read(*this);
 196 }
 197
 198
 199 void HWPFile::FontRead()
 200 {
 201     _hwpFont.Read(*this);
 202 }
 203
 204
 205 void HWPFile::StyleRead()
 206 {
 207     _hwpStyle.Read(*this);
 208 }
 209
 210
 211 void HWPFile::ParaListRead()
 212 {
 213     ReadParaList(plist);
 214 }
 215
 216 void HWPFile::ReadParaList(std::vector < HWPPara* > &aplist)
 217 {
 218     std::unique_ptr<HWPPara> spNode( new HWPPara );
 219     unsigned char tmp_etcflag;
 220     unsigned char prev_etcflag = 0;
 221     while (spNode->Read(*this, 0))
 222     {
 223         if( !(spNode->etcflag & 0x04) ){
 224             tmp_etcflag = spNode->etcflag;
 225             spNode->etcflag = prev_etcflag;
 226             prev_etcflag = tmp_etcflag;
 227         }
 228         if (spNode->nch && spNode->reuse_shape)
 229         {
 230             if (!aplist.empty()){
 231                  spNode->pshape = aplist.back()->pshape;
 232             }
 233             else{
 234                  spNode->nch = 0;
 235                  spNode->reuse_shape = 0;
 236             }
 237         }
 238         spNode->pshape->pagebreak = spNode->etcflag;
 239         if (spNode->nch)
 240             AddParaShape(spNode->pshape);
 241
 242         if (!aplist.empty())
 243             aplist.back()->SetNext(spNode.get());
 244         aplist.push_back(spNode.release());
 245         spNode.reset( new HWPPara );
 246     }
 247 }
 248
 249 void HWPFile::ReadParaList(std::vector< std::unique_ptr<HWPPara> > &aplist, unsigned char flag)
 250 {
 251     std::unique_ptr<HWPPara> spNode( new HWPPara );
 252     unsigned char tmp_etcflag;
 253     unsigned char prev_etcflag = 0;
 254     while (spNode->Read(*this, flag))
 255     {
 256         if( !(spNode->etcflag & 0x04) ){
 257           tmp_etcflag = spNode->etcflag;
 258           spNode->etcflag = prev_etcflag;
 259           prev_etcflag = tmp_etcflag;
 260         }
 261         if (spNode->nch && spNode->reuse_shape)
 262         {
 263             if (!aplist.empty()){
 264                 spNode->pshape = aplist.back()->pshape;
 265             }
 266             else{
 267                 spNode->nch = 0;
 268                 spNode->reuse_shape = 0;
 269             }
 270         }
 271         spNode->pshape->pagebreak = spNode->etcflag;
 272         if (spNode->nch)
 273             AddParaShape(spNode->pshape);
 274
 275         if (!aplist.empty())
 276             aplist.back()->SetNext(spNode.get());
 277         aplist.push_back(std::move(spNode));
 278         spNode.reset( new HWPPara );
 279     }
 280 }
 281
 282 void HWPFile::TagsRead()
 283 {
 284     while (true)
 285     {
 286         uint tag;
 287         if (!Read4b(tag))
 288             return;
 289         int size;
 290         if (!Read4b(size))
 291             return;
 292         if (size <= 0 && tag > 0){
 293             continue;
 294           }
 295
 296         if (tag == FILETAG_END_OF_COMPRESSED ||
 297             tag == FILETAG_END_OF_UNCOMPRESSED)
 298             return;
 299         switch (tag)
 300         {
 301             case FILETAG_EMBEDDED_PICTURE:
 302             {
 303                 std::unique_ptr<EmPicture> emb(new EmPicture(size));
 304
 305                 if (emb->Read(*this))
 306                     emblist.push_back(std::move(emb));
 307             }
 308             break;
 309             case FILETAG_OLE_OBJECT:
 310                 oledata.reset( new OlePicture(size) );
 311                 oledata->Read(*this);
 312                 break;
 313             case FILETAG_HYPERTEXT:
 314             {
 315                 const int nRecordLen = 617;
 316                 if( (size % nRecordLen) != 0 )
 317                     SkipBlock( size );
 318                 else
 319                 {
 320                     const int nRecords = size / nRecordLen;
 321                     for (int i = 0 ; i < nRecords; ++i)
 322                     {
 323                         std::unique_ptr<HyperText> hypert(new HyperText);
 324                         if (hypert->Read(*this))
 325                             hyperlist.push_back(std::move(hypert));
 326                         else
 327                             break;
 328                     }
 329                 }
 330                 break;
 331             }
 332                 case 6:
 333                 {
 334                      ReadBlock(_hwpInfo.back_info.reserved1, 8);
 335                      if (!Read4b(_hwpInfo.back_info.luminance))
 336                         return;
 337                      if (!Read4b(_hwpInfo.back_info.contrast))
 338                         return;
 339                      if (!Read1b(_hwpInfo.back_info.effect))
 340                         return;
 341                      ReadBlock(_hwpInfo.back_info.reserved2, 7);
 342                      ReadBlock(_hwpInfo.back_info.filename, 260);
 343                      ReadBlock(_hwpInfo.back_info.color, 3);
 344                      unsigned short nFlag;
 345                      if (!Read2b(nFlag))
 346                         return;
 347                      _hwpInfo.back_info.flag = nFlag >> 8 ;
 348                      int nRange;
 349                      if (!Read4b(nRange))
 350                         return;
 351                      _hwpInfo.back_info.range = nRange >> 24;
 352                      ReadBlock(_hwpInfo.back_info.reserved3, 27);
 353                      if (!Read4b(_hwpInfo.back_info.size))
 354                         return;
 355
 356                      if (_hwpInfo.back_info.size < 0)
 357                      {
 358                         _hwpInfo.back_info.size = 0;
 359                         return;
 360                      }
 361
 362                      _hwpInfo.back_info.data.clear();
 363
 364                      //read potentially compressed data in blocks as its more
 365                      //likely large values are simply broken and we'll run out
 366                      //of data before we need to realloc
 367                      for (int i = 0; i < _hwpInfo.back_info.size; i+= SAL_MAX_UINT16)
 368                      {
 369                         int nOldSize = _hwpInfo.back_info.data.size();
 370                         size_t nBlock = std::min<int>(SAL_MAX_UINT16, _hwpInfo.back_info.size - nOldSize);
 371                         _hwpInfo.back_info.data.resize(nOldSize + nBlock);
 372                         size_t nReadBlock = ReadBlock(_hwpInfo.back_info.data.data() + nOldSize, nBlock);
 373                         if (nBlock != nReadBlock)
 374                         {
 375                             _hwpInfo.back_info.data.resize(nOldSize + nReadBlock);
 376                             break;
 377                         }
 378                      }
 379                      _hwpInfo.back_info.size = _hwpInfo.back_info.data.size();
 380
 381                      if( _hwpInfo.back_info.size > 0 )
 382                           _hwpInfo.back_info.type = 2;
 383                      else if( _hwpInfo.back_info.filename[0] )
 384                           _hwpInfo.back_info.type = 1;
 385                      else
 386                           _hwpInfo.back_info.type = 0;
 387
 388
 389                      _hwpInfo.back_info.isset = true;
 390
 391                      break;
 392                 }
 393             case FILETAG_PRESENTATION:
 394             case FILETAG_PREVIEW_IMAGE:
 395             case FILETAG_PREVIEW_TEXT:
 396             default:
 397                 SkipBlock(size);
 398         }
 399     }
 400 }
 401
 402
 403 ColumnDef *HWPFile::GetColumnDef(int num)
 404 {
 405     if (o3tl::make_unsigned(num) < columnlist.size())
 406         return columnlist[num]->xColdef.get();
 407     else
 408         return nullptr;
 409 }
 410
 411 /* Index of @return starts from 1 */
 412 int HWPFile::GetPageMasterNum(int page)
 413 {
 414     int i = 0;
 415     for (auto const& column : columnlist)
 416     {
 417         if( page < column->start_page )
 418             return i;
 419         ++i;
 420     }
 421     return i;
 422 }
 423
 424 HyperText *HWPFile::GetHyperText()
 425 {
 426     ++currenthyper;
 427     if (o3tl::make_unsigned(currenthyper) <= hyperlist.size())
 428         return hyperlist[currenthyper-1].get();
 429     else
 430         return nullptr;
 431 }
 432
 433 EmPicture *HWPFile::GetEmPicture(Picture * pic)
 434 {
 435     char *name = pic->picinfo.picembed.embname;
 436
 437     name[0] = 'H';
 438     name[1] = 'W';
 439     name[2] = 'P';
 440
 441     for (auto const& emb : emblist)
 442         if (strcmp(name, emb->name) == 0)
 443             return emb.get();
 444     return nullptr;
 445 }
 446
 447 EmPicture *HWPFile::GetEmPictureByName(char * name)
 448 {
 449     name[0] = 'H';
 450     name[1] = 'W';
 451     name[2] = 'P';
 452
 453     for (auto const& emb : emblist)
 454         if (strcmp(name, emb->name) == 0)
 455             return emb.get();
 456     return nullptr;
 457 }
 458
 459 void HWPFile::AddBox(FBox * box)
 460 {
 461     blist.push_back(box);
 462 }
 463
 464 ParaShape *HWPFile::getParaShape(int index)
 465 {
 466     if (index < 0 || o3tl::make_unsigned(index) >= pslist.size())
 467         return nullptr;
 468     return pslist[index].get();
 469 }
 470
 471 CharShape *HWPFile::getCharShape(int index)
 472 {
 473     if (index < 0 || o3tl::make_unsigned(index) >= cslist.size())
 474         return nullptr;
 475     return cslist[index].get();
 476 }
 477
 478 FBoxStyle *HWPFile::getFBoxStyle(int index)
 479 {
 480     if (index < 0 || o3tl::make_unsigned(index) >= fbslist.size())
 481         return nullptr;
 482     return fbslist[index];
 483 }
 484
 485 DateCode *HWPFile::getDateCode(int index)
 486 {
 487     if (index < 0 || o3tl::make_unsigned(index) >= datecodes.size())
 488         return nullptr;
 489     return datecodes[index];
 490 }
 491
 492 HeaderFooter *HWPFile::getHeaderFooter(int index)
 493 {
 494     if (index < 0 || o3tl::make_unsigned(index) >= headerfooters.size())
 495         return nullptr;
 496     return headerfooters[index];
 497 }
 498
 499 ShowPageNum *HWPFile::getPageNumber(int index)
 500 {
 501     if (index < 0 || o3tl::make_unsigned(index) >= pagenumbers.size())
 502         return nullptr;
 503     return pagenumbers[index];
 504 }
 505
 506 Table *HWPFile::getTable(int index)
 507 {
 508     if (index < 0 || o3tl::make_unsigned(index) >= tables.size())
 509         return nullptr;
 510     return tables[index].get();
 511 }
 512
 513 void HWPFile::AddParaShape(std::shared_ptr<ParaShape> const & pshape)
 514 {
 515     int nscount = 0;
 516     for(int j = 0 ; j < MAXTABS-1 ; j++)
 517     {
 518         if( j > 0 && pshape->tabs[j].position == 0 )
 519           break;
 520         if( pshape->tabs[0].position == 0 ){
 521             if( pshape->tabs[j].type || pshape->tabs[j].dot_continue ||
 522                  (pshape->tabs[j].position != 1000 *j) )
 523                       nscount = j;
 524         }
 525         else {
 526             if( pshape->tabs[j].type || pshape->tabs[j].dot_continue ||
 527                 (pshape->tabs[j].position != 1000 * (j + 1)) )
 528                     nscount = j;
 529           }
 530     }
 531     if( nscount )
 532     {
 533         pshape->tabs[MAXTABS-1].type = sal::static_int_cast<char>(nscount);
 534         pshape->index = ++pcount;
 535         pslist.push_back(pshape);
 536         return;
 537     }
 538
 539     int value = compareParaShape(pshape.get());
 540     if (value == 0)
 541     {
 542         pshape->index = ++pcount;
 543         pslist.push_back(pshape);
 544         return;
 545     }
 546     pshape->index = value;
 547 }
 548
 549 void HWPFile::AddCharShape(std::shared_ptr<CharShape> const & cshape)
 550 {
 551     int value = compareCharShape(cshape.get());
 552     if (value == 0)
 553     {
 554         cshape->index = ++ccount;
 555         cslist.push_back(cshape);
 556     }
 557     else
 558         cshape->index = value;
 559 }
 560
 561 void HWPFile::AddColumnInfo()
 562 {
 563     columnlist.emplace_back(new ColumnInfo(m_nCurrentPage));
 564     setMaxSettedPage();
 565 }
 566
 567 void HWPFile::SetColumnDef(const std::shared_ptr<ColumnDef>& rColdef)
 568 {
 569     ColumnInfo *cinfo = columnlist.back().get();
 570     if( cinfo->bIsSet )
 571         return;
 572     cinfo->xColdef = rColdef;
 573     cinfo->bIsSet = true;
 574 }
 575
 576 void HWPFile::AddDateFormat(DateCode * hbox)
 577 {
 578     hbox->key = sal::static_int_cast<char>(++datecodecount);
 579     datecodes.push_back(hbox);
 580 }
 581
 582 void HWPFile::AddPageNumber(ShowPageNum * hbox)
 583 {
 584     pagenumbers.push_back(hbox);
 585 }
 586
 587 void HWPFile::AddHeaderFooter(HeaderFooter * hbox)
 588 {
 589     headerfooters.push_back(hbox);
 590 }
 591
 592 void HWPFile::AddTable(std::unique_ptr<Table> hbox)
 593 {
 594     tables.push_back(std::move(hbox));
 595 }
 596
 597 void HWPFile::AddFBoxStyle(FBoxStyle * fbstyle)
 598 {
 599     fbslist.push_back(fbstyle);
 600 }
 601
 602 int HWPFile::compareCharShape(CharShape const *shape)
 603 {
 604     int count = cslist.size();
 605     if( count > 0 )
 606     {
 607         for(int i = 0; i< count; i++)
 608         {
 609             CharShape *cshape = getCharShape(i);
 610
 611             if( shape->size == cshape->size &&
 612                 shape->font[0] == cshape->font[0] &&
 613                 shape->ratio[0] == cshape->ratio[0] &&
 614                 shape->space[0] == cshape->space[0] &&
 615                 shape->color[1] == cshape->color[1] &&
 616                 shape->color[0] == cshape->color[0] &&
 617                 shape->shade == cshape->shade &&
 618                 shape->attr == cshape->attr )
 619             {
 620                 return cshape->index;
 621             }
 622         }
 623     }
 624     return 0;
 625 }
 626
 627
 628 int HWPFile::compareParaShape(ParaShape const *shape)
 629 {
 630     int count = pslist.size();
 631     if( count > 0 )
 632     {
 633         for(int i = 0; i< count; i++)
 634         {
 635             ParaShape *pshape = getParaShape(i);
 636             if( shape->left_margin == pshape->left_margin &&
 637                 shape->right_margin == pshape->right_margin &&
 638                 shape->pspacing_prev == pshape->pspacing_prev &&
 639                 shape->pspacing_next == pshape->pspacing_next &&
 640                 shape->indent == pshape->indent &&
 641                 shape->lspacing == pshape->lspacing &&
 642                 shape->arrange_type == pshape->arrange_type &&
 643                 shape->outline == pshape->outline  &&
 644                      shape->pagebreak == pshape->pagebreak)
 645             {
 646                     if( shape->cshape && pshape->cshape &&
 647                          shape->cshape->size == pshape->cshape->size &&
 648                          shape->cshape->font[0] == pshape->cshape->font[0] &&
 649                          shape->cshape->ratio[0] == pshape->cshape->ratio[0] &&
 650                          shape->cshape->space[0] == pshape->cshape->space[0] &&
 651                          shape->cshape->color[1] == pshape->cshape->color[1] &&
 652                          shape->cshape->color[0] == pshape->cshape->color[0] &&
 653                          shape->cshape->shade == pshape->cshape->shade &&
 654                          shape->cshape->attr == pshape->cshape->attr )
 655                     {
 656                          return pshape->index;
 657                     }
 658             }
 659         }
 660     }
 661     return 0;
 662 }
 663
 664
 665 HWPFile *GetCurrentDoc()
 666 {
 667     return HWPFile::cur_doc;
 668 }
 669
 670
 671 HWPFile *SetCurrentDoc(HWPFile * hwpfp)
 672 {
 673     HWPFile *org = HWPFile::cur_doc;
 674
 675     HWPFile::cur_doc = hwpfp;
 676     return org;
 677 }
 678
 679 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */