Changeset 0d8322da in mainline


Ignore:
Timestamp:
2012-09-23T08:03:08Z (12 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
c99d470
Parents:
8595b954
Message:

Remove GPL licensed code from libext4.

Location:
uspace/lib/ext4
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/ext4/libext4_crc.c

    r8595b954 r0d8322da  
    3333/**
    3434 * @file  libext4_crc.c
    35  * @brief CRC checksumming implementation from Linux.
    3635 */
    3736
    38 #include <byteorder.h>
    3937#include "libext4.h"
    4038
    41 /** CRC table for the CRC-16.
    42  *
    43  * The poly is 0x8005 (x^16 + x^15 + x^2 + 1).
    44  *
    45  */
    46 uint16_t const crc16_table[256] = {
    47         0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
    48         0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
    49         0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
    50         0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
    51         0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
    52         0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
    53         0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
    54         0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
    55         0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
    56         0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
    57         0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
    58         0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
    59         0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
    60         0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
    61         0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
    62         0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
    63         0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
    64         0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
    65         0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
    66         0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
    67         0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
    68         0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
    69         0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
    70         0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
    71         0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
    72         0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
    73         0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
    74         0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
    75         0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
    76         0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
    77         0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
    78         0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
    79 };
    80 
    81 /** Modify CRC value.
    82  *
    83  * @param crc   Current CRC value
    84  * @param data  New byte of data to be "added" to CRC
    85  *
    86  * @return Updated CRC value
    87  *
    88  */
    89 static inline uint16_t crc16_byte(uint16_t crc, const uint8_t data)
    90 {
    91         return (crc >> 8) ^ crc16_table[(crc ^ data) & 0xff];
    92 }
    93 
    94 /** Compute the CRC-16 for the data buffer.
    95  *
    96  * @param crc    Previous CRC value
    97  * @param buffer Data pointer
    98  * @param len    Number of bytes in the buffer
    99  *
    100  * @return Updated CRC value
    101  *
    102  */
    10339uint16_t crc16(uint16_t crc, const uint8_t *buffer, size_t len)
    10440{
    105         while (len--)
    106                 crc = crc16_byte(crc, *buffer++);
    107        
    108         return crc;
     41        // TODO
     42        return 0;
    10943}
    11044

  • uspace/lib/ext4/libext4_filesystem.c

    r8595b954 r0d8322da  
    471471
    472472/** Compute checksum of block group descriptor.
    473  *
    474  * It uses crc functions from Linux kernel implementation.
    475473 *
    476474 * @param sb   Superblock

  • uspace/lib/ext4/libext4_hash.c

    r8595b954 r0d8322da  
    3535 */
    3636
     37#include "libext4.h"
    3738#include <errno.h>
    38 #include <mem.h>
    39 #include "libext4.h"
    4039
    41 #define TEA_DELTA  0x9E3779B9
    42 
    43 /* F, G and H are basic MD4 functions: selection, majority, parity */
    44 #define F(x, y, z)  ((z) ^ ((x) & ((y) ^ (z))))
    45 #define G(x, y, z)  (((x) & (y)) + (((x) ^ (y)) & (z)))
    46 #define H(x, y, z)  ((x) ^ (y) ^ (z))
    47 
    48 /*
    49  * The generic round function.  The application is so specific that
    50  * we don't bother protecting all the arguments with parens, as is generally
    51  * good macro practice, in favor of extra legibility.
    52  * Rotation is separate from addition to prevent recomputation
    53  */
    54 #define ROUND(f, a, b, c, d, x, s) \
    55         (a += f(b, c, d) + x, a = (a << s) | (a >> (32 - s)))
    56 
    57 #define K1  0
    58 #define K2  013240474631UL
    59 #define K3  015666365641UL
    60 
    61 static void tea_transform(uint32_t buf[4], uint32_t const in[])
    62 {
    63         uint32_t sum = 0;
    64         uint32_t b0 = buf[0];
    65         uint32_t b1 = buf[1];
    66         uint32_t a = in[0];
    67         uint32_t b = in[1];
    68         uint32_t c = in[2];
    69         uint32_t d = in[3];
    70        
    71         int n = 16;
    72        
    73         do {
    74                 sum += TEA_DELTA;
    75                 b0 += ((b1 << 4) + a) ^ (b1 + sum) ^ ((b1 >> 5) + b);
    76                 b1 += ((b0 << 4) + c) ^ (b0 + sum) ^ ((b0 >> 5) + d);
    77         } while (--n);
    78        
    79         buf[0] += b0;
    80         buf[1] += b1;
    81 }
    82 
    83 
    84 static void half_md4_transform(uint32_t buf[4], const uint32_t in[8])
    85 {
    86         uint32_t a = buf[0], b = buf[1], c = buf[2], d = buf[3];
    87        
    88         /* Round 1 */
    89         ROUND(F, a, b, c, d, in[0] + K1,  3);
    90         ROUND(F, d, a, b, c, in[1] + K1,  7);
    91         ROUND(F, c, d, a, b, in[2] + K1, 11);
    92         ROUND(F, b, c, d, a, in[3] + K1, 19);
    93         ROUND(F, a, b, c, d, in[4] + K1,  3);
    94         ROUND(F, d, a, b, c, in[5] + K1,  7);
    95         ROUND(F, c, d, a, b, in[6] + K1, 11);
    96         ROUND(F, b, c, d, a, in[7] + K1, 19);
    97        
    98         /* Round 2 */
    99         ROUND(G, a, b, c, d, in[1] + K2,  3);
    100         ROUND(G, d, a, b, c, in[3] + K2,  5);
    101         ROUND(G, c, d, a, b, in[5] + K2,  9);
    102         ROUND(G, b, c, d, a, in[7] + K2, 13);
    103         ROUND(G, a, b, c, d, in[0] + K2,  3);
    104         ROUND(G, d, a, b, c, in[2] + K2,  5);
    105         ROUND(G, c, d, a, b, in[4] + K2,  9);
    106         ROUND(G, b, c, d, a, in[6] + K2, 13);
    107        
    108         /* Round 3 */
    109         ROUND(H, a, b, c, d, in[3] + K3,  3);
    110         ROUND(H, d, a, b, c, in[7] + K3,  9);
    111         ROUND(H, c, d, a, b, in[2] + K3, 11);
    112         ROUND(H, b, c, d, a, in[6] + K3, 15);
    113         ROUND(H, a, b, c, d, in[1] + K3,  3);
    114         ROUND(H, d, a, b, c, in[5] + K3,  9);
    115         ROUND(H, c, d, a, b, in[0] + K3, 11);
    116         ROUND(H, b, c, d, a, in[4] + K3, 15);
    117        
    118         buf[0] += a;
    119         buf[1] += b;
    120         buf[2] += c;
    121         buf[3] += d;
    122 }
    123 
    124 static uint32_t hash_unsigned(const char *name, int len)
    125 {
    126         uint32_t hash;
    127         uint32_t hash0 = 0x12a3fe2d;
    128         uint32_t hash1 = 0x37abe8f9;
    129         const unsigned char *ucp = (const unsigned char *) name;
    130        
    131         while (len--) {
    132                 hash = hash1 + (hash0 ^ (((int) *ucp++) * 7152373));
    133                
    134                 if (hash & 0x80000000)
    135                         hash -= 0x7fffffff;
    136                
    137                 hash1 = hash0;
    138                 hash0 = hash;
    139         }
    140        
    141         return hash0 << 1;
    142 }
    143 
    144 static uint32_t hash_signed(const char *name, int len)
    145 {
    146         uint32_t hash;
    147         uint32_t hash0 = 0x12a3fe2d;
    148         uint32_t hash1 = 0x37abe8f9;
    149         const signed char *scp = (const signed char *) name;
    150        
    151         while (len--) {
    152                 hash = hash1 + (hash0 ^ (((int) *scp++) * 7152373));
    153                
    154                 if (hash & 0x80000000)
    155                         hash -= 0x7fffffff;
    156                
    157                 hash1 = hash0;
    158                 hash0 = hash;
    159         }
    160        
    161         return hash0 << 1;
    162 }
    163 
    164 static void str2hashbuf_signed(const char *msg, int len, uint32_t *buf, int num)
    165 {
    166         uint32_t pad, val;
    167         int i;
    168         const signed char *scp = (const signed char *) msg;
    169        
    170         pad = (uint32_t) len | ((uint32_t) len << 8);
    171         pad |= pad << 16;
    172        
    173         val = pad;
    174         if (len > num * 4)
    175                 len = num * 4;
    176        
    177         for (i = 0; i < len; i++) {
    178                 if ((i % 4) == 0)
    179                         val = pad;
    180                
    181                 val = ((int) scp[i]) + (val << 8);
    182                 if ((i % 4) == 3) {
    183                         *buf++ = val;
    184                         val = pad;
    185                         num--;
    186                 }
    187         }
    188        
    189         if (--num >= 0)
    190                 *buf++ = val;
    191        
    192         while (--num >= 0)
    193                 *buf++ = pad;
    194 }
    195 
    196 static void str2hashbuf_unsigned(const char *msg, int len, uint32_t *buf,
    197     int num)
    198 {
    199         uint32_t pad, val;
    200         int i;
    201         const unsigned char *ucp = (const unsigned char *) msg;
    202        
    203         pad = (uint32_t) len | ((uint32_t) len << 8);
    204         pad |= pad << 16;
    205        
    206         val = pad;
    207         if (len > num * 4)
    208                 len = num * 4;
    209        
    210         for (i = 0; i < len; i++) {
    211                 if ((i % 4) == 0)
    212                         val = pad;
    213                
    214                 val = ((int) ucp[i]) + (val << 8);
    215                 if ((i % 4) == 3) {
    216                         *buf++ = val;
    217                         val = pad;
    218                         num--;
    219                 }
    220         }
    221        
    222         if (--num >= 0)
    223                 *buf++ = val;
    224        
    225         while (--num >= 0)
    226                 *buf++ = pad;
    227 }
    228 
    229 /** Compute hash value of the string.
    230  *
    231  * @param hinfo Hash info structure with information about
    232  *              the algorithm, hash seed and with the place
    233  *              for the output hash value
    234  * @param len  Length of the name
    235  * @param name Name to be hashed
    236  *
    237  * @return Error code
    238  *
    239  */
    24040int ext4_hash_string(ext4_hash_info_t *hinfo, int len, const char *name)
    24141{
    242         uint32_t hash = 0;
    243         uint32_t minor_hash = 0;
    244         const char *p;
    245         int i;
    246         uint32_t in[8], buf[4];
    247         void (*str2hashbuf)(const char *, int, uint32_t *, int) =
    248             str2hashbuf_signed;
    249        
    250         /* Initialize the default seed for the hash checksum functions */
    251         buf[0] = 0x67452301;
    252         buf[1] = 0xefcdab89;
    253         buf[2] = 0x98badcfe;
    254         buf[3] = 0x10325476;
    255        
    256         /* Check if the seed is all zero's */
    257         if (hinfo->seed) {
    258                 for (i = 0; i < 4; i++) {
    259                         if (hinfo->seed[i] != 0)
    260                                 break;
    261                        
    262                 }
    263                
    264                 if (i < 4)
    265                         memcpy(buf, hinfo->seed, sizeof(buf));
    266         }
    267        
    268         switch (hinfo->hash_version) {
    269         case EXT4_HASH_VERSION_LEGACY_UNSIGNED:
    270                 hash = hash_unsigned(name, len);
    271                 break;
    272         case EXT4_HASH_VERSION_LEGACY:
    273                 hash = hash_signed(name, len);
    274                 break;
    275         case EXT4_HASH_VERSION_HALF_MD4_UNSIGNED:
    276                 str2hashbuf = str2hashbuf_unsigned;
    277         case EXT4_HASH_VERSION_HALF_MD4:
    278                 p = name;
    279                
    280                 while (len > 0) {
    281                         (*str2hashbuf)(p, len, in, 8);
    282                         half_md4_transform(buf, in);
    283                         len -= 32;
    284                         p += 32;
    285                 }
    286                
    287                 minor_hash = buf[2];
    288                 hash = buf[1];
    289                 break;
    290         case EXT4_HASH_VERSION_TEA_UNSIGNED:
    291                 str2hashbuf = str2hashbuf_unsigned;
    292         case EXT4_HASH_VERSION_TEA:
    293                 p = name;
    294                
    295                 while (len > 0) {
    296                         (*str2hashbuf)(p, len, in, 4);
    297                         tea_transform(buf, in);
    298                         len -= 16;
    299                         p += 16;
    300                 }
    301                
    302                 hash = buf[0];
    303                 minor_hash = buf[1];
    304                 break;
    305         default:
    306                 hinfo->hash = 0;
    307                 return EINVAL;
    308         }
    309        
    310         hash = hash & ~1;
    311         if (hash == (EXT4_DIRECTORY_HTREE_EOF << 1))
    312                 hash = (EXT4_DIRECTORY_HTREE_EOF - 1) << 1;
    313        
    314         hinfo->hash = hash;
    315         hinfo->minor_hash = minor_hash;
    316        
    317         return EOK;
     42        // TODO
     43        hinfo->hash = 0;
     44        return ENOTSUP;
    31845}
    31946
Note: See TracChangeset for help on using the changeset viewer.