00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037 #include "system.h"
00038 #include "rpmiotypes.h"
00039 #include "debug.h"
00040
00041 #if defined(_JLU3_SELFTEST)
00042 # define _JLU3_jlu32w 1
00043 # define _JLU3_jlu32l 1
00044 # define _JLU3_jlu32lpair 1
00045 # define _JLU3_jlu32b 1
00046 #endif
00047
00048
00049
00050 static const union _dbswap {
00051 const rpmuint32_t ui;
00052 const unsigned char uc[4];
00053 } endian = { .ui = 0x11223344 };
00054 # define HASH_LITTLE_ENDIAN (endian.uc[0] == (unsigned char) 0x44)
00055 # define HASH_BIG_ENDIAN (endian.uc[0] == (unsigned char) 0x11)
00056
00057
00058 #ifndef ROTL32
00059 # define ROTL32(x, s) (((x) << (s)) | ((x) >> (32 - (s))))
00060 #endif
00061
00062
00063 #define _JLU3_INIT(_h, _size) (0xdeadbeef + ((rpmuint32_t)(_size)) + (_h))
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109 #define _JLU3_MIX(a,b,c) \
00110 { \
00111 a -= c; a ^= ROTL32(c, 4); c += b; \
00112 b -= a; b ^= ROTL32(a, 6); a += c; \
00113 c -= b; c ^= ROTL32(b, 8); b += a; \
00114 a -= c; a ^= ROTL32(c,16); c += b; \
00115 b -= a; b ^= ROTL32(a,19); a += c; \
00116 c -= b; c ^= ROTL32(b, 4); b += a; \
00117 }
00118
00119
00143
00144 #define _JLU3_FINAL(a,b,c) \
00145 { \
00146 c ^= b; c -= ROTL32(b,14); \
00147 a ^= c; a -= ROTL32(c,11); \
00148 b ^= a; b -= ROTL32(a,25); \
00149 c ^= b; c -= ROTL32(b,16); \
00150 a ^= c; a -= ROTL32(c,4); \
00151 b ^= a; b -= ROTL32(a,14); \
00152 c ^= b; c -= ROTL32(b,24); \
00153 }
00154
00155 #if defined(_JLU3_jlu32w)
00156 rpmuint32_t jlu32w(rpmuint32_t h, const rpmuint32_t *k, size_t size)
00157 ;
00158
00175
00176 rpmuint32_t jlu32w(rpmuint32_t h, const rpmuint32_t *k, size_t size)
00177 {
00178 rpmuint32_t a = _JLU3_INIT(h, (size * sizeof(*k)));
00179 rpmuint32_t b = a;
00180 rpmuint32_t c = a;
00181
00182 if (k == NULL)
00183 goto exit;
00184
00185
00186 while (size > 3) {
00187 a += k[0];
00188 b += k[1];
00189 c += k[2];
00190 _JLU3_MIX(a,b,c);
00191 size -= 3;
00192 k += 3;
00193 }
00194
00195
00196 switch (size) {
00197 case 3 : c+=k[2];
00198 case 2 : b+=k[1];
00199 case 1 : a+=k[0];
00200 _JLU3_FINAL(a,b,c);
00201
00202 case 0:
00203 break;
00204 }
00205
00206 exit:
00207 return c;
00208 }
00209 #endif
00210
00211 #if defined(_JLU3_jlu32l)
00212 rpmuint32_t jlu32l(rpmuint32_t h, const void *key, size_t size)
00213 ;
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245 rpmuint32_t jlu32l(rpmuint32_t h, const void *key, size_t size)
00246 {
00247 union { const void *ptr; size_t i; } u;
00248 rpmuint32_t a = _JLU3_INIT(h, size);
00249 rpmuint32_t b = a;
00250 rpmuint32_t c = a;
00251
00252 if (key == NULL)
00253 goto exit;
00254
00255 u.ptr = key;
00256 if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
00257 const rpmuint32_t *k = (const rpmuint32_t *)key;
00258 #ifdef VALGRIND
00259 const rpmuint8_t *k8;
00260 #endif
00261
00262
00263 while (size > 12) {
00264 a += k[0];
00265 b += k[1];
00266 c += k[2];
00267 _JLU3_MIX(a,b,c);
00268 size -= 12;
00269 k += 3;
00270 }
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282 #ifndef VALGRIND
00283
00284 switch (size) {
00285 case 12: c += k[2]; b+=k[1]; a+=k[0]; break;
00286 case 11: c += k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
00287 case 10: c += k[2]&0xffff; b+=k[1]; a+=k[0]; break;
00288 case 9: c += k[2]&0xff; b+=k[1]; a+=k[0]; break;
00289 case 8: b += k[1]; a+=k[0]; break;
00290 case 7: b += k[1]&0xffffff; a+=k[0]; break;
00291 case 6: b += k[1]&0xffff; a+=k[0]; break;
00292 case 5: b += k[1]&0xff; a+=k[0]; break;
00293 case 4: a += k[0]; break;
00294 case 3: a += k[0]&0xffffff; break;
00295 case 2: a += k[0]&0xffff; break;
00296 case 1: a += k[0]&0xff; break;
00297 case 0: goto exit;
00298 }
00299
00300 #else
00301
00302 k8 = (const rpmuint8_t *)k;
00303 switch (size) {
00304 case 12: c += k[2]; b+=k[1]; a+=k[0] break;
00305 case 11: c += ((rpmuint32_t)k8[10])<<16;
00306 case 10: c += ((rpmuint32_t)k8[9])<<8;
00307 case 9: c += k8[8];
00308 case 8: b += k[1]; a+=k[0]; break;
00309 case 7: b += ((rpmuint32_t)k8[6])<<16;
00310 case 6: b += ((rpmuint32_t)k8[5])<<8;
00311 case 5: b += k8[4];
00312 case 4: a += k[0]; break;
00313 case 3: a += ((rpmuint32_t)k8[2])<<16;
00314 case 2: a += ((rpmuint32_t)k8[1])<<8;
00315 case 1: a += k8[0]; break;
00316 case 0: goto exit;
00317 }
00318
00319 #endif
00320
00321 } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
00322 const rpmuint16_t *k = (const rpmuint16_t *)key;
00323 const rpmuint8_t *k8;
00324
00325
00326 while (size > 12) {
00327 a += k[0] + (((rpmuint32_t)k[1])<<16);
00328 b += k[2] + (((rpmuint32_t)k[3])<<16);
00329 c += k[4] + (((rpmuint32_t)k[5])<<16);
00330 _JLU3_MIX(a,b,c);
00331 size -= 12;
00332 k += 6;
00333 }
00334
00335
00336 k8 = (const rpmuint8_t *)k;
00337 switch (size) {
00338 case 12:
00339 c += k[4]+(((rpmuint32_t)k[5])<<16);
00340 b += k[2]+(((rpmuint32_t)k[3])<<16);
00341 a += k[0]+(((rpmuint32_t)k[1])<<16);
00342 break;
00343 case 11:
00344 c += ((rpmuint32_t)k8[10])<<16;
00345
00346 case 10:
00347 c += (rpmuint32_t)k[4];
00348 b += k[2]+(((rpmuint32_t)k[3])<<16);
00349 a += k[0]+(((rpmuint32_t)k[1])<<16);
00350 break;
00351 case 9:
00352 c += (rpmuint32_t)k8[8];
00353
00354 case 8:
00355 b += k[2]+(((rpmuint32_t)k[3])<<16);
00356 a += k[0]+(((rpmuint32_t)k[1])<<16);
00357 break;
00358 case 7:
00359 b += ((rpmuint32_t)k8[6])<<16;
00360
00361 case 6:
00362 b += (rpmuint32_t)k[2];
00363 a += k[0]+(((rpmuint32_t)k[1])<<16);
00364 break;
00365 case 5:
00366 b += (rpmuint32_t)k8[4];
00367
00368 case 4:
00369 a += k[0]+(((rpmuint32_t)k[1])<<16);
00370 break;
00371 case 3:
00372 a += ((rpmuint32_t)k8[2])<<16;
00373
00374 case 2:
00375 a += (rpmuint32_t)k[0];
00376 break;
00377 case 1:
00378 a += (rpmuint32_t)k8[0];
00379 break;
00380 case 0:
00381 goto exit;
00382 }
00383
00384 } else {
00385 const rpmuint8_t *k = (const rpmuint8_t *)key;
00386
00387
00388 while (size > 12) {
00389 a += (rpmuint32_t)k[0];
00390 a += ((rpmuint32_t)k[1])<<8;
00391 a += ((rpmuint32_t)k[2])<<16;
00392 a += ((rpmuint32_t)k[3])<<24;
00393 b += (rpmuint32_t)k[4];
00394 b += ((rpmuint32_t)k[5])<<8;
00395 b += ((rpmuint32_t)k[6])<<16;
00396 b += ((rpmuint32_t)k[7])<<24;
00397 c += (rpmuint32_t)k[8];
00398 c += ((rpmuint32_t)k[9])<<8;
00399 c += ((rpmuint32_t)k[10])<<16;
00400 c += ((rpmuint32_t)k[11])<<24;
00401 _JLU3_MIX(a,b,c);
00402 size -= 12;
00403 k += 12;
00404 }
00405
00406
00407 switch (size) {
00408 case 12: c += ((rpmuint32_t)k[11])<<24;
00409 case 11: c += ((rpmuint32_t)k[10])<<16;
00410 case 10: c += ((rpmuint32_t)k[9])<<8;
00411 case 9: c += (rpmuint32_t)k[8];
00412 case 8: b += ((rpmuint32_t)k[7])<<24;
00413 case 7: b += ((rpmuint32_t)k[6])<<16;
00414 case 6: b += ((rpmuint32_t)k[5])<<8;
00415 case 5: b += (rpmuint32_t)k[4];
00416 case 4: a += ((rpmuint32_t)k[3])<<24;
00417 case 3: a += ((rpmuint32_t)k[2])<<16;
00418 case 2: a += ((rpmuint32_t)k[1])<<8;
00419 case 1: a += (rpmuint32_t)k[0];
00420 break;
00421 case 0:
00422 goto exit;
00423 }
00424 }
00425
00426 _JLU3_FINAL(a,b,c);
00427
00428 exit:
00429 return c;
00430 }
00431 #endif
00432
00433 #if defined(_JLU3_jlu32lpair)
00434 void jlu32lpair( const void *key, size_t size,
00435 rpmuint32_t *pc, rpmuint32_t *pb)
00436 ;
00453 void jlu32lpair(const void *key, size_t size, rpmuint32_t *pc, rpmuint32_t *pb)
00454 {
00455 union { const void *ptr; size_t i; } u;
00456 rpmuint32_t a = _JLU3_INIT(*pc, size);
00457 rpmuint32_t b = a;
00458 rpmuint32_t c = a;
00459
00460 if (key == NULL)
00461 goto exit;
00462
00463 c += *pb;
00464
00465 u.ptr = key;
00466 if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
00467 const rpmuint32_t *k = (const rpmuint32_t *)key;
00468 #ifdef VALGRIND
00469 const rpmuint8_t *k8;
00470 #endif
00471
00472
00473 while (size > 12) {
00474 a += k[0];
00475 b += k[1];
00476 c += k[2];
00477 _JLU3_MIX(a,b,c);
00478 size -= 12;
00479 k += 3;
00480 }
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491 #ifndef VALGRIND
00492
00493 switch (size) {
00494 case 12: c += k[2]; b+=k[1]; a+=k[0]; break;
00495 case 11: c += k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
00496 case 10: c += k[2]&0xffff; b+=k[1]; a+=k[0]; break;
00497 case 9: c += k[2]&0xff; b+=k[1]; a+=k[0]; break;
00498 case 8: b += k[1]; a+=k[0]; break;
00499 case 7: b += k[1]&0xffffff; a+=k[0]; break;
00500 case 6: b += k[1]&0xffff; a+=k[0]; break;
00501 case 5: b += k[1]&0xff; a+=k[0]; break;
00502 case 4: a += k[0]; break;
00503 case 3: a += k[0]&0xffffff; break;
00504 case 2: a += k[0]&0xffff; break;
00505 case 1: a += k[0]&0xff; break;
00506 case 0: goto exit;
00507 }
00508
00509 #else
00510
00511 k8 = (const rpmuint8_t *)k;
00512 switch (size) {
00513 case 12: c += k[2]; b+=k[1]; a+=k[0]; break;
00514 case 11: c += ((rpmuint32_t)k8[10])<<16;
00515 case 10: c += ((rpmuint32_t)k8[9])<<8;
00516 case 9: c += k8[8];
00517 case 8: b += k[1]; a+=k[0]; break;
00518 case 7: b += ((rpmuint32_t)k8[6])<<16;
00519 case 6: b += ((rpmuint32_t)k8[5])<<8;
00520 case 5: b += k8[4];
00521 case 4: a += k[0]; break;
00522 case 3: a += ((rpmuint32_t)k8[2])<<16;
00523 case 2: a += ((rpmuint32_t)k8[1])<<8;
00524 case 1: a += k8[0]; break;
00525 case 0: goto exit;
00526 }
00527
00528 #endif
00529
00530 } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
00531 const rpmuint16_t *k = (const rpmuint16_t *)key;
00532 const rpmuint8_t *k8;
00533
00534
00535 while (size > 12) {
00536 a += k[0] + (((rpmuint32_t)k[1])<<16);
00537 b += k[2] + (((rpmuint32_t)k[3])<<16);
00538 c += k[4] + (((rpmuint32_t)k[5])<<16);
00539 _JLU3_MIX(a,b,c);
00540 size -= 12;
00541 k += 6;
00542 }
00543
00544
00545 k8 = (const rpmuint8_t *)k;
00546 switch (size) {
00547 case 12:
00548 c += k[4]+(((rpmuint32_t)k[5])<<16);
00549 b += k[2]+(((rpmuint32_t)k[3])<<16);
00550 a += k[0]+(((rpmuint32_t)k[1])<<16);
00551 break;
00552 case 11:
00553 c += ((rpmuint32_t)k8[10])<<16;
00554
00555 case 10:
00556 c += k[4];
00557 b += k[2]+(((rpmuint32_t)k[3])<<16);
00558 a += k[0]+(((rpmuint32_t)k[1])<<16);
00559 break;
00560 case 9:
00561 c += k8[8];
00562
00563 case 8:
00564 b += k[2]+(((rpmuint32_t)k[3])<<16);
00565 a += k[0]+(((rpmuint32_t)k[1])<<16);
00566 break;
00567 case 7:
00568 b += ((rpmuint32_t)k8[6])<<16;
00569
00570 case 6:
00571 b += k[2];
00572 a += k[0]+(((rpmuint32_t)k[1])<<16);
00573 break;
00574 case 5:
00575 b += k8[4];
00576
00577 case 4:
00578 a += k[0]+(((rpmuint32_t)k[1])<<16);
00579 break;
00580 case 3:
00581 a += ((rpmuint32_t)k8[2])<<16;
00582
00583 case 2:
00584 a += k[0];
00585 break;
00586 case 1:
00587 a += k8[0];
00588 break;
00589 case 0:
00590 goto exit;
00591 }
00592
00593 } else {
00594 const rpmuint8_t *k = (const rpmuint8_t *)key;
00595
00596
00597 while (size > 12) {
00598 a += k[0];
00599 a += ((rpmuint32_t)k[1])<<8;
00600 a += ((rpmuint32_t)k[2])<<16;
00601 a += ((rpmuint32_t)k[3])<<24;
00602 b += k[4];
00603 b += ((rpmuint32_t)k[5])<<8;
00604 b += ((rpmuint32_t)k[6])<<16;
00605 b += ((rpmuint32_t)k[7])<<24;
00606 c += k[8];
00607 c += ((rpmuint32_t)k[9])<<8;
00608 c += ((rpmuint32_t)k[10])<<16;
00609 c += ((rpmuint32_t)k[11])<<24;
00610 _JLU3_MIX(a,b,c);
00611 size -= 12;
00612 k += 12;
00613 }
00614
00615
00616 switch (size) {
00617 case 12: c += ((rpmuint32_t)k[11])<<24;
00618 case 11: c += ((rpmuint32_t)k[10])<<16;
00619 case 10: c += ((rpmuint32_t)k[9])<<8;
00620 case 9: c += k[8];
00621 case 8: b += ((rpmuint32_t)k[7])<<24;
00622 case 7: b += ((rpmuint32_t)k[6])<<16;
00623 case 6: b += ((rpmuint32_t)k[5])<<8;
00624 case 5: b += k[4];
00625 case 4: a += ((rpmuint32_t)k[3])<<24;
00626 case 3: a += ((rpmuint32_t)k[2])<<16;
00627 case 2: a += ((rpmuint32_t)k[1])<<8;
00628 case 1: a += k[0];
00629 break;
00630 case 0:
00631 goto exit;
00632 }
00633 }
00634
00635 _JLU3_FINAL(a,b,c);
00636
00637 exit:
00638 *pc = c;
00639 *pb = b;
00640 return;
00641 }
00642 #endif
00643
00644 #if defined(_JLU3_jlu32b)
00645 rpmuint32_t jlu32b(rpmuint32_t h, const void *key, size_t size)
00646 ;
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658 rpmuint32_t jlu32b(rpmuint32_t h, const void *key, size_t size)
00659 {
00660 union { const void *ptr; size_t i; } u;
00661 rpmuint32_t a = _JLU3_INIT(h, size);
00662 rpmuint32_t b = a;
00663 rpmuint32_t c = a;
00664
00665 if (key == NULL)
00666 return h;
00667
00668 u.ptr = key;
00669 if (HASH_BIG_ENDIAN && ((u.i & 0x3) == 0)) {
00670 const rpmuint32_t *k = (const rpmuint32_t *)key;
00671 #ifdef VALGRIND
00672 const rpmuint8_t *k8;
00673 #endif
00674
00675
00676 while (size > 12) {
00677 a += k[0];
00678 b += k[1];
00679 c += k[2];
00680 _JLU3_MIX(a,b,c);
00681 size -= 12;
00682 k += 3;
00683 }
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695 #ifndef VALGRIND
00696
00697 switch (size) {
00698 case 12: c += k[2]; b+=k[1]; a+=k[0]; break;
00699 case 11: c += k[2]&0xffffff00; b+=k[1]; a+=k[0]; break;
00700 case 10: c += k[2]&0xffff0000; b+=k[1]; a+=k[0]; break;
00701 case 9: c += k[2]&0xff000000; b+=k[1]; a+=k[0]; break;
00702 case 8: b += k[1]; a+=k[0]; break;
00703 case 7: b += k[1]&0xffffff00; a+=k[0]; break;
00704 case 6: b += k[1]&0xffff0000; a+=k[0]; break;
00705 case 5: b += k[1]&0xff000000; a+=k[0]; break;
00706 case 4: a += k[0]; break;
00707 case 3: a += k[0]&0xffffff00; break;
00708 case 2: a += k[0]&0xffff0000; break;
00709 case 1: a += k[0]&0xff000000; break;
00710 case 0: goto exit;
00711 }
00712
00713 #else
00714
00715 k8 = (const rpmuint8_t *)k;
00716 switch (size) {
00717 case 12: c += k[2]; b+=k[1]; a+=k[0]; break;
00718 case 11: c += ((rpmuint32_t)k8[10])<<8;
00719 case 10: c += ((rpmuint32_t)k8[9])<<16;
00720 case 9: c += ((rpmuint32_t)k8[8])<<24;
00721 case 8: b += k[1]; a+=k[0]; break;
00722 case 7: b += ((rpmuint32_t)k8[6])<<8;
00723 case 6: b += ((rpmuint32_t)k8[5])<<16;
00724 case 5: b += ((rpmuint32_t)k8[4])<<24;
00725 case 4: a += k[0]; break;
00726 case 3: a += ((rpmuint32_t)k8[2])<<8;
00727 case 2: a += ((rpmuint32_t)k8[1])<<16;
00728 case 1: a += ((rpmuint32_t)k8[0])<<24; break;
00729 case 0: goto exit;
00730 }
00731
00732 #endif
00733
00734 } else {
00735 const rpmuint8_t *k = (const rpmuint8_t *)key;
00736
00737
00738 while (size > 12) {
00739 a += ((rpmuint32_t)k[0])<<24;
00740 a += ((rpmuint32_t)k[1])<<16;
00741 a += ((rpmuint32_t)k[2])<<8;
00742 a += ((rpmuint32_t)k[3]);
00743 b += ((rpmuint32_t)k[4])<<24;
00744 b += ((rpmuint32_t)k[5])<<16;
00745 b += ((rpmuint32_t)k[6])<<8;
00746 b += ((rpmuint32_t)k[7]);
00747 c += ((rpmuint32_t)k[8])<<24;
00748 c += ((rpmuint32_t)k[9])<<16;
00749 c += ((rpmuint32_t)k[10])<<8;
00750 c += ((rpmuint32_t)k[11]);
00751 _JLU3_MIX(a,b,c);
00752 size -= 12;
00753 k += 12;
00754 }
00755
00756
00757 switch (size) {
00758 case 12: c += k[11];
00759 case 11: c += ((rpmuint32_t)k[10])<<8;
00760 case 10: c += ((rpmuint32_t)k[9])<<16;
00761 case 9: c += ((rpmuint32_t)k[8])<<24;
00762 case 8: b += k[7];
00763 case 7: b += ((rpmuint32_t)k[6])<<8;
00764 case 6: b += ((rpmuint32_t)k[5])<<16;
00765 case 5: b += ((rpmuint32_t)k[4])<<24;
00766 case 4: a += k[3];
00767 case 3: a += ((rpmuint32_t)k[2])<<8;
00768 case 2: a += ((rpmuint32_t)k[1])<<16;
00769 case 1: a += ((rpmuint32_t)k[0])<<24;
00770 break;
00771 case 0:
00772 goto exit;
00773 }
00774 }
00775
00776 _JLU3_FINAL(a,b,c);
00777
00778 exit:
00779 return c;
00780 }
00781 #endif
00782
00783 #if defined(_JLU3_SELFTEST)
00784
00785
00786 static void driver1(void)
00787
00788 {
00789 rpmuint8_t buf[256];
00790 rpmuint32_t i;
00791 rpmuint32_t h=0;
00792 time_t a,z;
00793
00794 time(&a);
00795 for (i=0; i<256; ++i) buf[i] = 'x';
00796 for (i=0; i<1; ++i) {
00797 h = jlu32l(h, &buf[0], sizeof(buf[0]));
00798 }
00799 time(&z);
00800 if (z-a > 0) printf("time %d %.8x\n", (int)(z-a), h);
00801 }
00802
00803
00804 #define HASHSTATE 1
00805 #define HASHLEN 1
00806 #define MAXPAIR 60
00807 #define MAXLEN 70
00808 static void driver2(void)
00809
00810 {
00811 rpmuint8_t qa[MAXLEN+1], qb[MAXLEN+2], *a = &qa[0], *b = &qb[1];
00812 rpmuint32_t c[HASHSTATE], d[HASHSTATE], i=0, j=0, k, l, m=0, z;
00813 rpmuint32_t e[HASHSTATE],f[HASHSTATE],g[HASHSTATE],h[HASHSTATE];
00814 rpmuint32_t x[HASHSTATE],y[HASHSTATE];
00815 rpmuint32_t hlen;
00816
00817 printf("No more than %d trials should ever be needed \n",MAXPAIR/2);
00818 for (hlen=0; hlen < MAXLEN; ++hlen) {
00819 z=0;
00820 for (i=0; i<hlen; ++i) {
00821 for (j=0; j<8; ++j) {
00822 for (m=1; m<8; ++m) {
00823 for (l=0; l<HASHSTATE; ++l)
00824 e[l]=f[l]=g[l]=h[l]=x[l]=y[l]=~((rpmuint32_t)0);
00825
00826
00827 for (k=0; k<MAXPAIR; k+=2) {
00828 rpmuint32_t finished=1;
00829
00830 for (l=0; l<hlen+1; ++l) {a[l] = b[l] = (rpmuint8_t)0;}
00831
00832 a[i] ^= (k<<j);
00833 a[i] ^= (k>>(8-j));
00834 c[0] = jlu32l(m, a, hlen);
00835 b[i] ^= ((k+1)<<j);
00836 b[i] ^= ((k+1)>>(8-j));
00837 d[0] = jlu32l(m, b, hlen);
00838
00839 for (l=0; l<HASHSTATE; ++l) {
00840 e[l] &= (c[l]^d[l]);
00841 f[l] &= ~(c[l]^d[l]);
00842 g[l] &= c[l];
00843 h[l] &= ~c[l];
00844 x[l] &= d[l];
00845 y[l] &= ~d[l];
00846 if (e[l]|f[l]|g[l]|h[l]|x[l]|y[l]) finished=0;
00847 }
00848 if (finished) break;
00849 }
00850 if (k>z) z=k;
00851 if (k == MAXPAIR) {
00852 printf("Some bit didn't change: ");
00853 printf("%.8x %.8x %.8x %.8x %.8x %.8x ",
00854 e[0],f[0],g[0],h[0],x[0],y[0]);
00855 printf("i %d j %d m %d len %d\n", i, j, m, hlen);
00856 }
00857 if (z == MAXPAIR) goto done;
00858 }
00859 }
00860 }
00861 done:
00862 if (z < MAXPAIR) {
00863 printf("Mix success %2d bytes %2d initvals ",i,m);
00864 printf("required %d trials\n", z/2);
00865 }
00866 }
00867 printf("\n");
00868 }
00869
00870
00871 static void driver3(void)
00872
00873 {
00874 rpmuint8_t buf[MAXLEN+20], *b;
00875 rpmuint32_t len;
00876 rpmuint8_t q[] = "This is the time for all good men to come to the aid of their country...";
00877 rpmuint32_t h;
00878 rpmuint8_t qq[] = "xThis is the time for all good men to come to the aid of their country...";
00879 rpmuint32_t i;
00880 rpmuint8_t qqq[] = "xxThis is the time for all good men to come to the aid of their country...";
00881 rpmuint32_t j;
00882 rpmuint8_t qqqq[] = "xxxThis is the time for all good men to come to the aid of their country...";
00883 rpmuint32_t ref,x,y;
00884 rpmuint8_t *p;
00885 rpmuint32_t m = 13;
00886
00887 printf("Endianness. These lines should all be the same (for values filled in):\n");
00888 printf("%.8x %.8x %.8x\n",
00889 jlu32w(m, (const rpmuint32_t *)q, (sizeof(q)-1)/4),
00890 jlu32w(m, (const rpmuint32_t *)q, (sizeof(q)-5)/4),
00891 jlu32w(m, (const rpmuint32_t *)q, (sizeof(q)-9)/4));
00892 p = q;
00893 printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
00894 jlu32l(m, p, sizeof(q)-1), jlu32l(m, p, sizeof(q)-2),
00895 jlu32l(m, p, sizeof(q)-3), jlu32l(m, p, sizeof(q)-4),
00896 jlu32l(m, p, sizeof(q)-5), jlu32l(m, p, sizeof(q)-6),
00897 jlu32l(m, p, sizeof(q)-7), jlu32l(m, p, sizeof(q)-8),
00898 jlu32l(m, p, sizeof(q)-9), jlu32l(m, p, sizeof(q)-10),
00899 jlu32l(m, p, sizeof(q)-11), jlu32l(m, p, sizeof(q)-12));
00900 p = &qq[1];
00901 printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
00902 jlu32l(m, p, sizeof(q)-1), jlu32l(m, p, sizeof(q)-2),
00903 jlu32l(m, p, sizeof(q)-3), jlu32l(m, p, sizeof(q)-4),
00904 jlu32l(m, p, sizeof(q)-5), jlu32l(m, p, sizeof(q)-6),
00905 jlu32l(m, p, sizeof(q)-7), jlu32l(m, p, sizeof(q)-8),
00906 jlu32l(m, p, sizeof(q)-9), jlu32l(m, p, sizeof(q)-10),
00907 jlu32l(m, p, sizeof(q)-11), jlu32l(m, p, sizeof(q)-12));
00908 p = &qqq[2];
00909 printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
00910 jlu32l(m, p, sizeof(q)-1), jlu32l(m, p, sizeof(q)-2),
00911 jlu32l(m, p, sizeof(q)-3), jlu32l(m, p, sizeof(q)-4),
00912 jlu32l(m, p, sizeof(q)-5), jlu32l(m, p, sizeof(q)-6),
00913 jlu32l(m, p, sizeof(q)-7), jlu32l(m, p, sizeof(q)-8),
00914 jlu32l(m, p, sizeof(q)-9), jlu32l(m, p, sizeof(q)-10),
00915 jlu32l(m, p, sizeof(q)-11), jlu32l(m, p, sizeof(q)-12));
00916 p = &qqqq[3];
00917 printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
00918 jlu32l(m, p, sizeof(q)-1), jlu32l(m, p, sizeof(q)-2),
00919 jlu32l(m, p, sizeof(q)-3), jlu32l(m, p, sizeof(q)-4),
00920 jlu32l(m, p, sizeof(q)-5), jlu32l(m, p, sizeof(q)-6),
00921 jlu32l(m, p, sizeof(q)-7), jlu32l(m, p, sizeof(q)-8),
00922 jlu32l(m, p, sizeof(q)-9), jlu32l(m, p, sizeof(q)-10),
00923 jlu32l(m, p, sizeof(q)-11), jlu32l(m, p, sizeof(q)-12));
00924 printf("\n");
00925 for (h=0, b=buf+1; h<8; ++h, ++b) {
00926 for (i=0; i<MAXLEN; ++i) {
00927 len = i;
00928 for (j=0; j<i; ++j)
00929 *(b+j)=0;
00930
00931
00932 m = 1;
00933 ref = jlu32l(m, b, len);
00934 *(b+i)=(rpmuint8_t)~0;
00935 *(b-1)=(rpmuint8_t)~0;
00936 x = jlu32l(m, b, len);
00937 y = jlu32l(m, b, len);
00938 if ((ref != x) || (ref != y))
00939 printf("alignment error: %.8x %.8x %.8x %d %d\n",ref,x,y, h, i);
00940 }
00941 }
00942 }
00943
00944
00945 static void driver4(void)
00946
00947 {
00948 rpmuint8_t buf[1];
00949 rpmuint32_t h;
00950 rpmuint32_t i;
00951 rpmuint32_t state[HASHSTATE];
00952
00953 buf[0] = ~0;
00954 for (i=0; i<HASHSTATE; ++i)
00955 state[i] = 1;
00956 printf("These should all be different\n");
00957 h = 0;
00958 for (i=0; i<8; ++i) {
00959 h = jlu32l(h, buf, 0);
00960 printf("%2ld 0-byte strings, hash is %.8x\n", (long)i, h);
00961 }
00962 }
00963
00964
00965 int main(int argc, char ** argv)
00966 {
00967 driver1();
00968 driver2();
00969 driver3();
00970 driver4();
00971 return 1;
00972 }
00973
00974 #endif