Eliminate a now pointless loop. Done as a separate patch to
make the effects of upcoming changes more clear.
Signed-off-by: Alex Elder <aelder@xxxxxxx>
---
db/metadump.c | 146 ++++++++++++++++++++++++++++------------------------------
1 file changed, 71 insertions(+), 75 deletions(-)
Index: b/db/metadump.c
===================================================================
--- a/db/metadump.c
+++ b/db/metadump.c
@@ -450,89 +450,85 @@ generate_obfuscated_name(
if (*name == '/')
name++;
do {
+ uchar_t high_bit;
+
dup = 0;
- for (;;) {
- uchar_t high_bit;
- /*
- * The beginning of the obfuscated name can
- * be pretty much anything, so fill it in
- * with random characters. Accumulate its
- * new hash value as we go.
- */
- newhash = 0;
- for (i = 0; i < namelen - 5; i++) {
- newp[i] = random_filename_char();
- newhash = newp[i] ^ rol32(newhash, 7);
- }
+ /*
+ * The beginning of the obfuscated name can be
+ * pretty much anything, so fill it in with random
+ * characters. Accumulate its new hash value as we
+ * go.
+ */
+ newhash = 0;
+ for (i = 0; i < namelen - 5; i++) {
+ newp[i] = random_filename_char();
+ newhash = newp[i] ^ rol32(newhash, 7);
+ }
- /*
- * Compute which five bytes need to be used
- * at the end of the name so the hash of the
- * obfuscated name is the same as the hash
- * of the original. If any result in an
- * invalid character, flip a bit and arrange
- * for a corresponding bit in a neighboring
- * byte to be flipped as well. For the last
- * byte, the "neighbor" to change is the
- * first byte we're computing here.
- */
- newhash = rol32(newhash, 3) ^ hash;
+ /*
+ * Compute which five bytes need to be used at the
+ * end of the name so the hash of the obfuscated
+ * name is the same as the hash of the original. If
+ * any result in an invalid character, flip a bit
+ * and arrange for a corresponding bit in a
+ * neighboring byte to be flipped as well. For the
+ * last byte, the "neighbor" to change is the first
+ * byte we're computing here.
+ */
+ newhash = rol32(newhash, 3) ^ hash;
+ high_bit = 0;
+
+ newp[namelen - 5] = ((newhash >> 28) & 0x7f) ^ high_bit;
+ if (is_invalid_char(newp[namelen - 5])) {
+ newp[namelen - 5] ^= 1;
+ high_bit = 0x80;
+ } else
high_bit = 0;
- newp[namelen - 5] = ((newhash >> 28) & 0x7f) ^ high_bit;
- if (is_invalid_char(newp[namelen - 5])) {
- newp[namelen - 5] ^= 1;
- high_bit = 0x80;
- } else
- high_bit = 0;
-
- newp[namelen - 4] = ((newhash >> 21) & 0x7f) ^ high_bit;
- if (is_invalid_char(newp[namelen - 4])) {
- newp[namelen - 4] ^= 1;
- high_bit = 0x80;
- } else
- high_bit = 0;
-
- newp[namelen - 3] = ((newhash >> 14) & 0x7f) ^ high_bit;
- if (is_invalid_char(newp[namelen - 3])) {
- newp[namelen - 3] ^= 1;
- high_bit = 0x80;
- } else
- high_bit = 0;
-
- newp[namelen - 2] = ((newhash >> 7) & 0x7f) ^ high_bit;
- if (is_invalid_char(newp[namelen - 2])) {
- newp[namelen - 2] ^= 1;
- high_bit = 0x80;
- } else
- high_bit = 0;
-
- newp[namelen - 1] = ((newhash >> 0) & 0x7f) ^ high_bit;
- if (is_invalid_char(newp[namelen - 1])) {
- newp[namelen - 1] ^= 1;
- high_bit = 0x80;
- } else
- high_bit = 0;
+ newp[namelen - 4] = ((newhash >> 21) & 0x7f) ^ high_bit;
+ if (is_invalid_char(newp[namelen - 4])) {
+ newp[namelen - 4] ^= 1;
+ high_bit = 0x80;
+ } else
+ high_bit = 0;
- /*
- * If we flipped a bit on the last byte, we
- * need to fix up the first one we computed.
- * That could make that first character
- * invalid, in which case we flip one more
- * bit in both bytes.
- */
- if (high_bit) {
- newp[namelen - 5] ^= 0x10;
- if (is_invalid_char(newp[namelen - 5])) {
- newp[namelen - 1] ^= 2;
- newp[namelen - 5] ^= 0x20;
- ASSERT(!is_invalid_char(newp[namelen - 1]));
- ASSERT(!is_invalid_char(newp[namelen - 5]));
- }
+ newp[namelen - 3] = ((newhash >> 14) & 0x7f) ^ high_bit;
+ if (is_invalid_char(newp[namelen - 3])) {
+ newp[namelen - 3] ^= 1;
+ high_bit = 0x80;
+ } else
+ high_bit = 0;
+
+ newp[namelen - 2] = ((newhash >> 7) & 0x7f) ^ high_bit;
+ if (is_invalid_char(newp[namelen - 2])) {
+ newp[namelen - 2] ^= 1;
+ high_bit = 0x80;
+ } else
+ high_bit = 0;
+
+ newp[namelen - 1] = ((newhash >> 0) & 0x7f) ^ high_bit;
+ if (is_invalid_char(newp[namelen - 1])) {
+ newp[namelen - 1] ^= 1;
+ high_bit = 0x80;
+ } else
+ high_bit = 0;
+
+ /*
+ * If we flipped a bit on the last byte, we need to
+ * fix up the first one we computed. That could
+ * make that first character invalid, in which case
+ * we flip one more bit in both bytes.
+ */
+ if (high_bit) {
+ newp[namelen - 5] ^= 0x10;
+ if (is_invalid_char(newp[namelen - 5])) {
+ newp[namelen - 1] ^= 2;
+ newp[namelen - 5] ^= 0x20;
+ ASSERT(!is_invalid_char(newp[namelen - 1]));
+ ASSERT(!is_invalid_char(newp[namelen - 5]));
}
- break;
}
ASSERT(libxfs_da_hashname((char *) newname, namelen) == hash);
_______________________________________________
xfs mailing list
xfs@xxxxxxxxxxx
http://oss.sgi.com/mailman/listinfo/xfs
