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>
No significant changes in this version from the last one posted.
---
db/metadump.c | 144 ++++++++++++++++++++++++++++------------------------------
1 file changed, 70 insertions(+), 74 deletions(-)
Index: b/db/metadump.c
===================================================================
--- a/db/metadump.c
+++ b/db/metadump.c
@@ -472,87 +472,83 @@ generate_obfuscated_name(
hash = libxfs_da_hashname(name, namelen);
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 - 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 - 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 - 3] = ((newhash >> 14) & 0x7f) ^ high_bit;
+ if (is_invalid_char(newp[namelen - 3])) {
+ newp[namelen - 3] ^= 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 first byte had 0's in its upper four
- * bits (it's the result of shifting a
- * 32-bit unsigned value Right by 28 bits),
- * so we don't need to worry about it
- * becoming invalid as a result.
- */
- if (high_bit) {
- newp[namelen - 5] ^= 0x10;
- ASSERT(!is_invalid_char(newp[namelen - 5]));
- }
- break;
+ 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 first byte had 0's in its upper four bits
+ * (it's the result of shifting a 32-bit unsigned
+ * value Right by 28 bits), so we don't need to
+ * worry about it becoming invalid as a result.
+ */
+ if (high_bit) {
+ newp[namelen - 5] ^= 0x10;
+ ASSERT(!is_invalid_char(newp[namelen - 5]));
}
ASSERT(libxfs_da_hashname(newname, namelen) == hash);
_______________________________________________
xfs mailing list
xfs@xxxxxxxxxxx
http://oss.sgi.com/mailman/listinfo/xfs
