1 // SVNReportParser -- parser for SVN report XML data
3 // Copyright (C) 2012 James Turner <zakalawe@mac.com>
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.
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.
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.
20 # include <simgear_config.h>
23 #include "SVNReportParser.hxx"
32 #include <boost/foreach.hpp>
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"
44 # include "sg_expat.h"
47 #include "SVNDirectory.hxx"
48 #include "SVNRepository.hxx"
49 #include "DAVMultiStatus.hxx"
56 using namespace simgear;
58 #define DAV_NS "DAV::"
59 #define SVN_NS "svn::"
60 #define SUBVERSION_DAV_NS "http://subversion.tigris.org/xmlns/dav/"
64 #define MAX_ENCODED_INT_LEN 10
67 decode_size(unsigned char* &p,
68 const unsigned char *end)
70 if (p + MAX_ENCODED_INT_LEN < end)
71 end = p + MAX_ENCODED_INT_LEN;
72 /* Decode bytes until we're done. */
76 result = (result << 7) | (*p & 0x7f);
77 if (((*p++ >> 7) & 0x1) == 0) {
86 try_decode_size(unsigned char* &p,
87 const unsigned char *end)
89 if (p + MAX_ENCODED_INT_LEN < end)
90 end = p + MAX_ENCODED_INT_LEN;
93 if (((*p++ >> 7) & 0x1) == 0) {
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_PROP_TAG = SVN_NS "prop";
110 const char* SVN_DELETE_ENTRY_TAG = SVN_NS "delete-entry";
112 const char* SVN_DAV_MD5_CHECKSUM = SUBVERSION_DAV_NS ":md5-checksum";
114 const char* DAV_HREF_TAG = DAV_NS "href";
115 const char* DAV_CHECKED_IN_TAG = DAV_NS "checked-in";
118 const int svn_txdelta_source = 0;
119 const int svn_txdelta_target = 1;
120 const int svn_txdelta_new = 2;
122 const size_t DELTA_HEADER_SIZE = 4;
125 * helper struct to decode and store the SVN delta header
128 struct SVNDeltaWindow
132 static bool isWindowComplete(unsigned char* buffer, size_t bytes)
134 unsigned char* p = buffer;
135 unsigned char* pEnd = p + bytes;
136 // if we can't decode five sizes, certainly incomplete
137 for (int i=0; i<5; i++) {
138 if (!try_decode_size(p, pEnd)) {
144 // ignore these three
145 decode_size(p, pEnd);
146 decode_size(p, pEnd);
147 decode_size(p, pEnd);
148 size_t instructionLen = decode_size(p, pEnd);
149 size_t newLength = decode_size(p, pEnd);
150 size_t headerLength = p - buffer;
152 return (bytes >= (instructionLen + newLength + headerLength));
155 SVNDeltaWindow(unsigned char* p) :
159 sourceViewOffset = decode_size(p, p+20);
160 sourceViewLength = decode_size(p, p+20);
161 targetViewLength = decode_size(p, p+20);
162 instructionLength = decode_size(p, p+20);
163 newLength = decode_size(p, p+20);
165 headerLength = p - _ptr;
169 bool apply(std::vector<unsigned char>& output, std::istream& source)
171 unsigned char* pEnd = _ptr + instructionLength;
172 unsigned char* newData = pEnd;
174 while (_ptr < pEnd) {
175 int op = ((*_ptr >> 6) & 0x3);
177 SG_LOG(SG_IO, SG_INFO, "SVNDeltaWindow: bad opcode:" << op);
181 int length = *_ptr++ & 0x3f;
185 length = decode_size(_ptr, pEnd);
189 SG_LOG(SG_IO, SG_INFO, "SVNDeltaWindow: malformed stream, 0 length" << op);
193 // if op != new, decode another size value
194 if (op != svn_txdelta_new) {
195 offset = decode_size(_ptr, pEnd);
198 if (op == svn_txdelta_target) {
199 // this is inefficent, but ranges can overlap.
201 output.push_back(output[offset++]);
204 } else if (op == svn_txdelta_new) {
205 output.insert(output.end(), newData, newData + length);
207 } else if (op == svn_txdelta_source) {
208 source.seekg(offset);
209 char* sourceBuf = (char*) malloc(length);
211 source.read(sourceBuf, length);
212 output.insert(output.end(), sourceBuf, sourceBuf + length);
215 SG_LOG(SG_IO, SG_WARN, "bad opcode logic");
218 } // of instruction loop
225 return headerLength + instructionLength + newLength;
228 unsigned int sourceViewOffset;
229 size_t sourceViewLength,
240 } // of anonymous namespace
242 class SVNReportParser::SVNReportParserPrivate
245 SVNReportParserPrivate(SVNRepository* repo) :
247 status(SVNRepository::SVN_NO_ERROR),
249 currentPath(repo->fsBase())
252 currentDir = repo->rootDir();
255 ~SVNReportParserPrivate()
259 void startElement (const char * name, const char** attributes)
261 if (status != SVNRepository::SVN_NO_ERROR) {
265 ExpatAtts attrs(attributes);
266 tagStack.push_back(name);
267 if (!strcmp(name, SVN_TXDELTA_TAG)) {
269 } else if (!strcmp(name, SVN_ADD_FILE_TAG)) {
270 string fileName(attrs.getValue("name"));
271 SGPath filePath(currentDir->fsDir().file(fileName));
272 currentPath = filePath;
274 } else if (!strcmp(name, SVN_OPEN_FILE_TAG)) {
275 string fileName(attrs.getValue("name"));
276 SGPath filePath(Dir(currentPath).file(fileName));
277 currentPath = filePath;
279 if (!filePath.exists()) {
280 fail(SVNRepository::SVN_ERROR_FILE_NOT_FOUND);
285 } else if (!strcmp(name, SVN_ADD_DIRECTORY_TAG)) {
286 string dirName(attrs.getValue("name"));
287 Dir d(currentDir->fsDir().file(dirName));
289 // policy decision : if we're doing an add, wipe the existing
293 currentDir = currentDir->addChildDirectory(dirName);
294 currentPath = currentDir->fsPath();
295 currentDir->beginUpdateReport();
296 //cout << "addDir:" << currentPath << endl;
297 } else if (!strcmp(name, SVN_SET_PROP_TAG)) {
298 setPropName = attrs.getValue("name");
299 setPropValue.clear();
300 } else if (!strcmp(name, SVN_DAV_MD5_CHECKSUM)) {
302 } else if (!strcmp(name, SVN_OPEN_DIRECTORY_TAG)) {
304 if (attrs.getValue("name")) {
305 dirName = string(attrs.getValue("name"));
307 openDirectory(dirName);
308 } else if (!strcmp(name, SVN_DELETE_ENTRY_TAG)) {
309 string entryName(attrs.getValue("name"));
310 deleteEntry(entryName);
311 } else if (!strcmp(name, DAV_CHECKED_IN_TAG) ||
312 !strcmp(name, DAV_HREF_TAG) ||
313 !strcmp(name, SVN_PROP_TAG)) {
314 // don't warn on these ones
316 //SG_LOG(SG_IO, SG_WARN, "SVNReportParser: unhandled tag:" << name);
320 void openDirectory(const std::string& dirName)
322 if (dirName.empty()) {
323 // root directory, we shall assume
324 currentDir = tree->rootDir();
327 currentDir = currentDir->child(dirName);
331 currentPath = currentDir->fsPath();
332 currentDir->beginUpdateReport();
335 void deleteEntry(const std::string& entryName)
337 currentDir->deleteChildByName(entryName);
340 bool decodeTextDelta(const SGPath& outputPath)
342 std::vector<unsigned char> output, decoded;
343 strutils::decodeBase64(txDeltaData, decoded);
344 size_t bytesToDecode = decoded.size();
346 unsigned char* p = decoded.data();
347 if (memcmp(p, "SVN\0", DELTA_HEADER_SIZE) != 0) {
348 return false; // bad header
351 bytesToDecode -= DELTA_HEADER_SIZE;
352 p += DELTA_HEADER_SIZE;
353 std::ifstream source;
354 source.open(outputPath.c_str(), std::ios::in | std::ios::binary);
356 while (bytesToDecode > 0) {
357 if (!SVNDeltaWindow::isWindowComplete(p, bytesToDecode)) {
358 SG_LOG(SG_IO, SG_WARN, "SVN txdelta broken window");
362 SVNDeltaWindow window(p);
363 assert(bytesToDecode >= window.size());
364 window.apply(output, source);
365 bytesToDecode -= window.size();
372 f.open(outputPath.c_str(),
373 std::ios::out | std::ios::trunc | std::ios::binary);
374 f.write((char*) output.data(), output.size());
376 // compute MD5 while we have the file in memory
377 memset(&md5Context, 0, sizeof(SG_MD5_CTX));
378 SG_MD5Init(&md5Context);
379 SG_MD5Update(&md5Context, (unsigned char*) output.data(), output.size());
380 unsigned char digest[MD5_DIGEST_LENGTH];
381 SG_MD5Final(digest, &md5Context);
382 decodedFileMd5 = strutils::encodeHex(digest, MD5_DIGEST_LENGTH);
387 void endElement (const char * name)
389 if (status != SVNRepository::SVN_NO_ERROR) {
393 assert(tagStack.back() == name);
396 if (!strcmp(name, SVN_TXDELTA_TAG)) {
397 if (!decodeTextDelta(currentPath)) {
398 fail(SVNRepository::SVN_ERROR_TXDELTA);
400 } else if (!strcmp(name, SVN_ADD_FILE_TAG)) {
401 finishFile(currentPath);
402 } else if (!strcmp(name, SVN_OPEN_FILE_TAG)) {
403 finishFile(currentPath);
404 } else if (!strcmp(name, SVN_ADD_DIRECTORY_TAG)) {
406 currentPath = currentPath.dir();
407 currentDir->updateReportComplete();
408 currentDir = currentDir->parent();
409 } else if (!strcmp(name, SVN_SET_PROP_TAG)) {
410 if (setPropName == "svn:entry:committed-rev") {
411 revision = strutils::to_int(setPropValue);
412 currentVersionName = setPropValue;
414 // for directories we have the resource already
415 // for adding files, we might not; we set the version name
416 // above when ending the add/open-file element
417 currentDir->collection()->setVersionName(currentVersionName);
420 } else if (!strcmp(name, SVN_DAV_MD5_CHECKSUM)) {
421 // validate against (presumably) just written file
422 if (decodedFileMd5 != md5Sum) {
423 fail(SVNRepository::SVN_ERROR_CHECKSUM);
425 } else if (!strcmp(name, SVN_OPEN_DIRECTORY_TAG)) {
426 currentDir->updateReportComplete();
427 if (currentDir->parent()) {
428 // pop the collection stack
429 currentDir = currentDir->parent();
432 currentPath = currentDir->fsPath();
434 // std::cout << "element:" << name;
438 void finishFile(const SGPath& path)
440 currentPath = path.dir();
444 void data (const char * s, int length)
446 if (status != SVNRepository::SVN_NO_ERROR) {
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);
459 void pi (const char * target, const char * data) {}
461 string tagN(const unsigned int n) const
463 size_t sz = tagStack.size();
468 return tagStack[sz - (1 + n)];
471 void fail(SVNRepository::ResultCode err)
477 DAVCollection* rootCollection;
478 SVNDirectory* currentDir;
479 SVNRepository::ResultCode status;
482 XML_Parser xmlParser;
485 string_list tagStack;
486 string currentVersionName;
491 unsigned int revision;
492 SG_MD5_CTX md5Context;
493 string md5Sum, decodedFileMd5;
494 std::string setPropName, setPropValue;
498 ////////////////////////////////////////////////////////////////////////
499 // Static callback functions for Expat.
500 ////////////////////////////////////////////////////////////////////////
502 #define VISITOR static_cast<SVNReportParser::SVNReportParserPrivate *>(userData)
505 start_element (void * userData, const char * name, const char ** atts)
507 VISITOR->startElement(name, atts);
511 end_element (void * userData, const char * name)
513 VISITOR->endElement(name);
517 character_data (void * userData, const char * s, int len)
519 VISITOR->data(s, len);
523 processing_instruction (void * userData,
527 VISITOR->pi(target, data);
532 ///////////////////////////////////////////////////////////////////////////////
534 SVNReportParser::SVNReportParser(SVNRepository* repo) :
535 _d(new SVNReportParserPrivate(repo))
540 SVNReportParser::~SVNReportParser()
544 SVNRepository::ResultCode
545 SVNReportParser::innerParseXML(const char* data, int size)
547 if (_d->status != SVNRepository::SVN_NO_ERROR) {
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));
557 XML_ParserFree(_d->xmlParser);
558 _d->parserInited = false;
559 return SVNRepository::SVN_ERROR_XML;
561 XML_ParserFree(_d->xmlParser);
562 _d->parserInited = false;
568 SVNRepository::ResultCode
569 SVNReportParser::parseXML(const char* data, int size)
571 if (_d->status != SVNRepository::SVN_NO_ERROR) {
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;
584 return innerParseXML(data, size);
587 SVNRepository::ResultCode SVNReportParser::finishParse()
589 if (_d->status != SVNRepository::SVN_NO_ERROR) {
593 return innerParseXML(NULL, 0);
596 std::string SVNReportParser::etagFromRevision(unsigned int revision)
598 // etags look like W/"7//", hopefully this is stable
599 // across different servers and similar
600 std::ostringstream os;
601 os << "W/\"" << revision << "//";