simgear/io/SVNReportParser.cxx

   1 // SVNReportParser -- parser for SVN report XML data
   2 //
   3 // Copyright (C) 2012  James Turner <zakalawe@mac.com>
   4 //
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License as
   7 // published by the Free Software Foundation; either version 2 of the
   8 // License, or (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful, but
  11 // WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 // General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18
  19 #ifdef HAVE_CONFIG_H
  20 #  include <simgear_config.h>
  21 #endif
  22
  23 #include "SVNReportParser.hxx"
  24
  25 #include <iostream>
  26 #include <cstring>
  27 #include <cassert>
  28 #include <algorithm>
  29 #include <sstream>
  30 #include <fstream>
  31
  32 #include <boost/foreach.hpp>
  33
  34 #include "simgear/misc/sg_path.hxx"
  35 #include "simgear/misc/sg_dir.hxx"
  36 #include "simgear/debug/logstream.hxx"
  37 #include "simgear/xml/easyxml.hxx"
  38 #include "simgear/misc/strutils.hxx"
  39 #include "simgear/package/md5.h"
  40
  41 #ifdef SYSTEM_EXPAT
  42 #  include <expat.h>
  43 #else
  44 #  include "sg_expat.h"
  45 #endif
  46
  47 #include "SVNDirectory.hxx"
  48 #include "SVNRepository.hxx"
  49 #include "DAVMultiStatus.hxx"
  50
  51 using std::cout;
  52 using std::cerr;
  53 using std::endl;
  54 using std::string;
  55
  56 using namespace simgear;
  57
  58 #define DAV_NS "DAV::"
  59 #define SVN_NS "svn::"
  60 #define SUBVERSION_DAV_NS "http://subversion.tigris.org/xmlns/dav/"
  61
  62 namespace {
  63
  64     #define MAX_ENCODED_INT_LEN 10
  65
  66     static size_t
  67     decode_size(unsigned char* &p,
  68                 const unsigned char *end)
  69     {
  70       if (p + MAX_ENCODED_INT_LEN < end)
  71         end = p + MAX_ENCODED_INT_LEN;
  72       /* Decode bytes until we're done.  */
  73       size_t result = 0;
  74
  75       while (p < end) {
  76           result = (result << 7) | (*p & 0x7f);
  77           if (((*p++ >> 7) & 0x1) == 0) {
  78               break;
  79           }
  80       }
  81
  82       return result;
  83     }
  84
  85     static bool
  86     try_decode_size(unsigned char* &p,
  87                 const unsigned char *end)
  88     {
  89       if (p + MAX_ENCODED_INT_LEN < end)
  90         end = p + MAX_ENCODED_INT_LEN;
  91
  92       while (p < end) {
  93           if (((*p++ >> 7) & 0x1) == 0) {
  94               return true;
  95           }
  96       }
  97
  98       return false;
  99     }
 100
 101 //  const char* SVN_UPDATE_REPORT_TAG = SVN_NS "update-report";
 102  // const char* SVN_TARGET_REVISION_TAG = SVN_NS "target-revision";
 103   const char* SVN_OPEN_DIRECTORY_TAG = SVN_NS "open-directory";
 104   const char* SVN_OPEN_FILE_TAG = SVN_NS "open-file";
 105   const char* SVN_ADD_DIRECTORY_TAG = SVN_NS "add-directory";
 106   const char* SVN_ADD_FILE_TAG = SVN_NS "add-file";
 107   const char* SVN_TXDELTA_TAG = SVN_NS "txdelta";
 108   const char* SVN_SET_PROP_TAG = SVN_NS "set-prop";
 109   const char* SVN_DELETE_ENTRY_TAG = SVN_NS "delete-entry";
 110
 111   const char* SVN_DAV_MD5_CHECKSUM = SUBVERSION_DAV_NS ":md5-checksum";
 112
 113   const char* DAV_HREF_TAG = DAV_NS "href";
 114   const char* DAV_CHECKED_IN_TAG = SVN_NS "checked-in";
 115
 116
 117   const int svn_txdelta_source = 0;
 118   const int svn_txdelta_target = 1;
 119   const int svn_txdelta_new = 2;
 120
 121   const size_t DELTA_HEADER_SIZE = 4;
 122
 123   /**
 124    * helper struct to decode and store the SVN delta header
 125    * values
 126    */
 127   struct SVNDeltaWindow
 128   {
 129   public:
 130
 131       static bool isWindowComplete(unsigned char* buffer, size_t bytes)
 132       {
 133           unsigned char* p = buffer;
 134           unsigned char* pEnd = p + bytes;
 135           // if we can't decode five sizes, certainly incomplete
 136           for (int i=0; i<5; i++) {
 137               if (!try_decode_size(p, pEnd)) {
 138                   return false;
 139               }
 140           }
 141
 142           p = buffer;
 143         // ignore these three
 144           decode_size(p, pEnd);
 145           decode_size(p, pEnd);
 146           decode_size(p, pEnd);
 147           size_t instructionLen = decode_size(p, pEnd);
 148           size_t newLength = decode_size(p, pEnd);
 149           size_t headerLength = p - buffer;
 150
 151           return (bytes >= (instructionLen + newLength + headerLength));
 152       }
 153
 154      SVNDeltaWindow(unsigned char* p) :
 155          headerLength(0),
 156          _ptr(p)
 157      {
 158          sourceViewOffset = decode_size(p, p+20);
 159          sourceViewLength = decode_size(p, p+20);
 160          targetViewLength = decode_size(p, p+20);
 161          instructionLength = decode_size(p, p+20);
 162          newLength = decode_size(p, p+20);
 163
 164          headerLength = p - _ptr;
 165          _ptr = p;
 166      }
 167
 168     bool apply(std::vector<unsigned char>& output, std::istream& source)
 169     {
 170         unsigned char* pEnd = _ptr + instructionLength;
 171         unsigned char* newData = pEnd;
 172
 173         while (_ptr < pEnd) {
 174           int op = ((*_ptr >> 6) & 0x3);
 175           if (op >= 3) {
 176             SG_LOG(SG_IO, SG_INFO, "SVNDeltaWindow: bad opcode:" << op);
 177               return false;
 178           }
 179
 180           int length = *_ptr++ & 0x3f;
 181           int offset = 0;
 182
 183           if (length == 0) {
 184             length = decode_size(_ptr, pEnd);
 185           }
 186
 187           if (length == 0) {
 188                         SG_LOG(SG_IO, SG_INFO, "SVNDeltaWindow: malformed stream, 0 length" << op);
 189             return false;
 190           }
 191
 192           // if op != new, decode another size value
 193           if (op != svn_txdelta_new) {
 194             offset = decode_size(_ptr, pEnd);
 195           }
 196
 197           if (op == svn_txdelta_target) {
 198             while (length > 0) {
 199               output.push_back(output[offset++]);
 200               --length;
 201             }
 202           } else if (op == svn_txdelta_new) {
 203               output.insert(output.end(), newData, newData + length);
 204           } else if (op == svn_txdelta_source) {
 205             source.seekg(offset);
 206             char* sourceBuf = (char*) malloc(length);
 207             assert(sourceBuf);
 208             source.read(sourceBuf, length);
 209             output.insert(output.end(), sourceBuf, sourceBuf + length);
 210             free(sourceBuf);
 211           }
 212         } // of instruction loop
 213
 214         return true;
 215     }
 216
 217     size_t size() const
 218     {
 219         return headerLength + instructionLength + newLength;
 220     }
 221
 222     unsigned int sourceViewOffset;
 223     size_t sourceViewLength,
 224       targetViewLength;
 225     size_t headerLength,
 226         instructionLength,
 227         newLength;
 228
 229 private:
 230     unsigned char* _ptr;
 231   };
 232
 233
 234 } // of anonymous namespace
 235
 236 class SVNReportParser::SVNReportParserPrivate
 237 {
 238 public:
 239   SVNReportParserPrivate(SVNRepository* repo) :
 240     tree(repo),
 241     status(SVNRepository::SVN_NO_ERROR),
 242     parserInited(false),
 243     currentPath(repo->fsBase())
 244   {
 245     inFile = false;
 246     currentDir = repo->rootDir();
 247   }
 248
 249   ~SVNReportParserPrivate()
 250   {
 251   }
 252
 253   void startElement (const char * name, const char** attributes)
 254   {
 255       if (status != SVNRepository::SVN_NO_ERROR) {
 256           return;
 257       }
 258
 259     ExpatAtts attrs(attributes);
 260     tagStack.push_back(name);
 261     if (!strcmp(name, SVN_TXDELTA_TAG)) {
 262         txDeltaData.clear();
 263     } else if (!strcmp(name, SVN_ADD_FILE_TAG)) {
 264       string fileName(attrs.getValue("name"));
 265       SGPath filePath(currentDir->fsDir().file(fileName));
 266       currentPath = filePath;
 267       inFile = true;
 268     } else if (!strcmp(name, SVN_OPEN_FILE_TAG)) {
 269       string fileName(attrs.getValue("name"));
 270       SGPath filePath(Dir(currentPath).file(fileName));
 271       currentPath = filePath;
 272
 273       DAVResource* res = currentDir->collection()->childWithName(fileName);
 274       if (!res || !filePath.exists()) {
 275         // set error condition
 276       }
 277
 278       inFile = true;
 279     } else if (!strcmp(name, SVN_ADD_DIRECTORY_TAG)) {
 280       string dirName(attrs.getValue("name"));
 281       Dir d(currentDir->fsDir().file(dirName));
 282       if (d.exists()) {
 283           // policy decision : if we're doing an add, wipe the existing
 284           d.remove(true);
 285       }
 286
 287       currentDir = currentDir->addChildDirectory(dirName);
 288       currentPath = currentDir->fsPath();
 289       currentDir->beginUpdateReport();
 290       //cout << "addDir:" << currentPath << endl;
 291     } else if (!strcmp(name, SVN_SET_PROP_TAG)) {
 292       setPropName = attrs.getValue("name");
 293       setPropValue.clear();
 294     } else if (!strcmp(name, SVN_DAV_MD5_CHECKSUM)) {
 295       md5Sum.clear();
 296     } else if (!strcmp(name, SVN_OPEN_DIRECTORY_TAG)) {
 297         string dirName;
 298         if (attrs.getValue("name")) {
 299             dirName = string(attrs.getValue("name"));
 300         }
 301         openDirectory(dirName);
 302     } else if (!strcmp(name, SVN_DELETE_ENTRY_TAG)) {
 303         string entryName(attrs.getValue("name"));
 304         deleteEntry(entryName);
 305     } else if (!strcmp(name, DAV_CHECKED_IN_TAG) || !strcmp(name, DAV_HREF_TAG)) {
 306         // don't warn on these ones
 307     } else {
 308         //std::cerr << "unhandled element:" << name << std::endl;
 309     }
 310   } // of startElement
 311
 312   void openDirectory(const std::string& dirName)
 313   {
 314       if (dirName.empty()) {
 315           // root directory, we shall assume
 316           currentDir = tree->rootDir();
 317       } else {
 318           assert(currentDir);
 319           currentDir = currentDir->child(dirName);
 320       }
 321
 322       assert(currentDir);
 323       currentPath = currentDir->fsPath();
 324       currentDir->beginUpdateReport();
 325   }
 326
 327   void deleteEntry(const std::string& entryName)
 328   {
 329       currentDir->deleteChildByName(entryName);
 330   }
 331
 332   bool decodeTextDelta(const SGPath& outputPath)
 333   {
 334       std::vector<unsigned char> output, decoded;
 335     strutils::decodeBase64(txDeltaData, decoded);
 336     size_t bytesToDecode = decoded.size();
 337
 338     unsigned char* p = decoded.data();
 339     if (memcmp(p, "SVN\0", DELTA_HEADER_SIZE) != 0) {
 340         return false; // bad header
 341     }
 342
 343     bytesToDecode -= DELTA_HEADER_SIZE;
 344     p += DELTA_HEADER_SIZE;
 345     std::ifstream source;
 346     source.open(outputPath.c_str(), std::ios::in | std::ios::binary);
 347
 348     while (bytesToDecode > 0) {
 349         if (!SVNDeltaWindow::isWindowComplete(p, bytesToDecode)) {
 350             SG_LOG(SG_IO, SG_WARN, "SVN txdelta broken window");
 351             return false;
 352         }
 353
 354         SVNDeltaWindow window(p);
 355         assert(bytesToDecode >= window.size());
 356         window.apply(output, source);
 357         bytesToDecode -= window.size();
 358         p += window.size();
 359     }
 360
 361     source.close();
 362
 363     std::ofstream f;
 364     f.open(outputPath.c_str(),
 365       std::ios::out | std::ios::trunc | std::ios::binary);
 366     f.write((char*) output.data(), output.size());
 367
 368     // compute MD5 while we have the file in memory
 369     memset(&md5Context, 0, sizeof(SG_MD5_CTX));
 370     SG_MD5Init(&md5Context);
 371     SG_MD5Update(&md5Context, (unsigned char*) output.data(), output.size());
 372     SG_MD5Final(&md5Context);
 373     decodedFileMd5 = strutils::encodeHex(md5Context.digest, 16);
 374
 375     return true;
 376   }
 377
 378   void endElement (const char * name)
 379   {
 380       if (status != SVNRepository::SVN_NO_ERROR) {
 381           return;
 382       }
 383
 384     assert(tagStack.back() == name);
 385     tagStack.pop_back();
 386
 387     if (!strcmp(name, SVN_TXDELTA_TAG)) {
 388       if (!decodeTextDelta(currentPath)) {
 389         fail(SVNRepository::SVN_ERROR_TXDELTA);
 390       }
 391     } else if (!strcmp(name, SVN_ADD_FILE_TAG)) {
 392       finishFile(currentDir->addChildFile(currentPath.file()));
 393     } else if (!strcmp(name, SVN_OPEN_FILE_TAG)) {
 394       DAVResource* res = currentDir->collection()->childWithName(currentPath.file());
 395         if (!res) {
 396             SG_LOG(SG_IO, SG_WARN, "SVN open-file: unknown: " << currentPath);
 397             fail(SVNRepository::SVN_ERROR_IO);
 398             return;
 399         }
 400       finishFile(res);
 401     } else if (!strcmp(name, SVN_ADD_DIRECTORY_TAG)) {
 402       // pop directory
 403       currentPath = currentPath.dir();
 404       currentDir->updateReportComplete();
 405       currentDir = currentDir->parent();
 406     } else if (!strcmp(name, SVN_SET_PROP_TAG)) {
 407       if (setPropName == "svn:entry:committed-rev") {
 408         revision = strutils::to_int(setPropValue);
 409         currentVersionName = setPropValue;
 410         if (!inFile) {
 411           // for directories we have the resource already
 412           // for adding files, we might not; we set the version name
 413           // above when ending the add/open-file element
 414           currentDir->collection()->setVersionName(currentVersionName);
 415         }
 416       }
 417     } else if (!strcmp(name, SVN_DAV_MD5_CHECKSUM)) {
 418       // validate against (presumably) just written file
 419       if (decodedFileMd5 != md5Sum) {
 420           SG_LOG(SG_GENERAL, SG_INFO, "checksum fail on:" << currentPath);
 421         fail(SVNRepository::SVN_ERROR_CHECKSUM);
 422       }
 423     } else if (!strcmp(name, SVN_OPEN_DIRECTORY_TAG)) {
 424         currentDir->updateReportComplete();
 425         if (currentDir->parent()) {
 426           // pop the collection stack
 427           currentDir = currentDir->parent();
 428         }
 429
 430         currentPath = currentDir->fsPath();
 431     } else {
 432     //  std::cout << "element:" << name;
 433     }
 434   }
 435
 436   void finishFile(DAVResource* res)
 437   {
 438       res->setVersionName(currentVersionName);
 439       res->setMD5(md5Sum);
 440       currentPath = currentPath.dir();
 441       inFile = false;
 442   }
 443
 444   void data (const char * s, int length)
 445   {
 446       if (status != SVNRepository::SVN_NO_ERROR) {
 447           return;
 448       }
 449
 450     if (tagStack.back() == SVN_SET_PROP_TAG) {
 451       setPropValue.append(s, length);
 452     } else if (tagStack.back() == SVN_TXDELTA_TAG) {
 453       txDeltaData.append(s, length);
 454     } else if (tagStack.back() == SVN_DAV_MD5_CHECKSUM) {
 455       md5Sum.append(s, length);
 456     }
 457   }
 458
 459   void pi (const char * target, const char * data) {}
 460
 461   string tagN(const unsigned int n) const
 462   {
 463     size_t sz = tagStack.size();
 464     if (n >= sz) {
 465       return string();
 466     }
 467
 468     return tagStack[sz - (1 + n)];
 469   }
 470
 471   void fail(SVNRepository::ResultCode err)
 472   {
 473       status = err;
 474   }
 475
 476   SVNRepository* tree;
 477   DAVCollection* rootCollection;
 478   SVNDirectory* currentDir;
 479   SVNRepository::ResultCode status;
 480
 481   bool parserInited;
 482   XML_Parser xmlParser;
 483
 484 // in-flight data
 485   string_list tagStack;
 486   string currentVersionName;
 487   string txDeltaData;
 488   SGPath currentPath;
 489   bool inFile;
 490
 491   unsigned int revision;
 492   SG_MD5_CTX md5Context;
 493   string md5Sum, decodedFileMd5;
 494   std::string setPropName, setPropValue;
 495 };
 496
 497
 498 ////////////////////////////////////////////////////////////////////////
 499 // Static callback functions for Expat.
 500 ////////////////////////////////////////////////////////////////////////
 501
 502 #define VISITOR static_cast<SVNReportParser::SVNReportParserPrivate *>(userData)
 503
 504 static void
 505 start_element (void * userData, const char * name, const char ** atts)
 506 {
 507   VISITOR->startElement(name, atts);
 508 }
 509
 510 static void
 511 end_element (void * userData, const char * name)
 512 {
 513   VISITOR->endElement(name);
 514 }
 515
 516 static void
 517 character_data (void * userData, const char * s, int len)
 518 {
 519   VISITOR->data(s, len);
 520 }
 521
 522 static void
 523 processing_instruction (void * userData,
 524                         const char * target,
 525                         const char * data)
 526 {
 527   VISITOR->pi(target, data);
 528 }
 529
 530 #undef VISITOR
 531
 532 ///////////////////////////////////////////////////////////////////////////////
 533
 534 SVNReportParser::SVNReportParser(SVNRepository* repo) :
 535   _d(new SVNReportParserPrivate(repo))
 536 {
 537
 538 }
 539
 540 SVNReportParser::~SVNReportParser()
 541 {
 542 }
 543
 544 SVNRepository::ResultCode
 545 SVNReportParser::innerParseXML(const char* data, int size)
 546 {
 547     if (_d->status != SVNRepository::SVN_NO_ERROR) {
 548         return _d->status;
 549     }
 550
 551     bool isEnd = (data == NULL);
 552     if (!XML_Parse(_d->xmlParser, data, size, isEnd)) {
 553       SG_LOG(SG_IO, SG_INFO, "SVN parse error:" << XML_ErrorString(XML_GetErrorCode(_d->xmlParser))
 554              << " at line:" << XML_GetCurrentLineNumber(_d->xmlParser)
 555              << " column " << XML_GetCurrentColumnNumber(_d->xmlParser));
 556
 557       XML_ParserFree(_d->xmlParser);
 558       _d->parserInited = false;
 559       return SVNRepository::SVN_ERROR_XML;
 560     } else if (isEnd) {
 561         XML_ParserFree(_d->xmlParser);
 562         _d->parserInited = false;
 563     }
 564
 565     return _d->status;
 566 }
 567
 568 SVNRepository::ResultCode
 569 SVNReportParser::parseXML(const char* data, int size)
 570 {
 571     if (_d->status != SVNRepository::SVN_NO_ERROR) {
 572         return _d->status;
 573     }
 574
 575   if (!_d->parserInited) {
 576     _d->xmlParser = XML_ParserCreateNS(0, ':');
 577     XML_SetUserData(_d->xmlParser, _d.get());
 578     XML_SetElementHandler(_d->xmlParser, start_element, end_element);
 579     XML_SetCharacterDataHandler(_d->xmlParser, character_data);
 580     XML_SetProcessingInstructionHandler(_d->xmlParser, processing_instruction);
 581     _d->parserInited = true;
 582   }
 583
 584   return innerParseXML(data, size);
 585 }
 586
 587 SVNRepository::ResultCode SVNReportParser::finishParse()
 588 {
 589     if (_d->status != SVNRepository::SVN_NO_ERROR) {
 590         return _d->status;
 591     }
 592
 593     return innerParseXML(NULL, 0);
 594 }
 595
 596 std::string SVNReportParser::etagFromRevision(unsigned int revision)
 597 {
 598   // etags look like W/"7//", hopefully this is stable
 599   // across different servers and similar
 600   std::ostringstream os;
 601   os << "W/\"" << revision << "//";
 602   return os.str();
 603 }
 604
 605