Changes in / [c7c6afd:b6061f8c] in mainline


Ignore:
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • common/stdc/uchar.c

    rc7c6afd rb6061f8c  
    8484}
    8585
     86static bool _is_non_shortest(unsigned short cont, uint8_t b)
     87{
     88        return (cont == 0b1111110000000000 && !(b & 0b00100000)) ||
     89            (cont == 0b1111111111110000 && !(b & 0b00110000));
     90}
     91
    8692size_t mbrtoc32(char32_t *c, const char *s, size_t n, mbstate_t *mb)
    8793{
    … …  
    139145
    140146                if (_is_2_byte(b)) {
     147                        /* Reject non-shortest form. */
     148                        if (!(b & 0b00011110)) {
     149                                _set_ilseq();
     150                                return UCHAR_ILSEQ;
     151                        }
     152
    141153                        /* 2 byte encoding               110xxxxx */
    142154                        mb->continuation = b ^ 0b0000000011000000;
    … …  
    152164        }
    153165
    154         while (i < n) {
     166        for (; i < n; i++) {
    155167                /* Read continuation bytes. */
    156 
    157                 if (!_is_continuation(s[i])) {
     168                uint8_t b = s[i];
     169
     170                if (!_is_continuation(b) || _is_non_shortest(mb->continuation, b)) {
    158171                        _set_ilseq();
    159172                        return UCHAR_ILSEQ;
    … …  
    162175                /* Top bit becomes zero just before the last byte is shifted in. */
    163176                if (!(mb->continuation & 0x8000)) {
    164                         *c = ((char32_t) mb->continuation) << 6 | (s[i++] & 0x3f);
     177                        *c = ((char32_t) mb->continuation) << 6 | (b & 0x3f);
    165178                        mb->continuation = 0;
    166                         return i;
    167                 }
    168 
    169                 mb->continuation = mb->continuation << 6 | (s[i++] & 0x3f);
     179                        return ++i;
     180                }
     181
     182                mb->continuation = mb->continuation << 6 | (b & 0x3f);
    170183        }
    171184

  • common/str.c

    rc7c6afd rb6061f8c  
    156156static inline int _char_continuation_bytes(char32_t c)
    157157{
     158        if ((c & ~LO_MASK_32(7)) == 0)
     159                return 0;
     160
    158161        if ((c & ~LO_MASK_32(11)) == 0)
    159162                return 1;
    … …  
    207210char32_t str_decode(const char *str, size_t *offset, size_t size)
    208211{
    209         if (*offset + 1 > size)
     212        if (*offset >= size)
    210213                return 0;
    211214
    … …  
    223226        /* Determine code length */
    224227
    225         unsigned int cbytes = _continuation_bytes(b0);
    226         unsigned int b0_bits = 6 - cbytes;  /* Data bits in first byte */
    227 
    228         if (*offset + cbytes > size)
     228        int cbytes = _continuation_bytes(b0);
     229        int b0_bits = 6 - cbytes;  /* Data bits in first byte */
     230
     231        if (cbytes < 0 || *offset + cbytes > size)
    229232                return U_SPECIAL;
    230233
    … …  
    232235
    233236        /* Decode continuation bytes */
    234         while (cbytes > 0) {
    235                 uint8_t b = (uint8_t) str[(*offset)++];
     237        for (int i = 0; i < cbytes; i++) {
     238                uint8_t b = (uint8_t) str[*offset];
    236239
    237240                if (!_is_continuation_byte(b))
    238241                        return U_SPECIAL;
    239242
     243                (*offset)++;
     244
    240245                /* Shift data bits to ch */
    241246                ch = (ch << CONT_BITS) | (char32_t) (b & LO_MASK_8(CONT_BITS));
    242                 cbytes--;
    243         }
     247        }
     248
     249        /*
     250         * Reject non-shortest form encodings.
     251         * See https://www.unicode.org/versions/corrigendum1.html
     252         */
     253        if (cbytes != _char_continuation_bytes(ch))
     254                return U_SPECIAL;
    244255
    245256        return ch;
    … …  
    345356
    346357/* Convert in place any bytes that don't form a valid character into U_SPECIAL. */
    347 static void _repair_string(char *str, size_t n)
    348 {
    349         for (; *str && n > 0; str++, n--) {
    350                 int cont = _continuation_bytes(*str);
    351                 if (cont == 0)
     358static void _sanitize_string(char *str, size_t n)
     359{
     360        uint8_t *b = (uint8_t *) str;
     361
     362        for (; *b && n > 0; b++, n--) {
     363                int cont = _continuation_bytes(b[0]);
     364                if (__builtin_expect(cont, 0) == 0)
    352365                        continue;
    353366
    354367                if (cont < 0 || n <= (size_t) cont) {
    355                         *str = U_SPECIAL;
     368                        b[0] = U_SPECIAL;
    356369                        continue;
    357370                }
    358371
     372                /* Check continuation bytes. */
    359373                for (int i = 1; i <= cont; i++) {
    360                         if (!_is_continuation_byte(str[i])) {
    361                                 *str = U_SPECIAL;
     374                        if (!_is_continuation_byte(b[i])) {
     375                                b[0] = U_SPECIAL;
    362376                                continue;
    363377                        }
     378                }
     379
     380                /*
     381                 * Check for non-shortest form encoding.
     382                 * See https://www.unicode.org/versions/corrigendum1.html
     383                 */
     384
     385                switch (cont) {
     386                case 1:
     387                        /* 0b110!!!!x 0b10xxxxxx */
     388                        if (!(b[0] & 0b00011110))
     389                                b[0] = U_SPECIAL;
     390
     391                        continue;
     392                case 2:
     393                        /* 0b1110!!!! 0b10!xxxxx 0b10xxxxxx */
     394                        if (!(b[0] & 0b00001111) && !(b[1] & 0b00100000))
     395                                b[0] = U_SPECIAL;
     396
     397                        continue;
     398                case 3:
     399                        /* 0b11110!!! 0b10!!xxxx 0b10xxxxxx 0b10xxxxxx */
     400                        if (!(b[0] & 0b00000111) && !(b[1] & 0b00110000))
     401                                b[0] = U_SPECIAL;
     402
     403                        continue;
    364404                }
    365405        }
    … …  
    881921static void _str_cpyn(char *dest, size_t size, const char *src)
    882922{
     923        assert(dest && src && size);
     924
     925        if (!dest || !src || !size)
     926                return;
     927
     928        if (size == STR_NO_LIMIT)
     929                return _str_cpy(dest, src);
     930
    883931        char *dest_top = dest + size - 1;
     932        assert(size == 1 || dest < dest_top);
    884933
    885934        while (*src && dest < dest_top)
    … …  
    907956        assert(src != NULL);
    908957        assert(dest != NULL);
     958        assert(size == STR_NO_LIMIT || dest + size > dest);
    909959
    910960        /* Copy data. */
    … …  
    912962
    913963        /* In-place translate invalid bytes to U_SPECIAL. */
    914         _repair_string(dest, size);
     964        _sanitize_string(dest, size);
    915965}
    916966
    … …  
    941991
    942992        /* In-place translate invalid bytes to U_SPECIAL. */
    943         _repair_string(dest, size);
     993        _sanitize_string(dest, size);
    944994}
    945995
    … …  
    9601010        assert(dest != NULL);
    9611011        assert(size > 0);
     1012        assert(size == STR_NO_LIMIT || dest + size > dest);
    9621013
    9631014        size_t dstr_size = _str_nsize(dest, size);
    964         _str_cpyn(dest + dstr_size, size - dstr_size, src);
    965         _repair_string(dest + dstr_size, size - dstr_size);
     1015        if (dstr_size < size) {
     1016                _str_cpyn(dest + dstr_size, size - dstr_size, src);
     1017                _sanitize_string(dest + dstr_size, size - dstr_size);
     1018        }
    9661019}
    9671020
    … …  
    15401593                return NULL;
    15411594
    1542         _str_cpy(dest, src);
    1543         _repair_string(dest, size);
     1595        memcpy(dest, src, size);
     1596        _sanitize_string(dest, size);
    15441597        return dest;
    15451598}
    … …  
    15671620char *str_ndup(const char *src, size_t n)
    15681621{
    1569         size_t size = _str_nsize(src, n) + 1;
    1570 
    1571         char *dest = malloc(size);
     1622        size_t size = _str_nsize(src, n);
     1623
     1624        char *dest = malloc(size + 1);
    15721625        if (!dest)
    15731626                return NULL;
    15741627
    1575         _str_cpyn(dest, size, src);
    1576         _repair_string(dest, size);
     1628        memcpy(dest, src, size);
     1629        _sanitize_string(dest, size);
     1630        dest[size] = 0;
    15771631        return dest;
    15781632}

  • uspace/app/sysinst/sysinst.c

    rc7c6afd rb6061f8c  
    7272 */
    7373#define DEFAULT_DEV_0 "devices/\\hw\\sys\\00:01.1\\c0d0"
    74 #define DEFAULT_DEV_1 "devices/\\hw\\sys\\00:01.0\\ide1\\c0d0"
     74#define DEFAULT_DEV_1 "devices/\\hw\\sys\\ide1\\c0d0"
    7575//#define DEFAULT_DEV "devices/\\hw\\pci0\\00:01.2\\uhci_rh\\usb01_a1\\mass-storage0\\l0"
    7676/** Volume label for the new file system */

  • uspace/drv/block/isa-ide/main.c

    rc7c6afd rb6061f8c  
    169169        isa_ide_ctrl_t *ctrl;
    170170        isa_ide_hwres_t res;
     171        unsigned chans;
    171172        errno_t rc;
    172173
    … …  
    187188        ctrl->dev = dev;
    188189
     190        chans = 0;
     191
    189192        rc = isa_ide_channel_init(ctrl, &ctrl->channel[0], 0, &res);
    190         if (rc == ENOENT)
     193        if (rc == EOK)
     194                ++chans;
     195        else if (rc != ENOENT)
    191196                goto error;
    192197
    193198        rc = isa_ide_channel_init(ctrl, &ctrl->channel[1], 1, &res);
    194         if (rc == ENOENT)
    195                 goto error;
    196 
    197         if (rc != EOK) {
    198                 ddf_msg(LVL_ERROR, "Failed initializing ATA controller.");
     199        if (rc == EOK)
     200                ++chans;
     201        else if (rc != ENOENT)
     202                goto error;
     203
     204        if (chans == 0) {
     205                ddf_msg(LVL_ERROR, "No ISA IDE devices found.");
    199206                rc = EIO;
    200207                goto error;

  • uspace/drv/block/pci-ide/main.c

    rc7c6afd rb6061f8c  
    136136        pci_ide_hwres_t res;
    137137        async_sess_t *parent_sess;
     138        unsigned chans;
    138139        errno_t rc;
    139140
    … …  
    157158                goto error;
    158159
     160        chans = 0;
     161
    159162        rc = pci_ide_channel_init(ctrl, &ctrl->channel[0], 0, &res);
    160         if (rc == ENOENT)
     163        if (rc == EOK)
     164                ++chans;
     165        else if (rc != ENOENT)
    161166                goto error;
    162167
    163168        rc = pci_ide_channel_init(ctrl, &ctrl->channel[1], 1, &res);
    164         if (rc == ENOENT)
    165                 goto error;
    166 
    167         if (rc != EOK) {
    168                 ddf_msg(LVL_ERROR, "Failed initializing ATA controller.");
     169        if (rc == EOK)
     170                ++chans;
     171        else if (rc != ENOENT)
     172                goto error;
     173
     174        if (chans == 0) {
     175                ddf_msg(LVL_ERROR, "No PCI IDE devices found.");
    169176                rc = EIO;
    170177                goto error;

  • uspace/lib/c/test/adt/odict.c

    rc7c6afd rb6061f8c  
    233233
    234234                e->key = v;
    235                 odict_insert(&e->odict, &odict, &ep->odict);
     235                odict_insert(&e->odict, &odict, ep ? &ep->odict : NULL);
    236236                PCUT_ASSERT_ERRNO_VAL(EOK, odict_validate(&odict));
    237237                v = seq_next(v);

  • uspace/lib/c/test/str.c

    rc7c6afd rb6061f8c  
    2727 */
    2828
     29#include "pcut/asserts.h"
    2930#include <stdio.h>
    3031#include <str.h>
    … …  
    115116}
    116117
     118PCUT_TEST(str_non_shortest)
     119{
     120        /* Overlong zero. */
     121        const char overlong1[] = { 0b11000000, 0b10000000, 0 };
     122        const char overlong2[] = { 0b11100000, 0b10000000, 0 };
     123        const char overlong3[] = { 0b11110000, 0b10000000, 0 };
     124
     125        const char overlong4[] = { 0b11000001, 0b10111111, 0 };
     126        const char overlong5[] = { 0b11100000, 0b10011111, 0b10111111, 0 };
     127        const char overlong6[] = { 0b11110000, 0b10001111, 0b10111111, 0b10111111, 0 };
     128
     129        size_t offset = 0;
     130        PCUT_ASSERT_INT_EQUALS(U_SPECIAL, str_decode(overlong1, &offset, sizeof(overlong1)));
     131        offset = 0;
     132        PCUT_ASSERT_INT_EQUALS(U_SPECIAL, str_decode(overlong2, &offset, sizeof(overlong2)));
     133        offset = 0;
     134        PCUT_ASSERT_INT_EQUALS(U_SPECIAL, str_decode(overlong3, &offset, sizeof(overlong3)));
     135        offset = 0;
     136        PCUT_ASSERT_INT_EQUALS(U_SPECIAL, str_decode(overlong4, &offset, sizeof(overlong4)));
     137        offset = 0;
     138        PCUT_ASSERT_INT_EQUALS(U_SPECIAL, str_decode(overlong5, &offset, sizeof(overlong5)));
     139        offset = 0;
     140        PCUT_ASSERT_INT_EQUALS(U_SPECIAL, str_decode(overlong6, &offset, sizeof(overlong6)));
     141
     142        char sanitized[sizeof(overlong6)];
     143        str_cpy(sanitized, STR_NO_LIMIT, overlong1);
     144        PCUT_ASSERT_INT_EQUALS(U_SPECIAL, sanitized[0]);
     145        str_cpy(sanitized, STR_NO_LIMIT, overlong2);
     146        PCUT_ASSERT_INT_EQUALS(U_SPECIAL, sanitized[0]);
     147        str_cpy(sanitized, STR_NO_LIMIT, overlong3);
     148        PCUT_ASSERT_INT_EQUALS(U_SPECIAL, sanitized[0]);
     149        str_cpy(sanitized, STR_NO_LIMIT, overlong4);
     150        PCUT_ASSERT_INT_EQUALS(U_SPECIAL, sanitized[0]);
     151        str_cpy(sanitized, STR_NO_LIMIT, overlong5);
     152        PCUT_ASSERT_INT_EQUALS(U_SPECIAL, sanitized[0]);
     153        str_cpy(sanitized, STR_NO_LIMIT, overlong6);
     154        PCUT_ASSERT_INT_EQUALS(U_SPECIAL, sanitized[0]);
     155}
     156
    117157PCUT_EXPORT(str);
Note: See TracChangeset for help on using the changeset viewer.