unicode.c

Go to the documentation of this file.

/*
 *  linux/fs/hfsplus/unicode.c
 *
 * Copyright (C) 2001
 * Brad Boyer ([email protected])
 * (C) 2003 Ardis Technologies <[email protected]>
 *
 * Handler routines for unicode strings
 */

#include <linux/types.h>
#include <linux/nls.h>
#include "hfsplus_fs.h"
#include "hfsplus_raw.h"

/* Fold the case of a unicode char, given the 16 bit value */
/* Returns folded char, or 0 if ignorable */
static inline u16 case_fold(u16 c)
{
    u16 tmp;

    tmp = hfsplus_case_fold_table[c >> 8];
    if (tmp)
        tmp = hfsplus_case_fold_table[tmp + (c & 0xff)];
    else
        tmp = c;
    return tmp;
}

/* Compare unicode strings, return values like normal strcmp */
int hfsplus_strcasecmp(const struct hfsplus_unistr *s1,
               const struct hfsplus_unistr *s2)
{
    u16 len1, len2, c1, c2;
    const hfsplus_unichr *p1, *p2;

    len1 = be16_to_cpu(s1->length);
    len2 = be16_to_cpu(s2->length);
    p1 = s1->unicode;
    p2 = s2->unicode;

    while (1) {
        c1 = c2 = 0;

        while (len1 && !c1) {
            c1 = case_fold(be16_to_cpu(*p1));
            p1++;
            len1--;
        }
        while (len2 && !c2) {
            c2 = case_fold(be16_to_cpu(*p2));
            p2++;
            len2--;
        }

        if (c1 != c2)
            return (c1 < c2) ? -1 : 1;
        if (!c1 && !c2)
            return 0;
    }
}

/* Compare names as a sequence of 16-bit unsigned integers */
int hfsplus_strcmp(const struct hfsplus_unistr *s1,
           const struct hfsplus_unistr *s2)
{
    u16 len1, len2, c1, c2;
    const hfsplus_unichr *p1, *p2;
    int len;

    len1 = be16_to_cpu(s1->length);
    len2 = be16_to_cpu(s2->length);
    p1 = s1->unicode;
    p2 = s2->unicode;

    for (len = min(len1, len2); len > 0; len--) {
        c1 = be16_to_cpu(*p1);
        c2 = be16_to_cpu(*p2);
        if (c1 != c2)
            return c1 < c2 ? -1 : 1;
        p1++;
        p2++;
    }

    return len1 < len2 ? -1 :
           len1 > len2 ? 1 : 0;
}


#define Hangul_SBase    0xac00
#define Hangul_LBase    0x1100
#define Hangul_VBase    0x1161
#define Hangul_TBase    0x11a7
#define Hangul_SCount   11172
#define Hangul_LCount   19
#define Hangul_VCount   21
#define Hangul_TCount   28
#define Hangul_NCount   (Hangul_VCount * Hangul_TCount)


static u16 *hfsplus_compose_lookup(u16 *p, u16 cc)
{
    int i, s, e;

    s = 1;
    e = p[1];
    if (!e || cc < p[s * 2] || cc > p[e * 2])
        return NULL;
    do {
        i = (s + e) / 2;
        if (cc > p[i * 2])
            s = i + 1;
        else if (cc < p[i * 2])
            e = i - 1;
        else
            return hfsplus_compose_table + p[i * 2 + 1];
    } while (s <= e);
    return NULL;
}

int hfsplus_uni2asc(struct super_block *sb,
        const struct hfsplus_unistr *ustr,
        char *astr, int *len_p)
{
    const hfsplus_unichr *ip;
    struct nls_table *nls = HFSPLUS_SB(sb)->nls;
    u8 *op;
    u16 cc, c0, c1;
    u16 *ce1, *ce2;
    int i, len, ustrlen, res, compose;

    op = astr;
    ip = ustr->unicode;
    ustrlen = be16_to_cpu(ustr->length);
    len = *len_p;
    ce1 = NULL;
    compose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);

    while (ustrlen > 0) {
        c0 = be16_to_cpu(*ip++);
        ustrlen--;
        /* search for single decomposed char */
        if (likely(compose))
            ce1 = hfsplus_compose_lookup(hfsplus_compose_table, c0);
        if (ce1)
            cc = ce1[0];
        else
            cc = 0;
        if (cc) {
            /* start of a possibly decomposed Hangul char */
            if (cc != 0xffff)
                goto done;
            if (!ustrlen)
                goto same;
            c1 = be16_to_cpu(*ip) - Hangul_VBase;
            if (c1 < Hangul_VCount) {
                /* compose the Hangul char */
                cc = (c0 - Hangul_LBase) * Hangul_VCount;
                cc = (cc + c1) * Hangul_TCount;
                cc += Hangul_SBase;
                ip++;
                ustrlen--;
                if (!ustrlen)
                    goto done;
                c1 = be16_to_cpu(*ip) - Hangul_TBase;
                if (c1 > 0 && c1 < Hangul_TCount) {
                    cc += c1;
                    ip++;
                    ustrlen--;
                }
                goto done;
            }
        }
        while (1) {
            /* main loop for common case of not composed chars */
            if (!ustrlen)
                goto same;
            c1 = be16_to_cpu(*ip);
            if (likely(compose))
                ce1 = hfsplus_compose_lookup(
                    hfsplus_compose_table, c1);
            if (ce1)
                break;
            switch (c0) {
            case 0:
                c0 = 0x2400;
                break;
            case '/':
                c0 = ':';
                break;
            }
            res = nls->uni2char(c0, op, len);
            if (res < 0) {
                if (res == -ENAMETOOLONG)
                    goto out;
                *op = '?';
                res = 1;
            }
            op += res;
            len -= res;
            c0 = c1;
            ip++;
            ustrlen--;
        }
        ce2 = hfsplus_compose_lookup(ce1, c0);
        if (ce2) {
            i = 1;
            while (i < ustrlen) {
                ce1 = hfsplus_compose_lookup(ce2,
                    be16_to_cpu(ip[i]));
                if (!ce1)
                    break;
                i++;
                ce2 = ce1;
            }
            cc = ce2[0];
            if (cc) {
                ip += i;
                ustrlen -= i;
                goto done;
            }
        }
same:
        switch (c0) {
        case 0:
            cc = 0x2400;
            break;
        case '/':
            cc = ':';
            break;
        default:
            cc = c0;
        }
done:
        res = nls->uni2char(cc, op, len);
        if (res < 0) {
            if (res == -ENAMETOOLONG)
                goto out;
            *op = '?';
            res = 1;
        }
        op += res;
        len -= res;
    }
    res = 0;
out:
    *len_p = (char *)op - astr;
    return res;
}

/*
 * Convert one or more ASCII characters into a single unicode character.
 * Returns the number of ASCII characters corresponding to the unicode char.
 */
static inline int asc2unichar(struct super_block *sb, const char *astr, int len,
                  wchar_t *uc)
{
    int size = HFSPLUS_SB(sb)->nls->char2uni(astr, len, uc);
    if (size <= 0) {
        *uc = '?';
        size = 1;
    }
    switch (*uc) {
    case 0x2400:
        *uc = 0;
        break;
    case ':':
        *uc = '/';
        break;
    }
    return size;
}

/* Decomposes a single unicode character. */
static inline u16 *decompose_unichar(wchar_t uc, int *size)
{
    int off;

    off = hfsplus_decompose_table[(uc >> 12) & 0xf];
    if (off == 0 || off == 0xffff)
        return NULL;

    off = hfsplus_decompose_table[off + ((uc >> 8) & 0xf)];
    if (!off)
        return NULL;

    off = hfsplus_decompose_table[off + ((uc >> 4) & 0xf)];
    if (!off)
        return NULL;

    off = hfsplus_decompose_table[off + (uc & 0xf)];
    *size = off & 3;
    if (*size == 0)
        return NULL;
    return hfsplus_decompose_table + (off / 4);
}

int hfsplus_asc2uni(struct super_block *sb, struct hfsplus_unistr *ustr,
            const char *astr, int len)
{
    int size, dsize, decompose;
    u16 *dstr, outlen = 0;
    wchar_t c;

    decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
    while (outlen < HFSPLUS_MAX_STRLEN && len > 0) {
        size = asc2unichar(sb, astr, len, &c);

        if (decompose)
            dstr = decompose_unichar(c, &dsize);
        else
            dstr = NULL;
        if (dstr) {
            if (outlen + dsize > HFSPLUS_MAX_STRLEN)
                break;
            do {
                ustr->unicode[outlen++] = cpu_to_be16(*dstr++);
            } while (--dsize > 0);
        } else
            ustr->unicode[outlen++] = cpu_to_be16(c);

        astr += size;
        len -= size;
    }
    ustr->length = cpu_to_be16(outlen);
    if (len > 0)
        return -ENAMETOOLONG;
    return 0;
}

/*
 * Hash a string to an integer as appropriate for the HFS+ filesystem.
 * Composed unicode characters are decomposed and case-folding is performed
 * if the appropriate bits are (un)set on the superblock.
 */
int hfsplus_hash_dentry(const struct dentry *dentry, const struct inode *inode,
        struct qstr *str)
{
    struct super_block *sb = dentry->d_sb;
    const char *astr;
    const u16 *dstr;
    int casefold, decompose, size, len;
    unsigned long hash;
    wchar_t c;
    u16 c2;

    casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
    decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
    hash = init_name_hash();
    astr = str->name;
    len = str->len;
    while (len > 0) {
        int uninitialized_var(dsize);
        size = asc2unichar(sb, astr, len, &c);
        astr += size;
        len -= size;

        if (decompose)
            dstr = decompose_unichar(c, &dsize);
        else
            dstr = NULL;
        if (dstr) {
            do {
                c2 = *dstr++;
                if (casefold)
                    c2 = case_fold(c2);
                if (!casefold || c2)
                    hash = partial_name_hash(c2, hash);
            } while (--dsize > 0);
        } else {
            c2 = c;
            if (casefold)
                c2 = case_fold(c2);
            if (!casefold || c2)
                hash = partial_name_hash(c2, hash);
        }
    }
    str->hash = end_name_hash(hash);

    return 0;
}

/*
 * Compare strings with HFS+ filename ordering.
 * Composed unicode characters are decomposed and case-folding is performed
 * if the appropriate bits are (un)set on the superblock.
 */
int hfsplus_compare_dentry(const struct dentry *parent,
        const struct inode *pinode,
        const struct dentry *dentry, const struct inode *inode,
        unsigned int len, const char *str, const struct qstr *name)
{
    struct super_block *sb = parent->d_sb;
    int casefold, decompose, size;
    int dsize1, dsize2, len1, len2;
    const u16 *dstr1, *dstr2;
    const char *astr1, *astr2;
    u16 c1, c2;
    wchar_t c;

    casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
    decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
    astr1 = str;
    len1 = len;
    astr2 = name->name;
    len2 = name->len;
    dsize1 = dsize2 = 0;
    dstr1 = dstr2 = NULL;

    while (len1 > 0 && len2 > 0) {
        if (!dsize1) {
            size = asc2unichar(sb, astr1, len1, &c);
            astr1 += size;
            len1 -= size;

            if (decompose)
                dstr1 = decompose_unichar(c, &dsize1);
            if (!decompose || !dstr1) {
                c1 = c;
                dstr1 = &c1;
                dsize1 = 1;
            }
        }

        if (!dsize2) {
            size = asc2unichar(sb, astr2, len2, &c);
            astr2 += size;
            len2 -= size;

            if (decompose)
                dstr2 = decompose_unichar(c, &dsize2);
            if (!decompose || !dstr2) {
                c2 = c;
                dstr2 = &c2;
                dsize2 = 1;
            }
        }

        c1 = *dstr1;
        c2 = *dstr2;
        if (casefold) {
            c1 = case_fold(c1);
            if (!c1) {
                dstr1++;
                dsize1--;
                continue;
            }
            c2 = case_fold(c2);
            if (!c2) {
                dstr2++;
                dsize2--;
                continue;
            }
        }
        if (c1 < c2)
            return -1;
        else if (c1 > c2)
            return 1;

        dstr1++;
        dsize1--;
        dstr2++;
        dsize2--;
    }

    if (len1 < len2)
        return -1;
    if (len1 > len2)
        return 1;
    return 0;
}