Revision: 76518
http://sourceforge.net/p/brlcad/code/76518
Author: starseeker
Date: 2020-07-27 14:50:08 +0000 (Mon, 27 Jul 2020)
Log Message:
-----------
Make verify a bit more self contained
Modified Paths:
--------------
brlcad/trunk/misc/CMakeLists.txt
Added Paths:
-----------
brlcad/trunk/misc/repoconv/verify/cvs.sh
brlcad/trunk/misc/repoconv/verify/md5.hpp
brlcad/trunk/misc/repoconv/verify/sha1.hpp
brlcad/trunk/misc/repoconv/verify/svn.sh
brlcad/trunk/misc/repoconv/verify/svn_de-rcs.cxx
brlcad/trunk/misc/repoconv/verify/verify.sh
Modified: brlcad/trunk/misc/CMakeLists.txt
===================================================================
--- brlcad/trunk/misc/CMakeLists.txt 2020-07-27 12:47:29 UTC (rev 76517)
+++ brlcad/trunk/misc/CMakeLists.txt 2020-07-27 14:50:08 UTC (rev 76518)
@@ -255,8 +255,14 @@
repoconv/sync_commit_trunk.sh
repoconv/tagmap.sh
repoconv/terra.dsp
+ repoconv/verify/cvs.sh
repoconv/verify/cxxopts.hpp
+ repoconv/verify/md5.hpp
+ repoconv/verify/sha1.hpp
+ repoconv/verify/svn.sh
+ repoconv/verify/svn_de-rcs.cxx
repoconv/verify/verify.cpp
+ repoconv/verify/verify.sh
repowork/COPYING
repowork/README
repowork/blob.cpp
Added: brlcad/trunk/misc/repoconv/verify/cvs.sh
===================================================================
--- brlcad/trunk/misc/repoconv/verify/cvs.sh (rev 0)
+++ brlcad/trunk/misc/repoconv/verify/cvs.sh 2020-07-27 14:50:08 UTC (rev
76518)
@@ -0,0 +1,29 @@
+#!/bin/bash
+if [ ! -e "brlcad_cvs.tar.gz" ]; then
+ curl -o brlcad_cvs.tar.gz https://brlcad.org/brlcad_cvs.tar.gz
+fi
+rm -rf brlcad_cvs
+tar -xf brlcad_cvs.tar.gz
+cd brlcad_cvs/brlcad
+rm src/librt/Attic/parse.c,v
+rm pix/sphflake.pix,v
+cp ../../cvs_repaired/sphflake.pix,v pix/
+# RCS headers introduce unnecessary file differences, which are poison pills
+# for git log --follow
+echo "Scrubbing expanded RCS headers"
+echo "Date"
+find . -type f -exec sed -i 's/$Date:[^$;"]*/$Date/' {} \;
+echo "Header"
+find . -type f -exec sed -i 's/$Header:[^$;"]*/$Header/' {} \;
+echo "Id"
+find . -type f -exec sed -i 's/$Id:[^$;"]*/$Id/' {} \;
+echo "Log"
+find . -type f -exec sed -i 's/$Log:[^$;"]*/$Log/' {} \;
+echo "Revision"
+find . -type f -exec sed -i 's/$Revision:[^$;"]*/$Revision/' {} \;
+echo "Source"
+find . -type f -exec sed -i 's/$Source:[^$;"]*/$Source/' {} \;
+sed -i 's/$Author:[^$;"]*/$Author/' misc/Attic/cvs2cl.pl,v
+sed -i 's/$Author:[^$;"]*/$Author/' sh/Attic/cvs2cl.pl,v
+sed -i 's/$Locker:[^$;"]*/$Locker/' src/other/URToolkit/tools/mallocNd.c,v
+
Property changes on: brlcad/trunk/misc/repoconv/verify/cvs.sh
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/x-sh
\ No newline at end of property
Added: brlcad/trunk/misc/repoconv/verify/md5.hpp
===================================================================
--- brlcad/trunk/misc/repoconv/verify/md5.hpp (rev 0)
+++ brlcad/trunk/misc/repoconv/verify/md5.hpp 2020-07-27 14:50:08 UTC (rev
76518)
@@ -0,0 +1,437 @@
+/* This utility includes a de-namespaced version of
+ *
https://github.com/Microsoft/cpprestsdk/blob/master/Release/libs/websocketpp/websocketpp/common/md5.hpp
+ * to be self contained: */
+
+/*
+ md5.hpp is a reformulation of the md5.h and md5.c code from
+ http://www.opensource.apple.com/source/cups/cups-59/cups/md5.c to allow it
to
+ function as a component of a header only library. This conversion was done
by
+ Peter Thorson ([email protected]) in 2012 for the WebSocket++ project.
The
+ changes are released under the same license as the original (listed below)
+ */
+/*
+ Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved.
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ L. Peter Deutsch
+ [email protected]
+ */
+/*
+ Independent implementation of MD5 (RFC 1321).
+ This code implements the MD5 Algorithm defined in RFC 1321, whose
+ text is available at
+ http://www.ietf.org/rfc/rfc1321.txt
+ The code is derived from the text of the RFC, including the test suite
+ (section A.5) but excluding the rest of Appendix A. It does not include
+ any code or documentation that is identified in the RFC as being
+ copyrighted.
+ The original and principal author of md5.h is L. Peter Deutsch
+ <[email protected]>. Other authors are noted in the change history
+ that follows (in reverse chronological order):
+ 2002-04-13 lpd Removed support for non-ANSI compilers; removed
+ references to Ghostscript; clarified derivation from RFC 1321;
+ now handles byte order either statically or dynamically.
+ 1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+ 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
+ added conditionalization for C++ compilation from Martin
+ Purschke <[email protected]>.
+ 1999-05-03 lpd Original version.
+ */
+
+#ifndef MD5_HPP
+#define MD5_HPP
+
+/*
+ * This package supports both compile-time and run-time determination of CPU
+ * byte order. If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be
+ * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is
+ * defined as non-zero, the code will be compiled to run only on big-endian
+ * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to
+ * run on either big- or little-endian CPUs, but will run slightly less
+ * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined.
+ */
+
+#include <stddef.h>
+#include <string>
+#include <cstring>
+
+typedef unsigned char md5_byte_t; /* 8-bit byte */
+typedef unsigned int md5_word_t; /* 32-bit word */
+
+/* Define the state of the MD5 Algorithm. */
+typedef struct md5_state_s {
+ md5_word_t count[2]; /* message length in bits, lsw first */
+ md5_word_t abcd[4]; /* digest buffer */
+ md5_byte_t buf[64]; /* accumulate block */
+} md5_state_t;
+
+/* Initialize the algorithm. */
+inline void md5_init(md5_state_t *pms);
+
+/* Append a string to the message. */
+inline void md5_append(md5_state_t *pms, md5_byte_t const * data, size_t
nbytes);
+
+/* Finish the message and return the digest. */
+inline void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
+
+#undef ZSW_MD5_BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown
*/
+#ifdef ARCH_IS_BIG_ENDIAN
+# define ZSW_MD5_BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
+#else
+# define ZSW_MD5_BYTE_ORDER 0
+#endif
+
+#define ZSW_MD5_T_MASK ((md5_word_t)~0)
+#define ZSW_MD5_T1 /* 0xd76aa478 */ (ZSW_MD5_T_MASK ^ 0x28955b87)
+#define ZSW_MD5_T2 /* 0xe8c7b756 */ (ZSW_MD5_T_MASK ^ 0x173848a9)
+#define ZSW_MD5_T3 0x242070db
+#define ZSW_MD5_T4 /* 0xc1bdceee */ (ZSW_MD5_T_MASK ^ 0x3e423111)
+#define ZSW_MD5_T5 /* 0xf57c0faf */ (ZSW_MD5_T_MASK ^ 0x0a83f050)
+#define ZSW_MD5_T6 0x4787c62a
+#define ZSW_MD5_T7 /* 0xa8304613 */ (ZSW_MD5_T_MASK ^ 0x57cfb9ec)
+#define ZSW_MD5_T8 /* 0xfd469501 */ (ZSW_MD5_T_MASK ^ 0x02b96afe)
+#define ZSW_MD5_T9 0x698098d8
+#define ZSW_MD5_T10 /* 0x8b44f7af */ (ZSW_MD5_T_MASK ^ 0x74bb0850)
+#define ZSW_MD5_T11 /* 0xffff5bb1 */ (ZSW_MD5_T_MASK ^ 0x0000a44e)
+#define ZSW_MD5_T12 /* 0x895cd7be */ (ZSW_MD5_T_MASK ^ 0x76a32841)
+#define ZSW_MD5_T13 0x6b901122
+#define ZSW_MD5_T14 /* 0xfd987193 */ (ZSW_MD5_T_MASK ^ 0x02678e6c)
+#define ZSW_MD5_T15 /* 0xa679438e */ (ZSW_MD5_T_MASK ^ 0x5986bc71)
+#define ZSW_MD5_T16 0x49b40821
+#define ZSW_MD5_T17 /* 0xf61e2562 */ (ZSW_MD5_T_MASK ^ 0x09e1da9d)
+#define ZSW_MD5_T18 /* 0xc040b340 */ (ZSW_MD5_T_MASK ^ 0x3fbf4cbf)
+#define ZSW_MD5_T19 0x265e5a51
+#define ZSW_MD5_T20 /* 0xe9b6c7aa */ (ZSW_MD5_T_MASK ^ 0x16493855)
+#define ZSW_MD5_T21 /* 0xd62f105d */ (ZSW_MD5_T_MASK ^ 0x29d0efa2)
+#define ZSW_MD5_T22 0x02441453
+#define ZSW_MD5_T23 /* 0xd8a1e681 */ (ZSW_MD5_T_MASK ^ 0x275e197e)
+#define ZSW_MD5_T24 /* 0xe7d3fbc8 */ (ZSW_MD5_T_MASK ^ 0x182c0437)
+#define ZSW_MD5_T25 0x21e1cde6
+#define ZSW_MD5_T26 /* 0xc33707d6 */ (ZSW_MD5_T_MASK ^ 0x3cc8f829)
+#define ZSW_MD5_T27 /* 0xf4d50d87 */ (ZSW_MD5_T_MASK ^ 0x0b2af278)
+#define ZSW_MD5_T28 0x455a14ed
+#define ZSW_MD5_T29 /* 0xa9e3e905 */ (ZSW_MD5_T_MASK ^ 0x561c16fa)
+#define ZSW_MD5_T30 /* 0xfcefa3f8 */ (ZSW_MD5_T_MASK ^ 0x03105c07)
+#define ZSW_MD5_T31 0x676f02d9
+#define ZSW_MD5_T32 /* 0x8d2a4c8a */ (ZSW_MD5_T_MASK ^ 0x72d5b375)
+#define ZSW_MD5_T33 /* 0xfffa3942 */ (ZSW_MD5_T_MASK ^ 0x0005c6bd)
+#define ZSW_MD5_T34 /* 0x8771f681 */ (ZSW_MD5_T_MASK ^ 0x788e097e)
+#define ZSW_MD5_T35 0x6d9d6122
+#define ZSW_MD5_T36 /* 0xfde5380c */ (ZSW_MD5_T_MASK ^ 0x021ac7f3)
+#define ZSW_MD5_T37 /* 0xa4beea44 */ (ZSW_MD5_T_MASK ^ 0x5b4115bb)
+#define ZSW_MD5_T38 0x4bdecfa9
+#define ZSW_MD5_T39 /* 0xf6bb4b60 */ (ZSW_MD5_T_MASK ^ 0x0944b49f)
+#define ZSW_MD5_T40 /* 0xbebfbc70 */ (ZSW_MD5_T_MASK ^ 0x4140438f)
+#define ZSW_MD5_T41 0x289b7ec6
+#define ZSW_MD5_T42 /* 0xeaa127fa */ (ZSW_MD5_T_MASK ^ 0x155ed805)
+#define ZSW_MD5_T43 /* 0xd4ef3085 */ (ZSW_MD5_T_MASK ^ 0x2b10cf7a)
+#define ZSW_MD5_T44 0x04881d05
+#define ZSW_MD5_T45 /* 0xd9d4d039 */ (ZSW_MD5_T_MASK ^ 0x262b2fc6)
+#define ZSW_MD5_T46 /* 0xe6db99e5 */ (ZSW_MD5_T_MASK ^ 0x1924661a)
+#define ZSW_MD5_T47 0x1fa27cf8
+#define ZSW_MD5_T48 /* 0xc4ac5665 */ (ZSW_MD5_T_MASK ^ 0x3b53a99a)
+#define ZSW_MD5_T49 /* 0xf4292244 */ (ZSW_MD5_T_MASK ^ 0x0bd6ddbb)
+#define ZSW_MD5_T50 0x432aff97
+#define ZSW_MD5_T51 /* 0xab9423a7 */ (ZSW_MD5_T_MASK ^ 0x546bdc58)
+#define ZSW_MD5_T52 /* 0xfc93a039 */ (ZSW_MD5_T_MASK ^ 0x036c5fc6)
+#define ZSW_MD5_T53 0x655b59c3
+#define ZSW_MD5_T54 /* 0x8f0ccc92 */ (ZSW_MD5_T_MASK ^ 0x70f3336d)
+#define ZSW_MD5_T55 /* 0xffeff47d */ (ZSW_MD5_T_MASK ^ 0x00100b82)
+#define ZSW_MD5_T56 /* 0x85845dd1 */ (ZSW_MD5_T_MASK ^ 0x7a7ba22e)
+#define ZSW_MD5_T57 0x6fa87e4f
+#define ZSW_MD5_T58 /* 0xfe2ce6e0 */ (ZSW_MD5_T_MASK ^ 0x01d3191f)
+#define ZSW_MD5_T59 /* 0xa3014314 */ (ZSW_MD5_T_MASK ^ 0x5cfebceb)
+#define ZSW_MD5_T60 0x4e0811a1
+#define ZSW_MD5_T61 /* 0xf7537e82 */ (ZSW_MD5_T_MASK ^ 0x08ac817d)
+#define ZSW_MD5_T62 /* 0xbd3af235 */ (ZSW_MD5_T_MASK ^ 0x42c50dca)
+#define ZSW_MD5_T63 0x2ad7d2bb
+#define ZSW_MD5_T64 /* 0xeb86d391 */ (ZSW_MD5_T_MASK ^ 0x14792c6e)
+
+static void md5_process(md5_state_t *pms, md5_byte_t const * data /*[64]*/) {
+ md5_word_t
+ a = pms->abcd[0], b = pms->abcd[1],
+ c = pms->abcd[2], d = pms->abcd[3];
+ md5_word_t t;
+#if ZSW_MD5_BYTE_ORDER > 0
+ /* Define storage only for big-endian CPUs. */
+ md5_word_t X[16];
+#else
+ /* Define storage for little-endian or both types of CPUs. */
+ md5_word_t xbuf[16];
+ md5_word_t const * X;
+#endif
+
+ {
+#if ZSW_MD5_BYTE_ORDER == 0
+ /*
+ * Determine dynamically whether this is a big-endian or
+ * little-endian machine, since we can use a more efficient
+ * algorithm on the latter.
+ */
+ static int const w = 1;
+
+ if (*((md5_byte_t const *)&w)) /* dynamic little-endian */
+#endif
+#if ZSW_MD5_BYTE_ORDER <= 0 /* little-endian */
+ {
+ /*
+ * On little-endian machines, we can process properly aligned
+ * data without copying it.
+ */
+ if (!((data - (md5_byte_t const *)0) & 3)) {
+ /* data are properly aligned */
+ X = (md5_word_t const *)data;
+ } else {
+ /* not aligned */
+ std::memcpy(xbuf, data, 64);
+ X = xbuf;
+ }
+ }
+#endif
+#if ZSW_MD5_BYTE_ORDER == 0
+ else /* dynamic big-endian */
+#endif
+#if ZSW_MD5_BYTE_ORDER >= 0 /* big-endian */
+ {
+ /*
+ * On big-endian machines, we must arrange the bytes in the
+ * right order.
+ */
+ const md5_byte_t *xp = data;
+ int i;
+
+# if ZSW_MD5_BYTE_ORDER == 0
+ X = xbuf; /* (dynamic only) */
+# else
+# define xbuf X /* (static only) */
+# endif
+ for (i = 0; i < 16; ++i, xp += 4)
+ xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
+ }
+#endif
+ }
+
+#define ZSW_MD5_ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+
+ /* Round 1. */
+ /* Let [abcd k s i] denote the operation
+ a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
+#define ZSW_MD5_F(x, y, z) (((x) & (y)) | (~(x) & (z)))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + ZSW_MD5_F(b,c,d) + X[k] + Ti;\
+ a = ZSW_MD5_ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 0, 7, ZSW_MD5_T1);
+ SET(d, a, b, c, 1, 12, ZSW_MD5_T2);
+ SET(c, d, a, b, 2, 17, ZSW_MD5_T3);
+ SET(b, c, d, a, 3, 22, ZSW_MD5_T4);
+ SET(a, b, c, d, 4, 7, ZSW_MD5_T5);
+ SET(d, a, b, c, 5, 12, ZSW_MD5_T6);
+ SET(c, d, a, b, 6, 17, ZSW_MD5_T7);
+ SET(b, c, d, a, 7, 22, ZSW_MD5_T8);
+ SET(a, b, c, d, 8, 7, ZSW_MD5_T9);
+ SET(d, a, b, c, 9, 12, ZSW_MD5_T10);
+ SET(c, d, a, b, 10, 17, ZSW_MD5_T11);
+ SET(b, c, d, a, 11, 22, ZSW_MD5_T12);
+ SET(a, b, c, d, 12, 7, ZSW_MD5_T13);
+ SET(d, a, b, c, 13, 12, ZSW_MD5_T14);
+ SET(c, d, a, b, 14, 17, ZSW_MD5_T15);
+ SET(b, c, d, a, 15, 22, ZSW_MD5_T16);
+#undef SET
+
+ /* Round 2. */
+ /* Let [abcd k s i] denote the operation
+ a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
+#define ZSW_MD5_G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + ZSW_MD5_G(b,c,d) + X[k] + Ti;\
+ a = ZSW_MD5_ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 1, 5, ZSW_MD5_T17);
+ SET(d, a, b, c, 6, 9, ZSW_MD5_T18);
+ SET(c, d, a, b, 11, 14, ZSW_MD5_T19);
+ SET(b, c, d, a, 0, 20, ZSW_MD5_T20);
+ SET(a, b, c, d, 5, 5, ZSW_MD5_T21);
+ SET(d, a, b, c, 10, 9, ZSW_MD5_T22);
+ SET(c, d, a, b, 15, 14, ZSW_MD5_T23);
+ SET(b, c, d, a, 4, 20, ZSW_MD5_T24);
+ SET(a, b, c, d, 9, 5, ZSW_MD5_T25);
+ SET(d, a, b, c, 14, 9, ZSW_MD5_T26);
+ SET(c, d, a, b, 3, 14, ZSW_MD5_T27);
+ SET(b, c, d, a, 8, 20, ZSW_MD5_T28);
+ SET(a, b, c, d, 13, 5, ZSW_MD5_T29);
+ SET(d, a, b, c, 2, 9, ZSW_MD5_T30);
+ SET(c, d, a, b, 7, 14, ZSW_MD5_T31);
+ SET(b, c, d, a, 12, 20, ZSW_MD5_T32);
+#undef SET
+
+ /* Round 3. */
+ /* Let [abcd k s t] denote the operation
+ a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
+#define ZSW_MD5_H(x, y, z) ((x) ^ (y) ^ (z))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + ZSW_MD5_H(b,c,d) + X[k] + Ti;\
+ a = ZSW_MD5_ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 5, 4, ZSW_MD5_T33);
+ SET(d, a, b, c, 8, 11, ZSW_MD5_T34);
+ SET(c, d, a, b, 11, 16, ZSW_MD5_T35);
+ SET(b, c, d, a, 14, 23, ZSW_MD5_T36);
+ SET(a, b, c, d, 1, 4, ZSW_MD5_T37);
+ SET(d, a, b, c, 4, 11, ZSW_MD5_T38);
+ SET(c, d, a, b, 7, 16, ZSW_MD5_T39);
+ SET(b, c, d, a, 10, 23, ZSW_MD5_T40);
+ SET(a, b, c, d, 13, 4, ZSW_MD5_T41);
+ SET(d, a, b, c, 0, 11, ZSW_MD5_T42);
+ SET(c, d, a, b, 3, 16, ZSW_MD5_T43);
+ SET(b, c, d, a, 6, 23, ZSW_MD5_T44);
+ SET(a, b, c, d, 9, 4, ZSW_MD5_T45);
+ SET(d, a, b, c, 12, 11, ZSW_MD5_T46);
+ SET(c, d, a, b, 15, 16, ZSW_MD5_T47);
+ SET(b, c, d, a, 2, 23, ZSW_MD5_T48);
+#undef SET
+
+ /* Round 4. */
+ /* Let [abcd k s t] denote the operation
+ a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
+#define ZSW_MD5_I(x, y, z) ((y) ^ ((x) | ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + ZSW_MD5_I(b,c,d) + X[k] + Ti;\
+ a = ZSW_MD5_ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 0, 6, ZSW_MD5_T49);
+ SET(d, a, b, c, 7, 10, ZSW_MD5_T50);
+ SET(c, d, a, b, 14, 15, ZSW_MD5_T51);
+ SET(b, c, d, a, 5, 21, ZSW_MD5_T52);
+ SET(a, b, c, d, 12, 6, ZSW_MD5_T53);
+ SET(d, a, b, c, 3, 10, ZSW_MD5_T54);
+ SET(c, d, a, b, 10, 15, ZSW_MD5_T55);
+ SET(b, c, d, a, 1, 21, ZSW_MD5_T56);
+ SET(a, b, c, d, 8, 6, ZSW_MD5_T57);
+ SET(d, a, b, c, 15, 10, ZSW_MD5_T58);
+ SET(c, d, a, b, 6, 15, ZSW_MD5_T59);
+ SET(b, c, d, a, 13, 21, ZSW_MD5_T60);
+ SET(a, b, c, d, 4, 6, ZSW_MD5_T61);
+ SET(d, a, b, c, 11, 10, ZSW_MD5_T62);
+ SET(c, d, a, b, 2, 15, ZSW_MD5_T63);
+ SET(b, c, d, a, 9, 21, ZSW_MD5_T64);
+#undef SET
+
+ /* Then perform the following additions. (That is increment each
+ of the four registers by the value it had before this block
+ was started.) */
+ pms->abcd[0] += a;
+ pms->abcd[1] += b;
+ pms->abcd[2] += c;
+ pms->abcd[3] += d;
+}
+
+void md5_init(md5_state_t *pms) {
+ pms->count[0] = pms->count[1] = 0;
+ pms->abcd[0] = 0x67452301;
+ pms->abcd[1] = /*0xefcdab89*/ ZSW_MD5_T_MASK ^ 0x10325476;
+ pms->abcd[2] = /*0x98badcfe*/ ZSW_MD5_T_MASK ^ 0x67452301;
+ pms->abcd[3] = 0x10325476;
+}
+
+void md5_append(md5_state_t *pms, md5_byte_t const * data, size_t nbytes) {
+ md5_byte_t const * p = data;
+ size_t left = nbytes;
+ int offset = (pms->count[0] >> 3) & 63;
+ md5_word_t nbits = (md5_word_t)(nbytes << 3);
+
+ if (nbytes <= 0)
+ return;
+
+ /* Update the message length. */
+ pms->count[1] += nbytes >> 29;
+ pms->count[0] += nbits;
+ if (pms->count[0] < nbits)
+ pms->count[1]++;
+
+ /* Process an initial partial block. */
+ if (offset) {
+ int copy = (offset + nbytes > 64 ? 64 - offset :
static_cast<int>(nbytes));
+
+ std::memcpy(pms->buf + offset, p, copy);
+ if (offset + copy < 64)
+ return;
+ p += copy;
+ left -= copy;
+ md5_process(pms, pms->buf);
+ }
+
+ /* Process full blocks. */
+ for (; left >= 64; p += 64, left -= 64)
+ md5_process(pms, p);
+
+ /* Process a final partial block. */
+ if (left)
+ std::memcpy(pms->buf, p, left);
+}
+
+void md5_finish(md5_state_t *pms, md5_byte_t digest[16]) {
+ static md5_byte_t const pad[64] = {
+ 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+ };
+ md5_byte_t data[8];
+ int i;
+
+ /* Save the length before padding. */
+ for (i = 0; i < 8; ++i)
+ data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
+ /* Pad to 56 bytes mod 64. */
+ md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
+ /* Append the length. */
+ md5_append(pms, data, 8);
+ for (i = 0; i < 16; ++i)
+ digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
+}
+
+// some convenience c++ functions
+inline std::string md5_hash_string(const char *input, size_t len) {
+ char digest[16];
+
+ md5_state_t state;
+
+ md5_init(&state);
+ md5_append(&state, (md5_byte_t const *)input, len);
+ md5_finish(&state, (md5_byte_t *)digest);
+
+ std::string ret;
+ ret.resize(16);
+ std::copy(digest,digest+16,ret.begin());
+
+ return ret;
+}
+
+const char hexval[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f'};
+
+inline std::string md5_hash_hex(const char *input, size_t len) {
+ std::string hash = md5_hash_string(input, len);
+ std::string hex;
+
+ for (size_t i = 0; i < hash.size(); i++) {
+ hex.push_back(hexval[((hash[i] >> 4) & 0xF)]);
+ hex.push_back(hexval[(hash[i]) & 0x0F]);
+ }
+
+ return hex;
+}
+
+#endif // MD5_HPP
+
Property changes on: brlcad/trunk/misc/repoconv/verify/md5.hpp
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Added: brlcad/trunk/misc/repoconv/verify/sha1.hpp
===================================================================
--- brlcad/trunk/misc/repoconv/verify/sha1.hpp (rev 0)
+++ brlcad/trunk/misc/repoconv/verify/sha1.hpp 2020-07-27 14:50:08 UTC (rev
76518)
@@ -0,0 +1,337 @@
+/*
+SHA-1 in C
+By Steve Reid <[email protected]>
+100% Public Domain
+
+from https://github.com/clibs/sha1
+
+Test Vectors (from FIPS PUB 180-1)
+"abc"
+ A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+ 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
+A million repetitions of "a"
+ 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
+*/
+
+/* #define LITTLE_ENDIAN * This should be #define'd already, if true. */
+/* #define SHA1HANDSOFF * Copies data before messing with it. */
+
+#define SHA1HANDSOFF
+
+#include <stdio.h>
+#include <string.h>
+
+/* for uint32_t */
+#include <stdint.h>
+
+typedef struct
+{
+ uint32_t state[5];
+ uint32_t count[2];
+ unsigned char buffer[64];
+} SHA1_CTX;
+
+void SHA1Transform(
+ uint32_t state[5],
+ const unsigned char buffer[64]
+ );
+
+void SHA1Init(
+ SHA1_CTX * context
+ );
+
+void SHA1Update(
+ SHA1_CTX * context,
+ const unsigned char *data,
+ uint32_t len
+ );
+
+void SHA1Final(
+ unsigned char digest[20],
+ SHA1_CTX * context
+ );
+
+void SHA1(
+ char *hash_out,
+ const char *str,
+ int len);
+
+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+
+/* blk0() and blk() perform the initial expand. */
+/* I got the idea of expanding during the round function from SSLeay */
+#if BYTE_ORDER == LITTLE_ENDIAN
+#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
+ |(rol(block->l[i],8)&0x00FF00FF))
+#elif BYTE_ORDER == BIG_ENDIAN
+#define blk0(i) block->l[i]
+#else
+#error "Endianness not defined!"
+#endif
+#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
+ ^block->l[(i+2)&15]^block->l[i&15],1))
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define R0(v,w,x,y,z,i)
z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R1(v,w,x,y,z,i)
z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
+#define R3(v,w,x,y,z,i)
z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
+#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
+
+
+/* Hash a single 512-bit block. This is the core of the algorithm. */
+
+void SHA1Transform(
+ uint32_t state[5],
+ const unsigned char buffer[64]
+)
+{
+ uint32_t a, b, c, d, e;
+
+ typedef union
+ {
+ unsigned char c[64];
+ uint32_t l[16];
+ } CHAR64LONG16;
+
+#ifdef SHA1HANDSOFF
+ CHAR64LONG16 block[1]; /* use array to appear as a pointer */
+
+ memcpy(block, buffer, 64);
+#else
+ /* The following had better never be used because it causes the
+ * pointer-to-const buffer to be cast into a pointer to non-const.
+ * And the result is written through. I threw a "const" in, hoping
+ * this will cause a diagnostic.
+ */
+ CHAR64LONG16 *block = (const CHAR64LONG16 *) buffer;
+#endif
+ /* Copy context->state[] to working vars */
+ a = state[0];
+ b = state[1];
+ c = state[2];
+ d = state[3];
+ e = state[4];
+ /* 4 rounds of 20 operations each. Loop unrolled. */
+ R0(a, b, c, d, e, 0);
+ R0(e, a, b, c, d, 1);
+ R0(d, e, a, b, c, 2);
+ R0(c, d, e, a, b, 3);
+ R0(b, c, d, e, a, 4);
+ R0(a, b, c, d, e, 5);
+ R0(e, a, b, c, d, 6);
+ R0(d, e, a, b, c, 7);
+ R0(c, d, e, a, b, 8);
+ R0(b, c, d, e, a, 9);
+ R0(a, b, c, d, e, 10);
+ R0(e, a, b, c, d, 11);
+ R0(d, e, a, b, c, 12);
+ R0(c, d, e, a, b, 13);
+ R0(b, c, d, e, a, 14);
+ R0(a, b, c, d, e, 15);
+ R1(e, a, b, c, d, 16);
+ R1(d, e, a, b, c, 17);
+ R1(c, d, e, a, b, 18);
+ R1(b, c, d, e, a, 19);
+ R2(a, b, c, d, e, 20);
+ R2(e, a, b, c, d, 21);
+ R2(d, e, a, b, c, 22);
+ R2(c, d, e, a, b, 23);
+ R2(b, c, d, e, a, 24);
+ R2(a, b, c, d, e, 25);
+ R2(e, a, b, c, d, 26);
+ R2(d, e, a, b, c, 27);
+ R2(c, d, e, a, b, 28);
+ R2(b, c, d, e, a, 29);
+ R2(a, b, c, d, e, 30);
+ R2(e, a, b, c, d, 31);
+ R2(d, e, a, b, c, 32);
+ R2(c, d, e, a, b, 33);
+ R2(b, c, d, e, a, 34);
+ R2(a, b, c, d, e, 35);
+ R2(e, a, b, c, d, 36);
+ R2(d, e, a, b, c, 37);
+ R2(c, d, e, a, b, 38);
+ R2(b, c, d, e, a, 39);
+ R3(a, b, c, d, e, 40);
+ R3(e, a, b, c, d, 41);
+ R3(d, e, a, b, c, 42);
+ R3(c, d, e, a, b, 43);
+ R3(b, c, d, e, a, 44);
+ R3(a, b, c, d, e, 45);
+ R3(e, a, b, c, d, 46);
+ R3(d, e, a, b, c, 47);
+ R3(c, d, e, a, b, 48);
+ R3(b, c, d, e, a, 49);
+ R3(a, b, c, d, e, 50);
+ R3(e, a, b, c, d, 51);
+ R3(d, e, a, b, c, 52);
+ R3(c, d, e, a, b, 53);
+ R3(b, c, d, e, a, 54);
+ R3(a, b, c, d, e, 55);
+ R3(e, a, b, c, d, 56);
+ R3(d, e, a, b, c, 57);
+ R3(c, d, e, a, b, 58);
+ R3(b, c, d, e, a, 59);
+ R4(a, b, c, d, e, 60);
+ R4(e, a, b, c, d, 61);
+ R4(d, e, a, b, c, 62);
+ R4(c, d, e, a, b, 63);
+ R4(b, c, d, e, a, 64);
+ R4(a, b, c, d, e, 65);
+ R4(e, a, b, c, d, 66);
+ R4(d, e, a, b, c, 67);
+ R4(c, d, e, a, b, 68);
+ R4(b, c, d, e, a, 69);
+ R4(a, b, c, d, e, 70);
+ R4(e, a, b, c, d, 71);
+ R4(d, e, a, b, c, 72);
+ R4(c, d, e, a, b, 73);
+ R4(b, c, d, e, a, 74);
+ R4(a, b, c, d, e, 75);
+ R4(e, a, b, c, d, 76);
+ R4(d, e, a, b, c, 77);
+ R4(c, d, e, a, b, 78);
+ R4(b, c, d, e, a, 79);
+ /* Add the working vars back into context.state[] */
+ state[0] += a;
+ state[1] += b;
+ state[2] += c;
+ state[3] += d;
+ state[4] += e;
+ /* Wipe variables */
+ a = b = c = d = e = 0;
+#ifdef SHA1HANDSOFF
+ memset(block, '\0', sizeof(block));
+#endif
+}
+
+
+/* SHA1Init - Initialize new context */
+
+void SHA1Init(
+ SHA1_CTX * context
+)
+{
+ /* SHA1 initialization constants */
+ context->state[0] = 0x67452301;
+ context->state[1] = 0xEFCDAB89;
+ context->state[2] = 0x98BADCFE;
+ context->state[3] = 0x10325476;
+ context->state[4] = 0xC3D2E1F0;
+ context->count[0] = context->count[1] = 0;
+}
+
+
+/* Run your data through this. */
+
+void SHA1Update(
+ SHA1_CTX * context,
+ const unsigned char *data,
+ uint32_t len
+)
+{
+ uint32_t i;
+
+ uint32_t j;
+
+ j = context->count[0];
+ if ((context->count[0] += len << 3) < j)
+ context->count[1]++;
+ context->count[1] += (len >> 29);
+ j = (j >> 3) & 63;
+ if ((j + len) > 63)
+ {
+ memcpy(&context->buffer[j], data, (i = 64 - j));
+ SHA1Transform(context->state, context->buffer);
+ for (; i + 63 < len; i += 64)
+ {
+ SHA1Transform(context->state, &data[i]);
+ }
+ j = 0;
+ }
+ else
+ i = 0;
+ memcpy(&context->buffer[j], &data[i], len - i);
+}
+
+
+/* Add padding and return the message digest. */
+
+void SHA1Final(
+ unsigned char digest[20],
+ SHA1_CTX * context
+)
+{
+ unsigned i;
+
+ unsigned char finalcount[8];
+
+ unsigned char c;
+
+#if 0 /* untested "improvement" by DHR */
+ /* Convert context->count to a sequence of bytes
+ * in finalcount. Second element first, but
+ * big-endian order within element.
+ * But we do it all backwards.
+ */
+ unsigned char *fcp = &finalcount[8];
+
+ for (i = 0; i < 2; i++)
+ {
+ uint32_t t = context->count[i];
+
+ int j;
+
+ for (j = 0; j < 4; t >>= 8, j++)
+ *--fcp = (unsigned char) t}
+#else
+ for (i = 0; i < 8; i++)
+ {
+ finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)] >>
((3 - (i & 3)) * 8)) & 255); /* Endian independent */
+ }
+#endif
+ c = 0200;
+ SHA1Update(context, &c, 1);
+ while ((context->count[0] & 504) != 448)
+ {
+ c = 0000;
+ SHA1Update(context, &c, 1);
+ }
+ SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
+ for (i = 0; i < 20; i++)
+ {
+ digest[i] = (unsigned char)
+ ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
+ }
+ /* Wipe variables */
+ memset(context, '\0', sizeof(*context));
+ memset(&finalcount, '\0', sizeof(finalcount));
+}
+
+void SHA1(
+ char *hash_out,
+ const char *str,
+ int len)
+{
+ SHA1_CTX ctx;
+ unsigned int ii;
+
+ SHA1Init(&ctx);
+ for (ii=0; ii<len; ii+=1)
+ SHA1Update(&ctx, (const unsigned char*)str + ii, 1);
+ SHA1Final((unsigned char *)hash_out, &ctx);
+ hash_out[20] = '\0';
+}
+
+std::string sha1_hash_hex(const char *buffer, int len)
+{
+ char sha1_result[21];
+ char sha1_hex[41];
+ SHA1(sha1_result, buffer, len);
+ for (size_t offset = 0; offset < 20; offset++) {
+ sprintf( ( sha1_hex + (2*offset)), "%02x", sha1_result[offset]&0xff);
+ }
+ return std::string(sha1_hex);
+}
Property changes on: brlcad/trunk/misc/repoconv/verify/sha1.hpp
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Added: brlcad/trunk/misc/repoconv/verify/svn.sh
===================================================================
--- brlcad/trunk/misc/repoconv/verify/svn.sh (rev 0)
+++ brlcad/trunk/misc/repoconv/verify/svn.sh 2020-07-27 14:50:08 UTC (rev
76518)
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+REPODIR="$PWD/brlcad_repo"
+
+echo "Rsyncing BRL-CAD SVN repository"
+mv $REPODIR code
+rsync -av svn.code.sf.net::p/brlcad/code .
+mv code $REPODIR
+
+# Make a dump file
+svnadmin dump $REPODIR > brlcad_full.dump
+
+# Strip the populated RCS tags from as much of the SVN repo
+# as we can, then use the new dump file to populate a
+# repo to make sure the dump file wasn't damaged
+g++ -O3 -o dercs svn_de-rcs.cxx
+rm -f brlcad_full_dercs.dump
+./dercs brlcad_full.dump brlcad_full_dercs.dump
+rm -rf repo_dercs
+svnadmin create repo_dercs
+svnadmin load repo_dercs < brlcad_full_dercs.dump
+
Property changes on: brlcad/trunk/misc/repoconv/verify/svn.sh
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/x-sh
\ No newline at end of property
Added: brlcad/trunk/misc/repoconv/verify/svn_de-rcs.cxx
===================================================================
--- brlcad/trunk/misc/repoconv/verify/svn_de-rcs.cxx
(rev 0)
+++ brlcad/trunk/misc/repoconv/verify/svn_de-rcs.cxx 2020-07-27 14:50:08 UTC
(rev 76518)
@@ -0,0 +1,574 @@
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <regex>
+#include "md5.hpp"
+#include "sha1.hpp"
+
+#define sfcmp(_s1, _s2) _s1.compare(0, _s2.size(), _s2) && _s1.size() >=
_s2.size()
+#define svn_str(_s1, _s2) (!sfcmp(_s1, _s2)) ? _s1.substr(_s2.size(),
_s1.size()-_s2.size()) : std::string()
+
+std::map<std::string, std::string> md5_map;
+std::map<std::string, std::string> sha1_map;
+
+bool is_binary(const char *cstr, int len, std::string &npath)
+{
+ // https://stackoverflow.com/a/567918/2037687
+ for (int i = 0; i < len; i++) {
+ if (cstr[i] == '\0') {
+ return true;
+ }
+ }
+
+ // We may be processing the file contents as C++ with regex - make
+ // sure we can represent the contents successfully.
+ std::string sbuff;
+ sbuff.assign(cstr, len);
+ if (sbuff.length() != len) {
+ std::cout << "C++ string representation failed (size delta " <<
abs(sbuff.length() - len) << "): " << npath << "\n";
+ return true;
+ }
+
+ return false;
+}
+
+bool skip_dercs(std::string &npath) {
+ if (npath.find("/re2c/") != std::string::npos) return false;
+ if (npath.find("/misc/Cakefile.defs") != std::string::npos) return false;
+ if (npath.find("/misc/win32-msvc8") != std::string::npos) return false;
+ if (npath.find("/misc/rcs2log") != std::string::npos) return false;
+ if (npath.find("/misc/win32-msvc") != std::string::npos) return false;
+ if (npath.find("/misc/archlinux/brlcad.install") != std::string::npos)
return false;
+ if (npath.find("/misc/brlcad.spec.in") != std::string::npos) return false;
+ if (npath.find("/misc/") != std::string::npos) return true;
+ if (npath.find("/src/other/step") != std::string::npos) return true;
+ if (npath.find("/src/conv/step") != std::string::npos) return true;
+ if (npath.find("/ap242.exp") != std::string::npos) return true;
+ return false;
+}
+
+std::string de_rcs(const char *cstr, int len)
+{
+ std::regex rcs_date("\\$Date:[^\\$;\"\n\r]*");
+ std::regex rcs_header("\\$Header:[^\\$;\"\n\r]*");
+ std::regex rcs_id("\\$Id:[^\\$;\"\n\r]*");
+ std::regex rcs_log("\\$Log:[^\\$;\"\n\r]*");
+ std::regex rcs_revision("\\$Revision:[^\\$;\"\n\r]*");
+ std::regex rcs_source("\\$Source:[^\\$;\"\n\r]*");
+ std::regex rcs_author("\\$Author:[^\\$;\"\n\r]*");
+ std::regex rcs_locker("\\$Locker:[^\\$;\"\n\r]*");
+
+ std::string buff01;
+ buff01.assign(cstr, len);
+ std::string buff02 = std::regex_replace(buff01, rcs_date, "$Date");
+ std::string buff03 = std::regex_replace(buff02, rcs_header, "$Header");
+ std::string buff04 = std::regex_replace(buff03, rcs_id, "$Id");
+ std::string buff05 = std::regex_replace(buff04, rcs_log, "$Log");
+ std::string buff06 = std::regex_replace(buff05, rcs_revision, "$Revision");
+ std::string buff07 = std::regex_replace(buff06, rcs_source, "$Source");
+ std::string buff08 = std::regex_replace(buff07, rcs_author, "$Author");
+ std::string buff09 = std::regex_replace(buff08, rcs_locker, "$Locker");
+
+#if 0
+ if (buff01 != buff09) {
+ std::ofstream ofile("orig.f", std::ios::out | std::ios::binary);
+ ofile.write(cstr, len);
+ ofile.close();
+ std::ofstream nfile("new.f", std::ios::out | std::ios::binary);
+ nfile << buff09;
+ nfile.close();
+
+ std::cout << "RCS stripping complete.\n";
+ }
+#endif
+ return buff09;
+}
+
+long int svn_lint(std::string s1, std::string s2)
+{
+ if (!s1.length() || !s2.length()) return -1;
+ return std::stol(svn_str(s1, s2));
+}
+
+/* Newer subversion doesn't like non-LF line endings in properties,
+ * so strip them out */
+void
+skip_rev_props(std::ifstream &infile, std::ofstream &outfile)
+{
+ std::string kkey("K ");
+ std::string pend("PROPS-END");
+ std::string line;
+
+ // Go until we hit PROPS-END
+ while (std::getline(infile, line) && line.compare(pend)) {
+ // K <N> line is the trigger
+ std::replace(line.begin(), line.end(), '\r', '\n');
+ outfile << line << "\n";
+ std::string key = svn_str(line, kkey);
+ if (!key.length()) continue;
+
+ // Key associated with K line and value
+ std::getline(infile, key);
+ std::replace(key.begin(), key.end(), '\r', '\n');
+ outfile << key << "\n";
+ std::getline(infile, line);
+ std::replace(line.begin(), line.end(), '\r', '\n');
+ outfile << line << "\n";
+ }
+ outfile << "PROPS-END\n";
+}
+
+
+/* Newer subversion doesn't like non-LF line endings in properties,
+ * so strip them out */
+void
+skip_node_props(std::ifstream &infile, std::vector<std::string> &node_lines)
+{
+ std::string kkey("K ");
+ std::string pend("PROPS-END");
+ std::string line;
+
+ // Go until we hit PROPS-END
+ while (std::getline(infile, line)) {
+ std::replace(line.begin(), line.end(), '\r', '\n');
+ node_lines.push_back(line);
+
+ // If we get PROPS-END, we're done
+ if (!line.compare(pend)) {
+ return;
+ }
+
+ // K <N> line is the trigger
+ std::string key = svn_str(line, kkey);
+ if (!key.length()) continue;
+
+ // Key and value line associated with K line
+ std::getline(infile, key);
+ std::replace(key.begin(), key.end(), '\r', '\n');
+ node_lines.push_back(key);
+ std::getline(infile, line);
+ std::replace(line.begin(), line.end(), '\r', '\n');
+ node_lines.push_back(line);
+ }
+}
+
+int curr_md5_line(std::string line, std::string key, std::ofstream &outfile)
+{
+ if (!sfcmp(line, key)) {
+ std::map<std::string, std::string>::iterator m_it;
+ std::string old_md5 = svn_str(line, key);
+ m_it = md5_map.find(old_md5);
+ if (m_it != md5_map.end()) {
+ outfile << key << m_it->second << "\n";
+ } else {
+ outfile << line << "\n";
+ }
+ return 1;
+ }
+ return 0;
+}
+
+
+int curr_sha1_line(std::string line, std::string key, std::ofstream &outfile)
+{
+ if (!sfcmp(line, key)) {
+ std::map<std::string, std::string>::iterator m_it;
+ std::string old_sha1 = svn_str(line, key);
+ m_it = sha1_map.find(old_sha1);
+ if (m_it != sha1_map.end()) {
+ outfile << key << m_it->second << "\n";
+ } else {
+ outfile << line << "\n";
+ }
+ return 1;
+ }
+ return 0;
+}
+
+
+
+int curr_md5_line2(std::string line, std::string key, std::string &oval,
std::vector<std::string> &node_lines)
+{
+ if (!sfcmp(line, key)) {
+ std::map<std::string, std::string>::iterator m_it;
+ std::string old_md5 = svn_str(line, key);
+ if (old_md5.length()) {
+ m_it = md5_map.find(old_md5);
+ if (m_it != md5_map.end()) {
+ std::string nline = key + m_it->second;
+ node_lines.push_back(nline);
+ oval = m_it->second;
+ } else {
+ oval = old_md5;
+ node_lines.push_back(line);
+ }
+ } else {
+ oval = old_md5;
+ node_lines.push_back(line);
+ }
+ return 1;
+ }
+ return 0;
+}
+
+
+int curr_sha1_line2(std::string line, std::string key, std::string &oval,
std::vector<std::string> &node_lines)
+{
+ if (!sfcmp(line, key)) {
+ std::map<std::string, std::string>::iterator m_it;
+ std::string old_sha1 = svn_str(line, key);
+ m_it = sha1_map.find(old_sha1);
+ if (old_sha1.length()) {
+ if (m_it != sha1_map.end()) {
+ std::string nline = key + m_it->second;
+ node_lines.push_back(nline);
+ oval = m_it->second;
+ } else {
+ oval = old_sha1;
+ node_lines.push_back(line);
+ }
+ } else {
+ oval = old_sha1;
+ node_lines.push_back(line);
+ }
+ return 1;
+ }
+ return 0;
+}
+
+
+
+
+/* Return 1 if we successfully processed a node, else 0 */
+int
+process_node(std::ifstream &infile, std::ofstream &outfile)
+{
+ std::string text_copy_source_md5;
+ std::string text_copy_source_sha1;
+ std::string text_content_md5;
+ std::string text_content_sha1;
+ long int text_content_length = 0;
+ long int prop_content_length = 0;
+ long int content_length = 0;
+ std::string npath("");
+ std::string rkey("Revision-number: ");
+ std::string npkey("Node-path: ");
+ std::string pclkey("Prop-content-length: ");
+ std::string tcsmkey("Text-copy-source-md5: ");
+ std::string tcsskey("Text-copy-source-sha1: ");
+ std::string tcmkey("Text-content-md5: ");
+ std::string tcskey("Text-content-sha1: ");
+ std::string tclkey("Text-content-length: ");
+ std::string clkey("Content-length: ");
+ std::string line;
+ std::vector<std::string> node_lines;
+ std::vector<std::string>::iterator nl_it;
+
+ // Find node path, or bail if we hit a new revision first
+ size_t line_start = infile.tellg();
+ while (!npath.length() && std::getline(infile, line)) {
+ if (!sfcmp(line, rkey)) {
+ infile.seekg(line_start);
+ return -1; // Done with revision
+ }
+ node_lines.push_back(line);
+ npath = svn_str(line, npkey);
+ }
+
+ // If no node path, no node and presumably the end of the revision
+ if (!npath.length()) return -1;
+
+
+ // Have a path, so we're in a node. Find node contents, or bail if we hit a
+ // new revision/path
+ while (std::getline(infile, line)) {
+
+ // If we hit an empty line, we're done with the node itself
+ // and its down to properties and content, if any.
+ if (!line.length()) break;
+
+ if (!sfcmp(line, rkey)) {
+ return -1; // Done with revision
+ }
+ if (!sfcmp(line, npkey)) {
+ return 1; // Done with node
+ }
+
+ // Have path, get guts.
+ if (curr_md5_line2(line, tcsmkey, text_copy_source_md5, node_lines)) {
+ continue;
+ }
+ if (curr_sha1_line2(line, tcsskey, text_copy_source_sha1, node_lines)) {
+ continue;
+ }
+ if (!sfcmp(line, tcmkey)) {
+ text_content_md5 = svn_str(line, tcmkey);
+ node_lines.push_back(line);
+ continue;
+ }
+ if (!sfcmp(line, tcskey)) {
+ text_content_sha1 = svn_str(line, tcskey);
+ node_lines.push_back(line);
+ continue;
+ }
+ if (!sfcmp(line, tclkey)) {
+ text_content_length = svn_lint(line, tclkey);
+ node_lines.push_back(line);
+ continue;
+ }
+ if (!sfcmp(line, clkey)) {
+ content_length = svn_lint(line, clkey);
+ node_lines.push_back(line);
+ node_lines.push_back(std::string(""));
+ continue;
+ }
+ if (!sfcmp(line, pclkey)) {
+ prop_content_length = svn_lint(line, pclkey);
+ node_lines.push_back(line);
+ continue;
+ }
+
+ node_lines.push_back(line);
+ }
+
+ // If we have properties, skip beyond them
+ if (prop_content_length > 0) {
+ skip_node_props(infile, node_lines);
+ }
+
+ // If we have neither properties nor content, we're done
+ if (!prop_content_length && !text_content_length) {
+ for (nl_it = node_lines.begin(); nl_it != node_lines.end(); nl_it++) {
+ outfile << *nl_it << "\n";
+ }
+ outfile << "\n";
+ return 1;
+ }
+
+ // If we have content, store the file offset, process the content
+ // for possible RCS edits, set up the new values for md5 and sha1,
+ // and jump the seek beyond the old content.
+ char *buffer = NULL;
+ std::string new_content("");
+ size_t oldpos;
+ size_t after_content;
+ if (text_content_length > 0) {
+ oldpos = infile.tellg();
+ after_content = oldpos + text_content_length + 1;
+ buffer = new char [text_content_length];
+ infile.read(buffer, text_content_length);
+ infile.seekg(after_content);
+ }
+
+ if (buffer && !skip_dercs(npath)) {
+ if (!is_binary(buffer, text_content_length, npath)) {
+ std::string calc_md5 = md5_hash_hex(buffer, text_content_length);
+ std::string calc_sha1 = sha1_hash_hex(buffer, text_content_length);
+ if (text_content_md5 != calc_md5 || text_content_sha1 != calc_sha1)
{
+ std::cout << "Stored vs. calculated mismatch: " << npath <<
"\n";
+ std::cout << "Read md5 : " << text_content_md5 << "\n";
+ std::cout << "Calculated md5 : " << calc_md5 << "\n";
+ std::cout << "Read sha1 : " << text_content_sha1 << "\n";
+ std::cout << "Calculated sha1: " << calc_sha1 << "\n";
+ /*
+ if (npath == std::string("brlcad/trunk/misc/vfont/fix.6r")) {
+ std::ofstream cfile("fix-extracted.6r", std::ios::out |
std::ios::binary);
+ cfile.write(buffer, text_content_length);
+ cfile.close();
+ }
+ */
+ }
+ new_content = de_rcs(buffer, text_content_length);
+ std::string new_md5 = md5_hash_hex(new_content.c_str(),
new_content.length());
+ std::string new_sha1 = sha1_hash_hex(new_content.c_str(),
new_content.length());
+ if (text_content_md5 != new_md5 || text_content_sha1 != new_sha1) {
+ std::cout << "Altered: " << npath << "\n";
+ std::cout << "Original md5 : " << text_content_md5 << "\n";
+ std::cout << "Calculated md5 : " << new_md5 << "\n";
+ std::cout << "Original sha1 : " << text_content_sha1 << "\n";
+ std::cout << "Calculated sha1: " << new_sha1 << "\n";
+
md5_map.insert(std::pair<std::string,std::string>(text_content_md5, new_md5));
+
sha1_map.insert(std::pair<std::string,std::string>(text_content_sha1,
new_sha1));
+ }
+ }
+ }
+
+#if 0
+ std::regex cvsignore(".*cvsignore$");
+
+ if (!std::regex_match(npath, cvsignore)) {
+#endif
+ // Write out the node lines and content.
+ std::map<std::string, std::string>::iterator m_it;
+ for (nl_it = node_lines.begin(); nl_it != node_lines.end(); nl_it++) {
+ if (skip_dercs(npath)) {
+ outfile << *nl_it << "\n";
+ continue;
+ }
+ line = *nl_it;
+ // Text-copy-source-md5
+ if (curr_md5_line(line, tcsmkey, outfile)) {
+ continue;
+ }
+ // Text-copy-source-sha1
+ if (curr_sha1_line(line, tcsskey, outfile)) {
+ continue;
+ }
+
+ // Text-content-md5
+ if (curr_md5_line(line, tcmkey, outfile)) {
+ continue;
+ }
+
+ // Text-content-sha1
+ if (curr_sha1_line(line, tcskey, outfile)) {
+ continue;
+ }
+
+ // Text-content-length
+ if (!sfcmp(line, tclkey)) {
+ if (new_content.length()) {
+ outfile << "Text-content-length: " << new_content.length()
<< "\n";
+ } else {
+ outfile << *nl_it << "\n";
+ }
+ continue;
+ }
+
+ // Content-length
+ if (!sfcmp(line, clkey)) {
+ if (new_content.length()) {
+ outfile << "Content-length: " << new_content.length() +
prop_content_length << "\n";
+ } else {
+ outfile << *nl_it << "\n";
+ }
+ continue;
+ }
+
+ outfile << *nl_it << "\n";
+ }
+ if (buffer) {
+ if (new_content.length()) {
+ outfile << new_content;
+ } else {
+ outfile.write(buffer, text_content_length);
+ }
+ outfile << "\n";
+ }
+#if 0
+ } else {
+ std::cout << "Skipping " << npath << "\n";
+ }
+#endif
+
+ if (buffer) {
+ delete buffer;
+ }
+
+ return 1;
+}
+
+/* Return 1 if we successfully processed a revision, else 0 */
+int
+process_revision(std::ifstream &infile, std::ofstream &outfile)
+{
+ std::string rkey("Revision-number: ");
+ std::string ckey("Content-length: ");
+ int node_ret = 0;
+ int success = 0;
+ std::string line;
+ long int revision_number = -1;
+
+ while (revision_number < 0) {
+ if (!std::getline(infile, line)) return success; // No rkey and no
input, no revision
+ outfile << line << "\n";
+ outfile.flush();
+ if (!sfcmp(line, rkey)) revision_number = svn_lint(line, rkey);
+ }
+ success = 1; // For the moment, finding the revision is enough to qualify
as success...
+
+ // "Usually" a revision will have properties, but they are apparently not
+ // technically required. For revision properties Content-length and
+ // Prop-content-length will always match if non-zero, and Content-length
+ // appears to be requried by the dump file spec, so just find and use
+ // Content-length
+ long int rev_prop_length = -1;
+ while (rev_prop_length < 0) {
+ if (!std::getline(infile, line)) return success; // Rev num but no
contents, no revision
+ outfile << line << "\n";
+ outfile.flush();
+ if (!sfcmp(line, ckey)) rev_prop_length = svn_lint(line, ckey);
+ }
+ if (rev_prop_length) skip_rev_props(infile, outfile);
+
+ //std::cerr << "Revision-number: " << revision_number << ", prop length "
<< rev_prop_length << std::endl;
+
+ /* Have revision number - grab nodes until we spot another one */
+ while (node_ret != -1 && infile.peek() != EOF) {
+ node_ret = process_node(infile, outfile);
+ }
+
+ outfile.flush();
+ std::cout << "Processed r" << revision_number << "\n";
+
+ return success;
+}
+
+int
+main(int argc, const char **argv)
+{
+ std::string uuid;
+ long int dump_format_version = -1;
+ std::ifstream infile(argv[1]);
+ std::ofstream outfile(argv[2], std::ios::out | std::ios::binary);
+ if (!infile.good()) return -1;
+ if (!outfile.good()) return -1;
+ std::string line;
+ std::string fmtkey("SVN-fs-dump-format-version: ");
+ // The first non-empty line has to be the format version, or we're done.
+ while (std::getline(infile, line) && !line.length()) {
+ outfile << line;
+ };
+ if (line.compare(0, fmtkey.length(), fmtkey)) {
+ return -1;
+ }
+ outfile << line << "\n";
+
+ // Grab the format number
+ dump_format_version = svn_lint(line, fmtkey);
+
+ while (!uuid.length() && std::getline(infile, line)) {
+ outfile << line << "\n";
+ uuid = svn_str(line, std::string("UUID: "));
+ }
+
+ outfile.flush();
+
+ /* As long as we're not done, read revisions */
+ while (infile.peek() != EOF) {
+ process_revision(infile, outfile);
+ }
+
+ outfile << "\n";
+ outfile << "\n";
+
+ infile.close();
+ outfile.close();
+
+ return 0;
+}
+
+
+
+// Local Variables:
+// tab-width: 8
+// mode: C++
+// c-basic-offset: 4
+// indent-tabs-mode: t
+// c-file-style: "stroustrup"
+// End:
+// ex: shiftwidth=4 tabstop=8
Property changes on: brlcad/trunk/misc/repoconv/verify/svn_de-rcs.cxx
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Added: brlcad/trunk/misc/repoconv/verify/verify.sh
===================================================================
--- brlcad/trunk/misc/repoconv/verify/verify.sh (rev 0)
+++ brlcad/trunk/misc/repoconv/verify/verify.sh 2020-07-27 14:50:08 UTC (rev
76518)
@@ -0,0 +1,10 @@
+#!/bin/bash
+
+# Do initial setup for appropriate comparison repositories
+./cvs.sh
+./svn.sh
+
+CVSDIR="$PWD/brlcad_cvs"
+SVNDIR="$PWD/repo_dercs"
+
+./verify --cvs-repo $CVSDIR --svn-repo $SVNDIR $1
Property changes on: brlcad/trunk/misc/repoconv/verify/verify.sh
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/x-sh
\ No newline at end of property
This was sent by the SourceForge.net collaborative development platform, the
world's largest Open Source development site.
_______________________________________________
BRL-CAD Source Commits mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/brlcad-commits
