Changeset 3e828ea in mainline for uspace/lib/c/generic

Timestamp:

2019-09-23T12:49:29Z (7 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

9be2358

Parents:

9259d20 (diff), 1a4ec93f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

Jiri Svoboda <jiri@…> (2019-09-22 12:49:07)

git-committer:

Jiri Svoboda <jiri@…> (2019-09-23 12:49:29)

Message:

Merge changes from master, especially Meson build

Location:

uspace/lib/c/generic

Files:

• async/server.c (modified) (1 diff)
• crt/crt1.c (moved) (moved from uspace/lib/c/generic/crt/entry.c )
• ctype.c (modified) (1 diff)
• dirent.c (modified) (2 diffs)
• dlfcn.c (modified) (4 diffs)
• elf/elf_load.c (modified) (3 diffs)
• elf/elf_mod.c (modified) (29 diffs)
• private/stdio.h (modified) (4 diffs)
• rtld/module.c (modified) (9 diffs)
• rtld/rtld.c (modified) (1 diff)
• str.c (modified) (1 diff)
• strtol.c (modified) (11 diffs)
• ubsan.c (modified) (6 diffs)

uspace/lib/c/generic/async/server.c

@@ -114 +114 @@
 #include <stdlib.h>
 #include <mem.h>
-#include <stdlib.h>
 #include <macros.h>
 #include <str_error.h>

uspace/lib/c/generic/ctype.c

@@ -90 +90 @@
         case '\v':
                 return 1;
-                break;
         default:
                 return 0;

uspace/lib/c/generic/dirent.c

@@ -39 +39 @@
 #include <errno.h>
 #include <assert.h>
+#include <string.h>
 
 struct __dirstream {
@@ -92 +93 @@
         ssize_t len = 0;
 
-        rc = vfs_read_short(dirp->fd, dirp->pos, &dirp->res.d_name[0],
-            NAME_MAX + 1, &len);
+        rc = vfs_read_short(dirp->fd, dirp->pos, dirp->res.d_name,
+            sizeof(dirp->res.d_name), &len);
         if (rc != EOK) {
                 errno = rc;
                 return NULL;
         }
+
+        assert(strnlen(dirp->res.d_name, sizeof(dirp->res.d_name)) < sizeof(dirp->res.d_name));
 
         dirp->pos += len;

uspace/lib/c/generic/dlfcn.c

@@ -35 +35 @@
  */
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -44 +45 @@
 #include <rtld/module.h>
 #include <rtld/rtld.h>
+#include <rtld/rtld_arch.h>
 #include <rtld/symbol.h>
 
@@ -53 +55 @@
         if (m == NULL) {
                 m = module_load(runtime_env, path, mlf_local);
-                module_load_deps(m, mlf_local);
+                if (m == NULL) {
+                        return NULL;
+                }
+
+                if (module_load_deps(m, mlf_local) != EOK) {
+                        return NULL;
+                }
+
                 /* Now relocate. */
                 module_process_relocs(m);
@@ -71 +80 @@
         sd = symbol_bfs_find(sym_name, (module_t *) mod, &sm);
         if (sd != NULL) {
-                return symbol_get_addr(sd, sm, __tcb_get());
+                if (elf_st_type(sd->st_info) == STT_FUNC)
+                        return func_get_addr(sd, sm);
+                else
+                        return symbol_get_addr(sd, sm, __tcb_get());
         }
 

uspace/lib/c/generic/elf/elf_load.c

@@ -53 +53 @@
  * @param file File handle
  * @param info Place to store ELF program information
- * @return EE_OK on success or an EE_x error code
+ * @return EOK on success or an error code
  */
-int elf_load(int file, elf_info_t *info)
+errno_t elf_load(int file, elf_info_t *info)
 {
 #ifdef CONFIG_RTLD
         rtld_t *env;
 #endif
-        int rc;
+        errno_t rc;
 
         rc = elf_load_file(file, 0, &info->finfo);
-        if (rc != EE_OK) {
+        if (rc != EOK) {
                 DPRINTF("Failed to load executable '%s'.\n", file_name);
                 return rc;
@@ -72 +72 @@
                 DPRINTF("Binary is statically linked.\n");
                 info->env = NULL;
-                return EE_OK;
+                return EOK;
         }
 
@@ -79 +79 @@
         DPRINTF("- prog dynamic: %p\n", info->finfo.dynamic);
 
-        errno_t rc2 = rtld_prog_process(&info->finfo, &env);
-        switch (rc2) {
-        case EOK:
-                rc = EE_OK;
-                break;
-        case ENOMEM:
-                rc = EE_MEMORY;
-                break;
-        default:
-                DPRINTF("Unexpected error code from rtld_prog_process(): %s\n", str_error_name(rc2));
-                rc = EE_INVALID;
-        }
-
+        rc = rtld_prog_process(&info->finfo, &env);
         info->env = env;
 #else
-        rc = EE_UNSUPPORTED;
+        rc = ENOTSUP;
 #endif
         return rc;

uspace/lib/c/generic/elf/elf_mod.c

@@ -64 +64 @@
 #define DPRINTF(...)
 
-static const char *error_codes[] = {
-        "no error",
-        "invalid image",
-        "address space error",
-        "incompatible image",
-        "unsupported image type",
-        "irrecoverable error",
-        "file io error"
-};
-
-static unsigned int elf_load_module(elf_ld_t *elf);
-static int segment_header(elf_ld_t *elf, elf_segment_header_t *entry);
-static int load_segment(elf_ld_t *elf, elf_segment_header_t *entry);
+static errno_t elf_load_module(elf_ld_t *elf);
+static errno_t segment_header(elf_ld_t *elf, elf_segment_header_t *entry);
+static errno_t load_segment(elf_ld_t *elf, elf_segment_header_t *entry);
 
 /** Load ELF binary from a file.
@@ -90 +80 @@
  *                  extracted from the binary.
  *
- * @return EE_OK on success or EE_xx error code.
- *
- */
-int elf_load_file(int file, eld_flags_t flags, elf_finfo_t *info)
+ * @return EOK on success or an error code.
+ *
+ */
+errno_t elf_load_file(int file, eld_flags_t flags, elf_finfo_t *info)
 {
         elf_ld_t elf;
@@ -103 +93 @@
         }
         if (rc != EOK) {
-                return EE_IO;
+                return rc;
         }
 
@@ -110 +100 @@
         elf.flags = flags;
 
-        int ret = elf_load_module(&elf);
+        rc = elf_load_module(&elf);
 
         vfs_put(ofile);
-        return ret;
-}
-
-int elf_load_file_name(const char *path, eld_flags_t flags, elf_finfo_t *info)
+        return rc;
+}
+
+errno_t elf_load_file_name(const char *path, eld_flags_t flags, elf_finfo_t *info)
 {
         int file;
         errno_t rc = vfs_lookup(path, 0, &file);
         if (rc == EOK) {
-                int ret = elf_load_file(file, flags, info);
+                rc = elf_load_file(file, flags, info);
                 vfs_put(file);
-                return ret;
+                return rc;
         } else {
-                return EE_IO;
+                return EIO;
         }
 }
@@ -136 +126 @@
  *
  * @param elf           Pointer to loader state buffer.
- * @return EE_OK on success or EE_xx error code.
- */
-static unsigned int elf_load_module(elf_ld_t *elf)
+ * @return EOK on success or an error code.
+ */
+static errno_t elf_load_module(elf_ld_t *elf)
 {
         elf_header_t header_buf;
@@ -144 +134 @@
         aoff64_t pos = 0;
         size_t nr;
-        int i, ret;
+        int i;
         errno_t rc;
 
@@ -150 +140 @@
         if (rc != EOK || nr != sizeof(elf_header_t)) {
                 DPRINTF("Read error.\n");
-                return EE_IO;
+                return EIO;
         }
 
@@ -159 +149 @@
             header->e_ident[EI_MAG3] != ELFMAG3) {
                 DPRINTF("Invalid header.\n");
-                return EE_INVALID;
+                return EINVAL;
         }
 
@@ -169 +159 @@
             header->e_ident[EI_CLASS] != ELF_CLASS) {
                 DPRINTF("Incompatible data/version/class.\n");
-                return EE_INCOMPATIBLE;
+                return EINVAL;
         }
 
@@ -175 +165 @@
                 DPRINTF("e_phentsize: %u != %zu\n", header->e_phentsize,
                     sizeof(elf_segment_header_t));
-                return EE_INCOMPATIBLE;
+                return EINVAL;
         }
 
@@ -181 +171 @@
         if (header->e_type != ET_EXEC && header->e_type != ET_DYN) {
                 DPRINTF("Object type %d is not supported\n", header->e_type);
-                return EE_UNSUPPORTED;
+                return ENOTSUP;
         }
 
         if (header->e_phoff == 0) {
                 DPRINTF("Program header table is not present!\n");
-                return EE_UNSUPPORTED;
+                return ENOTSUP;
         }
 
@@ -203 +193 @@
         if (phdr_len > sizeof(phdr)) {
                 DPRINTF("more than %d program headers\n", phdr_cap);
-                return EE_UNSUPPORTED;
+                return ENOTSUP;
         }
 
@@ -210 +200 @@
         if (rc != EOK || nr != phdr_len) {
                 DPRINTF("Read error.\n");
-                return EE_IO;
+                return EIO;
         }
 
@@ -231 +221 @@
         if (base_offset != 0) {
                 DPRINTF("ELF headers not present in the text segment.\n");
-                return EE_INVALID;
+                return EINVAL;
         }
 
@@ -240 +230 @@
                 if (module_base != 0) {
                         DPRINTF("Unexpected shared object format.\n");
-                        return EE_INVALID;
+                        return EINVAL;
                 }
 
@@ -258 +248 @@
                 if (area == AS_MAP_FAILED) {
                         DPRINTF("Can't find suitable memory area.\n");
-                        return EE_MEMORY;
+                        return ENOMEM;
                 }
 
@@ -270 +260 @@
                         continue;
 
-                ret = load_segment(elf, &phdr[i]);
-                if (ret != EE_OK)
-                        return ret;
+                rc = load_segment(elf, &phdr[i]);
+                if (rc != EOK)
+                        return rc;
         }
 
@@ -292 +282 @@
                         continue;
 
-                ret = segment_header(elf, &phdr[i]);
-                if (ret != EE_OK)
-                        return ret;
+                rc = segment_header(elf, &phdr[i]);
+                if (rc != EOK)
+                        return rc;
         }
 
@@ -302 +292 @@
         DPRINTF("Done.\n");
 
-        return EE_OK;
-}
-
-/** Print error message according to error code.
- *
- * @param rc Return code returned by elf_load().
- *
- * @return NULL terminated description of error.
- */
-const char *elf_error(unsigned int rc)
-{
-        assert(rc < sizeof(error_codes) / sizeof(char *));
-
-        return error_codes[rc];
+        return EOK;
 }
 
@@ -338 +315 @@
  * @param entry Segment header.
  *
- * @return EE_OK on success, error code otherwise.
- */
-static int segment_header(elf_ld_t *elf, elf_segment_header_t *entry)
+ * @return EOK on success, error code otherwise.
+ */
+static errno_t segment_header(elf_ld_t *elf, elf_segment_header_t *entry)
 {
         switch (entry->p_type) {
@@ -358 +335 @@
                 if (entry->p_filesz == 0) {
                         DPRINTF("Zero-sized ELF interp string.\n");
-                        return EE_INVALID;
+                        return EINVAL;
                 }
                 if (elf->info->interp[entry->p_filesz - 1] != '\0') {
                         DPRINTF("Unterminated ELF interp string.\n");
-                        return EE_INVALID;
+                        return EINVAL;
                 }
                 DPRINTF("interpreter: \"%s\"\n", elf->info->interp);
@@ -389 +366 @@
         default:
                 DPRINTF("Segment p_type %d unknown.\n", entry->p_type);
-                return EE_UNSUPPORTED;
-                break;
-        }
-        return EE_OK;
+                return ENOTSUP;
+                break;
+        }
+        return EOK;
 }
 
@@ -400 +377 @@
  * @param entry Program header entry describing segment to be loaded.
  *
- * @return EE_OK on success, error code otherwise.
- */
-int load_segment(elf_ld_t *elf, elf_segment_header_t *entry)
+ * @return EOK on success, error code otherwise.
+ */
+errno_t load_segment(elf_ld_t *elf, elf_segment_header_t *entry)
 {
         void *a;
@@ -435 +412 @@
                             entry->p_offset % entry->p_align,
                             seg_addr % entry->p_align, entry->p_align);
-                        return EE_INVALID;
+                        return EINVAL;
                 }
         }
@@ -466 +443 @@
                 DPRINTF("memory mapping failed (%p, %zu)\n",
                     (void *) (base + bias), mem_sz);
-                return EE_MEMORY;
+                return ENOMEM;
         }
 
@@ -479 +456 @@
         if (rc != EOK || nr != entry->p_filesz) {
                 DPRINTF("read error\n");
-                return EE_IO;
+                return EIO;
         }
 
@@ -487 +464 @@
          */
         if ((elf->flags & ELDF_RW) != 0)
-                return EE_OK;
+                return EOK;
 
         DPRINTF("as_area_change_flags(%p, %x)\n",
@@ -494 +471 @@
         if (rc != EOK) {
                 DPRINTF("Failed to set memory area flags.\n");
-                return EE_MEMORY;
+                return ENOMEM;
         }
 
@@ -500 +477 @@
                 /* Enforce SMC coherence for the segment */
                 if (smc_coherence(seg_ptr, entry->p_filesz))
-                        return EE_MEMORY;
-        }
-
-        return EE_OK;
+                        return ENOMEM;
+        }
+
+        return EOK;
 }
 

uspace/lib/c/generic/private/stdio.h

@@ -40 +40 @@
 #include <async.h>
 #include <stddef.h>
+#include <offset.h>
 
 /** Maximum characters that can be pushed back by ungetc() */
@@ -54 +55 @@
         int (*flush)(FILE *stream);
 } __stream_ops_t;
+
+enum __buffer_state {
+        /** Buffer is empty */
+        _bs_empty,
+
+        /** Buffer contains data to be written */
+        _bs_write,
+
+        /** Buffer contains prefetched data for reading */
+        _bs_read
+};
 
 struct _IO_FILE {
@@ -87 +99 @@
 
         /** Buffering type */
-        enum _buffer_type btype;
+        enum __buffer_type btype;
 
         /** Buffer */
@@ -96 +108 @@
 
         /** Buffer state */
-        enum _buffer_state buf_state;
+        enum __buffer_state buf_state;
 
         /** Buffer I/O pointer */

uspace/lib/c/generic/rtld/module.c

@@ -65 +65 @@
 
         module = calloc(1, sizeof(module_t));
-        if (module == NULL)
+        if (module == NULL) {
+                DPRINTF("malloc failed\n");
                 return ENOMEM;
+        }
 
         module->id = rtld_get_next_id(rtld);
@@ -182 +184 @@
         char name_buf[NAME_BUF_SIZE];
         module_t *m;
-        int rc;
+        errno_t rc;
 
         m = calloc(1, sizeof(module_t));
         if (m == NULL) {
-                printf("malloc failed\n");
-                exit(1);
+                DPRINTF("malloc failed\n");
+                goto error;
         }
 
@@ -197 +199 @@
 
         if (str_size(name) > NAME_BUF_SIZE - 2) {
-                printf("soname too long. increase NAME_BUF_SIZE\n");
-                exit(1);
+                DPRINTF("soname too long. increase NAME_BUF_SIZE\n");
+                goto error;
         }
 
@@ -208 +210 @@
 
         rc = elf_load_file_name(name_buf, RTLD_MODULE_LDF, &info);
-        if (rc != EE_OK) {
-                printf("Failed to load '%s'\n", name_buf);
-                exit(1);
+        if (rc != EOK) {
+                DPRINTF("Failed to load '%s'\n", name_buf);
+                goto error;
         }
 
@@ -218 +220 @@
 
         if (info.dynamic == NULL) {
-                printf("Error: '%s' is not a dynamically-linked object.\n",
+                DPRINTF("Error: '%s' is not a dynamically-linked object.\n",
                     name_buf);
-                exit(1);
+                goto error;
         }
 
@@ -243 +245 @@
 
         return m;
+
+error:
+        if (m)
+                free(m);
+
+        return NULL;
 }
 
 /** Load all modules on which m (transitively) depends.
  */
-void module_load_deps(module_t *m, mlflags_t flags)
+errno_t module_load_deps(module_t *m, mlflags_t flags)
 {
         elf_dyn_t *dp;
@@ -274 +282 @@
                 /* There are no dependencies, so we are done. */
                 m->deps = NULL;
-                return;
+                return EOK;
         }
 
         m->deps = malloc(n * sizeof(module_t *));
         if (!m->deps) {
-                printf("malloc failed\n");
-                exit(1);
+                DPRINTF("malloc failed\n");
+                return ENOMEM;
         }
 
@@ -294 +302 @@
                         if (!dm) {
                                 dm = module_load(m->rtld, dep_name, flags);
-                                module_load_deps(dm, flags);
+                                if (!dm) {
+                                        return EINVAL;
+                                }
+
+                                errno_t rc = module_load_deps(dm, flags);
+                                if (rc != EOK) {
+                                        return rc;
+                                }
                         }
 
@@ -302 +317 @@
                 ++dp;
         }
+
+        return EOK;
 }
 

uspace/lib/c/generic/rtld/rtld.c

@@ -125 +125 @@
 
         DPRINTF("Load all program dependencies\n");
-        module_load_deps(prog, 0);
+        errno_t rc = module_load_deps(prog, 0);
+        if (rc != EOK) {
+                return rc;
+        }
 
         /* Compute static TLS size */

uspace/lib/c/generic/str.c

@@ -1471 +1471 @@
         *end = '\0';
         return start;
-}
-
-/** Convert string to uint64_t (internal variant).
- *
- * @param nptr   Pointer to string.
- * @param endptr Pointer to the first invalid character is stored here.
- * @param base   Zero or number between 2 and 36 inclusive.
- * @param neg    Indication of unary minus is stored here.
- * @apram result Result of the conversion.
- *
- * @return EOK if conversion was successful.
- *
- */
-static errno_t str_uint(const char *nptr, char **endptr, unsigned int base,
-    bool *neg, uint64_t *result)
-{
-        assert(endptr != NULL);
-        assert(neg != NULL);
-        assert(result != NULL);
-
-        *neg = false;
-        const char *str = nptr;
-
-        /* Ignore leading whitespace */
-        while (isspace(*str))
-                str++;
-
-        if (*str == '-') {
-                *neg = true;
-                str++;
-        } else if (*str == '+')
-                str++;
-
-        if (base == 0) {
-                /* Decode base if not specified */
-                base = 10;
-
-                if (*str == '0') {
-                        base = 8;
-                        str++;
-
-                        switch (*str) {
-                        case 'b':
-                        case 'B':
-                                base = 2;
-                                str++;
-                                break;
-                        case 'o':
-                        case 'O':
-                                base = 8;
-                                str++;
-                                break;
-                        case 'd':
-                        case 'D':
-                        case 't':
-                        case 'T':
-                                base = 10;
-                                str++;
-                                break;
-                        case 'x':
-                        case 'X':
-                                base = 16;
-                                str++;
-                                break;
-                        default:
-                                str--;
-                        }
-                }
-        } else {
-                /* Check base range */
-                if ((base < 2) || (base > 36)) {
-                        *endptr = (char *) str;
-                        return EINVAL;
-                }
-        }
-
-        *result = 0;
-        const char *startstr = str;
-
-        while (*str != 0) {
-                unsigned int digit;
-
-                if ((*str >= 'a') && (*str <= 'z'))
-                        digit = *str - 'a' + 10;
-                else if ((*str >= 'A') && (*str <= 'Z'))
-                        digit = *str - 'A' + 10;
-                else if ((*str >= '0') && (*str <= '9'))
-                        digit = *str - '0';
-                else
-                        break;
-
-                if (digit >= base)
-                        break;
-
-                uint64_t prev = *result;
-                *result = (*result) * base + digit;
-
-                if (*result < prev) {
-                        /* Overflow */
-                        *endptr = (char *) str;
-                        return EOVERFLOW;
-                }
-
-                str++;
-        }
-
-        if (str == startstr) {
-                /*
-                 * No digits were decoded => first invalid character is
-                 * the first character of the string.
-                 */
-                str = nptr;
-        }
-
-        *endptr = (char *) str;
-
-        if (str == nptr)
-                return EINVAL;
-
-        return EOK;
-}
-
-/** Convert string to uint8_t.
- *
- * @param nptr   Pointer to string.
- * @param endptr If not NULL, pointer to the first invalid character
- *               is stored here.
- * @param base   Zero or number between 2 and 36 inclusive.
- * @param strict Do not allow any trailing characters.
- * @param result Result of the conversion.
- *
- * @return EOK if conversion was successful.
- *
- */
-errno_t str_uint8_t(const char *nptr, const char **endptr, unsigned int base,
-    bool strict, uint8_t *result)
-{
-        assert(result != NULL);
-
-        bool neg;
-        char *lendptr;
-        uint64_t res;
-        errno_t ret = str_uint(nptr, &lendptr, base, &neg, &res);
-
-        if (endptr != NULL)
-                *endptr = (char *) lendptr;
-
-        if (ret != EOK)
-                return ret;
-
-        /* Do not allow negative values */
-        if (neg)
-                return EINVAL;
-
-        /*
-         * Check whether we are at the end of
-         * the string in strict mode
-         */
-        if ((strict) && (*lendptr != 0))
-                return EINVAL;
-
-        /* Check for overflow */
-        uint8_t _res = (uint8_t) res;
-        if (_res != res)
-                return EOVERFLOW;
-
-        *result = _res;
-
-        return EOK;
-}
-
-/** Convert string to uint16_t.
- *
- * @param nptr   Pointer to string.
- * @param endptr If not NULL, pointer to the first invalid character
- *               is stored here.
- * @param base   Zero or number between 2 and 36 inclusive.
- * @param strict Do not allow any trailing characters.
- * @param result Result of the conversion.
- *
- * @return EOK if conversion was successful.
- *
- */
-errno_t str_uint16_t(const char *nptr, const char **endptr, unsigned int base,
-    bool strict, uint16_t *result)
-{
-        assert(result != NULL);
-
-        bool neg;
-        char *lendptr;
-        uint64_t res;
-        errno_t ret = str_uint(nptr, &lendptr, base, &neg, &res);
-
-        if (endptr != NULL)
-                *endptr = (char *) lendptr;
-
-        if (ret != EOK)
-                return ret;
-
-        /* Do not allow negative values */
-        if (neg)
-                return EINVAL;
-
-        /*
-         * Check whether we are at the end of
-         * the string in strict mode
-         */
-        if ((strict) && (*lendptr != 0))
-                return EINVAL;
-
-        /* Check for overflow */
-        uint16_t _res = (uint16_t) res;
-        if (_res != res)
-                return EOVERFLOW;
-
-        *result = _res;
-
-        return EOK;
-}
-
-/** Convert string to uint32_t.
- *
- * @param nptr   Pointer to string.
- * @param endptr If not NULL, pointer to the first invalid character
- *               is stored here.
- * @param base   Zero or number between 2 and 36 inclusive.
- * @param strict Do not allow any trailing characters.
- * @param result Result of the conversion.
- *
- * @return EOK if conversion was successful.
- *
- */
-errno_t str_uint32_t(const char *nptr, const char **endptr, unsigned int base,
-    bool strict, uint32_t *result)
-{
-        assert(result != NULL);
-
-        bool neg;
-        char *lendptr;
-        uint64_t res;
-        errno_t ret = str_uint(nptr, &lendptr, base, &neg, &res);
-
-        if (endptr != NULL)
-                *endptr = (char *) lendptr;
-
-        if (ret != EOK)
-                return ret;
-
-        /* Do not allow negative values */
-        if (neg)
-                return EINVAL;
-
-        /*
-         * Check whether we are at the end of
-         * the string in strict mode
-         */
-        if ((strict) && (*lendptr != 0))
-                return EINVAL;
-
-        /* Check for overflow */
-        uint32_t _res = (uint32_t) res;
-        if (_res != res)
-                return EOVERFLOW;
-
-        *result = _res;
-
-        return EOK;
-}
-
-/** Convert string to uint64_t.
- *
- * @param nptr   Pointer to string.
- * @param endptr If not NULL, pointer to the first invalid character
- *               is stored here.
- * @param base   Zero or number between 2 and 36 inclusive.
- * @param strict Do not allow any trailing characters.
- * @param result Result of the conversion.
- *
- * @return EOK if conversion was successful.
- *
- */
-errno_t str_uint64_t(const char *nptr, const char **endptr, unsigned int base,
-    bool strict, uint64_t *result)
-{
-        assert(result != NULL);
-
-        bool neg;
-        char *lendptr;
-        errno_t ret = str_uint(nptr, &lendptr, base, &neg, result);
-
-        if (endptr != NULL)
-                *endptr = (char *) lendptr;
-
-        if (ret != EOK)
-                return ret;
-
-        /* Do not allow negative values */
-        if (neg)
-                return EINVAL;
-
-        /*
-         * Check whether we are at the end of
-         * the string in strict mode
-         */
-        if ((strict) && (*lendptr != 0))
-                return EINVAL;
-
-        return EOK;
-}
-
-/** Convert string to int64_t.
- *
- * @param nptr   Pointer to string.
- * @param endptr If not NULL, pointer to the first invalid character
- *               is stored here.
- * @param base   Zero or number between 2 and 36 inclusive.
- * @param strict Do not allow any trailing characters.
- * @param result Result of the conversion.
- *
- * @return EOK if conversion was successful.
- *
- */
-int str_int64_t(const char *nptr, const char **endptr, unsigned int base,
-    bool strict, int64_t *result)
-{
-        assert(result != NULL);
-
-        bool neg;
-        char *lendptr;
-        uint64_t unsigned_result;
-        int ret = str_uint(nptr, &lendptr, base, &neg, &unsigned_result);
-
-        if (endptr != NULL)
-                *endptr = (char *) lendptr;
-
-        if (ret != EOK)
-                return ret;
-
-        /* Do not allow negative values */
-        if (neg) {
-                if (unsigned_result == UINT64_MAX)
-                        return EINVAL;
-
-                *result = -(int64_t) unsigned_result;
-        } else
-                *result = unsigned_result;
-
-        /*
-         * Check whether we are at the end of
-         * the string in strict mode
-         */
-        if ((strict) && (*lendptr != 0))
-                return EINVAL;
-
-        return EOK;
-}
-
-/** Convert string to size_t.
- *
- * @param nptr   Pointer to string.
- * @param endptr If not NULL, pointer to the first invalid character
- *               is stored here.
- * @param base   Zero or number between 2 and 36 inclusive.
- * @param strict Do not allow any trailing characters.
- * @param result Result of the conversion.
- *
- * @return EOK if conversion was successful.
- *
- */
-errno_t str_size_t(const char *nptr, const char **endptr, unsigned int base,
-    bool strict, size_t *result)
-{
-        assert(result != NULL);
-
-        bool neg;
-        char *lendptr;
-        uint64_t res;
-        errno_t ret = str_uint(nptr, &lendptr, base, &neg, &res);
-
-        if (endptr != NULL)
-                *endptr = (char *) lendptr;
-
-        if (ret != EOK)
-                return ret;
-
-        /* Do not allow negative values */
-        if (neg)
-                return EINVAL;
-
-        /*
-         * Check whether we are at the end of
-         * the string in strict mode
-         */
-        if ((strict) && (*lendptr != 0))
-                return EINVAL;
-
-        /* Check for overflow */
-        size_t _res = (size_t) res;
-        if (_res != res)
-                return EOVERFLOW;
-
-        *result = _res;
-
-        return EOK;
 }
 

uspace/lib/c/generic/strtol.c

@@ -44 +44 @@
 #include <stdbool.h>
 #include <stdlib.h>
-
-// TODO: unit tests
+#include <str.h>
+
+// FIXME: The original HelenOS functions return EOVERFLOW instead
+//        of ERANGE. It's a pointless distinction from standard functions,
+//        so we should change that. Beware the callers though.
+
+// TODO: more unit tests
 
 static inline int _digit_value(int c)
@@ -69 +74 @@
 }
 
+static inline int _prefixbase(const char *restrict *nptrptr, bool nonstd)
+{
+        const char *nptr = *nptrptr;
+
+        if (nptr[0] != '0')
+                return 10;
+
+        if (nptr[1] == 'x' || nptr[1] == 'X') {
+                if (_digit_value(nptr[2]) < 16) {
+                        *nptrptr += 2;
+                        return 16;
+                }
+        }
+
+        if (nonstd) {
+                switch (nptr[1]) {
+                case 'b':
+                case 'B':
+                        if (_digit_value(nptr[2]) < 2) {
+                                *nptrptr += 2;
+                                return 2;
+                        }
+                        break;
+                case 'o':
+                case 'O':
+                        if (_digit_value(nptr[2]) < 8) {
+                                *nptrptr += 2;
+                                return 8;
+                        }
+                        break;
+                case 'd':
+                case 'D':
+                case 't':
+                case 'T':
+                        if (_digit_value(nptr[2]) < 10) {
+                                *nptrptr += 2;
+                                return 10;
+                        }
+                        break;
+                }
+        }
+
+        return 8;
+}
+
 static inline uintmax_t _strtoumax(
     const char *restrict nptr, char **restrict endptr, int base,
-    bool *restrict sgn)
+    bool *restrict sgn, errno_t *err, bool nonstd)
 {
         assert(nptr != NULL);
         assert(sgn != NULL);
+
+        const char *first = nptr;
 
         /* Skip leading whitespace. */
@@ -96 +148 @@
         /* Figure out the base. */
 
-        if (base == 0) {
-                if (*nptr == '0') {
-                        if (tolower(nptr[1]) == 'x') {
-                                /* 0x... is hex. */
-                                base = 16;
-                                nptr += 2;
-                        } else {
-                                /* 0... is octal. */
-                                base = 8;
-                        }
-                } else {
-                        /* Anything else is decimal by default. */
-                        base = 10;
-                }
-        } else if (base == 16) {
-                /* Allow hex number to be prefixed with "0x". */
-                if (nptr[0] == '0' && tolower(nptr[1]) == 'x') {
+        if (base == 0)
+                base = _prefixbase(&nptr, nonstd);
+
+        if (base == 16 && !nonstd) {
+                /*
+                 * Standard strto* functions allow hexadecimal prefix to be
+                 * present when base is explicitly set to 16.
+                 * Our nonstandard str_* functions don't allow it.
+                 * I don't know if that is intended, just matching the original
+                 * functionality here.
+                 */
+
+                if (nptr[0] == '0' && (nptr[1] == 'x' || nptr[1] == 'X') &&
+                    _digit_value(nptr[2]) < base)
                         nptr += 2;
-                }
-        } else if (base < 0 || base == 1 || base > 36) {
-                errno = EINVAL;
+        }
+
+        if (base < 2 || base > 36) {
+                *err = EINVAL;
                 return 0;
         }
 
-        /* Read the value. */
+        /* Must be at least one digit. */
+
+        if (_digit_value(*nptr) >= base) {
+                /* No digits on input. */
+                if (endptr != NULL)
+                        *endptr = (char *) first;
+                return 0;
+        }
+
+        /* Read the value.  */
 
         uintmax_t result = 0;
@@ -127 +186 @@
 
         while (digit = _digit_value(*nptr), digit < base) {
-
                 if (result > max ||
                     __builtin_add_overflow(result * base, digit, &result)) {
 
-                        errno = ERANGE;
+                        *err = nonstd ? EOVERFLOW : ERANGE;
                         result = UINTMAX_MAX;
                         break;
@@ -145 +203 @@
                  * Move the pointer to the end of the number,
                  * in case it isn't there already.
+                 * This can happen when the number has legal formatting,
+                 * but is out of range of the target type.
                  */
                 while (_digit_value(*nptr) < base) {
@@ -157 +217 @@
 
 static inline intmax_t _strtosigned(const char *nptr, char **endptr, int base,
-    intmax_t min, intmax_t max)
+    intmax_t min, intmax_t max, errno_t *err, bool nonstd)
 {
         bool sgn = false;
-        uintmax_t number = _strtoumax(nptr, endptr, base, &sgn);
+        uintmax_t number = _strtoumax(nptr, endptr, base, &sgn, err, nonstd);
 
         if (number > (uintmax_t) max) {
@@ -167 +227 @@
                 }
 
-                errno = ERANGE;
+                *err = nonstd ? EOVERFLOW : ERANGE;
                 return (sgn ? min : max);
         }
@@ -175 +235 @@
 
 static inline uintmax_t _strtounsigned(const char *nptr, char **endptr, int base,
-    uintmax_t max)
+    uintmax_t max, errno_t *err, bool nonstd)
 {
         bool sgn = false;
-        uintmax_t number = _strtoumax(nptr, endptr, base, &sgn);
-
-        if (sgn) {
-                if (number == 0) {
-                        return 0;
-                } else {
-                        errno = ERANGE;
-                        return max;
-                }
+        uintmax_t number = _strtoumax(nptr, endptr, base, &sgn, err, nonstd);
+
+        if (nonstd && sgn) {
+                /* Do not allow negative values */
+                *err = EINVAL;
+                return 0;
         }
 
         if (number > max) {
-                errno = ERANGE;
+                *err = nonstd ? EOVERFLOW : ERANGE;
                 return max;
         }
 
-        return number;
+        return (sgn ? -number : number);
 }
 
@@ -212 +269 @@
 long strtol(const char *nptr, char **endptr, int base)
 {
-        return _strtosigned(nptr, endptr, base, LONG_MIN, LONG_MAX);
+        return _strtosigned(nptr, endptr, base, LONG_MIN, LONG_MAX, &errno, false);
 }
 
@@ -230 +287 @@
 unsigned long strtoul(const char *nptr, char **endptr, int base)
 {
-        return _strtounsigned(nptr, endptr, base, ULONG_MAX);
+        return _strtounsigned(nptr, endptr, base, ULONG_MAX, &errno, false);
 }
 
 long long strtoll(const char *nptr, char **endptr, int base)
 {
-        return _strtosigned(nptr, endptr, base, LLONG_MIN, LLONG_MAX);
+        return _strtosigned(nptr, endptr, base, LLONG_MIN, LLONG_MAX, &errno, false);
 }
 
 unsigned long long strtoull(const char *nptr, char **endptr, int base)
 {
-        return _strtounsigned(nptr, endptr, base, ULLONG_MAX);
+        return _strtounsigned(nptr, endptr, base, ULLONG_MAX, &errno, false);
 }
 
 intmax_t strtoimax(const char *nptr, char **endptr, int base)
 {
-        return _strtosigned(nptr, endptr, base, INTMAX_MIN, INTMAX_MAX);
+        return _strtosigned(nptr, endptr, base, INTMAX_MIN, INTMAX_MAX, &errno, false);
 }
 
 uintmax_t strtoumax(const char *nptr, char **endptr, int base)
 {
-        return _strtounsigned(nptr, endptr, base, UINTMAX_MAX);
+        return _strtounsigned(nptr, endptr, base, UINTMAX_MAX, &errno, false);
 }
 
@@ -268 +325 @@
 }
 
+/** Convert string to uint8_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+errno_t str_uint8_t(const char *nptr, const char **endptr, unsigned int base,
+    bool strict, uint8_t *result)
+{
+        assert(result != NULL);
+
+        errno_t rc = EOK;
+        char *lendptr = (char *) nptr;
+
+        uintmax_t r = _strtounsigned(nptr, &lendptr, base, UINT8_MAX, &rc, true);
+
+        if (endptr)
+                *endptr = lendptr;
+
+        if (rc != EOK)
+                return rc;
+
+        if (strict && *lendptr != '\0')
+                return EINVAL;
+
+        *result = r;
+        return EOK;
+}
+
+/** Convert string to uint16_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+errno_t str_uint16_t(const char *nptr, const char **endptr, unsigned int base,
+    bool strict, uint16_t *result)
+{
+        assert(result != NULL);
+
+        errno_t rc = EOK;
+        char *lendptr = (char *) nptr;
+
+        uintmax_t r = _strtounsigned(nptr, &lendptr, base, UINT16_MAX, &rc, true);
+
+        if (endptr)
+                *endptr = lendptr;
+
+        if (rc != EOK)
+                return rc;
+
+        if (strict && *lendptr != '\0')
+                return EINVAL;
+
+        *result = r;
+        return EOK;
+}
+
+/** Convert string to uint32_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+errno_t str_uint32_t(const char *nptr, const char **endptr, unsigned int base,
+    bool strict, uint32_t *result)
+{
+        assert(result != NULL);
+
+        errno_t rc = EOK;
+        char *lendptr = (char *) nptr;
+
+        uintmax_t r = _strtounsigned(nptr, &lendptr, base, UINT32_MAX, &rc, true);
+
+        if (endptr)
+                *endptr = lendptr;
+
+        if (rc != EOK)
+                return rc;
+
+        if (strict && *lendptr != '\0')
+                return EINVAL;
+
+        *result = r;
+        return EOK;
+}
+
+/** Convert string to uint64_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+errno_t str_uint64_t(const char *nptr, const char **endptr, unsigned int base,
+    bool strict, uint64_t *result)
+{
+        assert(result != NULL);
+
+        errno_t rc = EOK;
+        char *lendptr = (char *) nptr;
+
+        uintmax_t r = _strtounsigned(nptr, &lendptr, base, UINT64_MAX, &rc, true);
+
+        if (endptr)
+                *endptr = lendptr;
+
+        if (rc != EOK)
+                return rc;
+
+        if (strict && *lendptr != '\0')
+                return EINVAL;
+
+        *result = r;
+        return EOK;
+}
+
+/** Convert string to int64_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+errno_t str_int64_t(const char *nptr, const char **endptr, unsigned int base,
+    bool strict, int64_t *result)
+{
+        assert(result != NULL);
+
+        errno_t rc = EOK;
+        char *lendptr = (char *) nptr;
+
+        intmax_t r = _strtosigned(nptr, &lendptr, base, INT64_MIN, INT64_MAX, &rc, true);
+
+        if (endptr)
+                *endptr = lendptr;
+
+        if (rc != EOK)
+                return rc;
+
+        if (strict && *lendptr != '\0')
+                return EINVAL;
+
+        *result = r;
+        return EOK;
+}
+
+/** Convert string to size_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+errno_t str_size_t(const char *nptr, const char **endptr, unsigned int base,
+    bool strict, size_t *result)
+{
+        assert(result != NULL);
+
+        errno_t rc = EOK;
+        char *lendptr = (char *) nptr;
+
+        uintmax_t r = _strtounsigned(nptr, &lendptr, base, SIZE_MAX, &rc, true);
+
+        if (endptr)
+                *endptr = lendptr;
+
+        if (rc != EOK)
+                return rc;
+
+        if (strict && *lendptr != '\0')
+                return EINVAL;
+
+        *result = r;
+        return EOK;
+}
+
 /** @}
  */

uspace/lib/c/generic/ubsan.c

@@ -35 +35 @@
 };
 
+struct type_mismatch_data_v1 {
+        struct source_location loc;
+        struct type_descriptor *type;
+        unsigned char log_alignment;
+        unsigned char type_check_kind;
+};
+
 struct overflow_data {
         struct source_location loc;
@@ -73 +80 @@
         struct source_location loc;
         struct source_location attr_loc;
+};
+
+struct pointer_overflow_data {
+        struct source_location loc;
 };
 
@@ -81 +92 @@
  */
 void __ubsan_handle_type_mismatch(struct type_mismatch_data *data, unsigned long ptr);
+void __ubsan_handle_type_mismatch_v1(struct type_mismatch_data_v1 *data, unsigned long ptr);
 void __ubsan_handle_add_overflow(struct overflow_data *data, unsigned long lhs, unsigned long rhs);
 void __ubsan_handle_sub_overflow(struct overflow_data *data, unsigned long lhs, unsigned long rhs);
@@ -99 +111 @@
 void __ubsan_handle_nonnull_return(struct nonnull_return_data *data);
 void __ubsan_handle_builtin_unreachable(struct unreachable_data *data);
+void __ubsan_handle_pointer_overflow(struct pointer_overflow_data *data,
+    unsigned long base, unsigned long result);
 
 static void print_loc(const char *func, struct source_location *loc)
@@ -121 +135 @@
 }
 
+void __ubsan_handle_type_mismatch_v1(struct type_mismatch_data_v1 *data,
+    unsigned long ptr)
+{
+        print_loc(__func__, &data->loc);
+        PRINTF("Type: %s, alignment: %hhu, type_check_kind: %hhu\n",
+            data->type->type_name, data->log_alignment, data->type_check_kind);
+        ubsan_panic();
+}
+
 void __ubsan_handle_add_overflow(struct overflow_data *data,
     unsigned long lhs,
@@ -228 +251 @@
         ubsan_panic();
 }
+
+void __ubsan_handle_pointer_overflow(struct pointer_overflow_data *data,
+    unsigned long base, unsigned long result)
+{
+        print_loc(__func__, &data->loc);
+        ubsan_panic();
+}