Line data    Source code

       1             : #include "burp.h"
       2             : #include "hexmap.h"
       3             : #include "protocol2/blk.h"
       4             : 
       5             : // FIX THIS: Should be set in configure somewhere.
       6             : #include <openssl/md5.h>
       7             : 
       8             : #define HEXMAP_SIZE     256
       9             : 
      10             : static uint8_t hexmap1[HEXMAP_SIZE];
      11             : static uint8_t hexmap2[HEXMAP_SIZE];
      12             : 
      13             : uint8_t md5sum_of_empty_string[MD5_DIGEST_LENGTH];
      14             : 
      15         764 : static void do_hexmap_init(uint8_t *hexmap, uint8_t shift)
      16             : {
      17             :         uint8_t i;
      18             :         uint8_t h;
      19         764 :         memset(hexmap, 0, HEXMAP_SIZE);
      20         764 :         for(i='0', h=0x00; i<='9'; i++, h++) hexmap[i]=h<<shift;
      21        4584 :         for(i='a', h=0x0A; i<='f'; i++, h++) hexmap[i]=h<<shift;
      22        4584 :         for(i='A', h=0x0A; i<='F'; i++, h++) hexmap[i]=h<<shift;
      23         764 : }
      24             : 
      25         382 : void hexmap_init(void)
      26             : {
      27         382 :         do_hexmap_init(hexmap1, 4);
      28         382 :         do_hexmap_init(hexmap2, 0);
      29         382 :         md5str_to_bytes("D41D8CD98F00B204E9800998ECF8427E",
      30             :                 md5sum_of_empty_string);
      31         382 : }
      32             : 
      33       17511 : static void str_to_bytes(const char *str, uint8_t *bytes, size_t len)
      34             : {
      35             :         static uint8_t bpos;
      36             :         static uint8_t spos;
      37             : 
      38      229763 :         for(bpos=0, spos=0; bpos<len && str[spos]; )
      39             :         {
      40      194741 :                 if(str[spos]=='/')
      41             :                 {
      42       51261 :                         spos++;
      43       51261 :                         continue;
      44             :                 }
      45             : #if BYTE_ORDER == LITTLE_ENDIAN
      46      286960 :                 bytes[bpos++] = hexmap1[(uint8_t)str[spos]]
      47      143480 :                         | hexmap2[(uint8_t)str[spos+1]];
      48             : #elif BYTE_ORDER == BIG_ENDIAN
      49             :                 bytes[bpos-bpos%4+3-bpos%4] = hexmap1[(uint8_t)str[spos]]
      50             :                         | hexmap2[(uint8_t)str[spos+1]];
      51             :                 bpos+=1;
      52             : #else
      53             :                 #error byte order not supported
      54             : #endif
      55      143480 :                 spos+=2;
      56             :         }
      57       17511 : }
      58             : 
      59          42 : void md5str_to_bytes(const char *md5str, uint8_t *bytes)
      60             : {
      61         424 :         str_to_bytes(md5str, bytes, MD5_DIGEST_LENGTH);
      62          42 : }
      63             : 
      64        7419 : char *bytes_to_md5str(uint8_t *bytes)
      65             : {
      66             :         static char str[64];
      67       22257 :         snprintf(str, sizeof(str), "%016" PRIx64 "%016" PRIx64,
      68             :                 htobe64(*(uint64_t *)bytes), htobe64(*(uint64_t *)(bytes+8)));
      69        7419 :         return str;
      70             : }
      71             : 
      72       17087 : uint64_t savepathstr_with_sig_to_uint64(const char *savepathstr)
      73             : {
      74             :         uint8_t b[sizeof(uint64_t)];
      75       17087 :         str_to_bytes(savepathstr, b, sizeof(b));
      76       34174 :         return htobe64(*(uint64_t *)&b);
      77             : }
      78             : 
      79       17657 : static char *savepathstr_make(uint64_t *be_bytes)
      80             : {
      81             :         static char str[15];
      82       17657 :         uint8_t *b=(uint8_t *)be_bytes;
      83      105942 :         snprintf(str, sizeof(str), "%02X%02X/%02X%02X/%02X%02X",
      84      105942 :                 b[0], b[1], b[2], b[3], b[4], b[5]);
      85       17657 :         return str;
      86             : }
      87             : 
      88       17336 : char *uint64_to_savepathstr(uint64_t bytes)
      89             : {
      90       17336 :         uint64_t be_bytes=htobe64(bytes);
      91       17336 :         return savepathstr_make(&be_bytes);
      92             : }
      93             : 
      94           5 : char *uint64_to_savepathstr_with_sig(uint64_t bytes)
      95             : {
      96             :         static char str[20];
      97           5 :         uint64_t be_bytes=htobe64(bytes);
      98           5 :         uint8_t *b=(uint8_t *)&be_bytes;
      99          40 :         snprintf(str, sizeof(str), "%02X%02X/%02X%02X/%02X%02X/%02X%02X",
     100          40 :                 b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]);
     101           5 :         return str;
     102             : }
     103             : 
     104         321 : char *uint64_to_savepathstr_with_sig_uint(uint64_t bytes, uint16_t *sig)
     105             : {
     106             :         char *str;
     107         321 :         uint64_t be_bytes=htobe64(bytes);
     108         321 :         uint8_t *b=(uint8_t *)&be_bytes;
     109         321 :         str=savepathstr_make(&be_bytes);
     110         321 :         *sig = b[6] << 8;
     111         321 :         *sig |= b[7];
     112         321 :         return str;
     113             : }
     114             : 
     115         321 : uint64_t uint64_to_savepath_hash_key(uint64_t bytes)
     116             : {
     117         321 :         return bytes & 0xFFFFFFFFFFFF0000;
     118             : }