Changeset 89ac5513 in mainline for uspace/lib/c/generic


Ignore:
Timestamp:
2013-06-23T19:54:53Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
ddb1922
Parents:
3abf0760 (diff), 96cbd18 (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.
Message:

Merge mainline changes.

Location:
uspace/lib/c/generic
Files:
2 added
11 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/device/hw_res_parsed.c

    r3abf0760 r89ac5513  
    188188        hw_resource_list_t hw_resources;
    189189        hw_res_list_parsed_clean(hw_res_parsed);
    190         bzero(&hw_resources, sizeof(hw_resource_list_t));
     190        memset(&hw_resources, 0, sizeof(hw_resource_list_t));
    191191       
    192192        int rc = hw_res_get_resource_list(sess, &hw_resources);

  • uspace/lib/c/generic/inet.c

    r3abf0760 r89ac5513  
    107107int inet_send(inet_dgram_t *dgram, uint8_t ttl, inet_df_t df)
    108108{
    109         async_exch_t *exch = async_exchange_begin(inet_sess);
    110 
     109        uint32_t src;
     110        int rc = inet_addr_pack(&dgram->src, &src);
     111        if (rc != EOK)
     112                return rc;
     113       
     114        uint32_t dest;
     115        rc = inet_addr_pack(&dgram->dest, &dest);
     116        if (rc != EOK)
     117                return EOK;
     118       
     119        async_exch_t *exch = async_exchange_begin(inet_sess);
     120       
    111121        ipc_call_t answer;
    112         aid_t req = async_send_5(exch, INET_SEND, dgram->src.ipv4,
    113             dgram->dest.ipv4, dgram->tos, ttl, df, &answer);
    114         int rc = async_data_write_start(exch, dgram->data, dgram->size);
    115         async_exchange_end(exch);
    116 
     122        aid_t req = async_send_5(exch, INET_SEND, (sysarg_t) src,
     123            (sysarg_t) dest, dgram->tos, ttl, df, &answer);
     124        rc = async_data_write_start(exch, dgram->data, dgram->size);
     125       
     126        async_exchange_end(exch);
     127       
    117128        if (rc != EOK) {
    118129                async_forget(req);
    119130                return rc;
    120131        }
    121 
     132       
    122133        sysarg_t retval;
    123134        async_wait_for(req, &retval);
    124135        if (retval != EOK)
    125136                return retval;
    126 
     137       
    127138        return EOK;
    128139}
    … …  
    130141int inet_get_srcaddr(inet_addr_t *remote, uint8_t tos, inet_addr_t *local)
    131142{
     143        uint32_t remote_addr;
     144        int rc = inet_addr_pack(remote, &remote_addr);
     145        if (rc != EOK)
     146                return rc;
     147       
     148        async_exch_t *exch = async_exchange_begin(inet_sess);
     149       
    132150        sysarg_t local_addr;
    133         async_exch_t *exch = async_exchange_begin(inet_sess);
    134 
    135         int rc = async_req_2_1(exch, INET_GET_SRCADDR, remote->ipv4,
     151        rc = async_req_2_1(exch, INET_GET_SRCADDR, (sysarg_t) remote_addr,
    136152            tos, &local_addr);
    137         async_exchange_end(exch);
    138 
    139         if (rc != EOK)
    140                 return rc;
    141 
    142         local->ipv4 = local_addr;
     153       
     154        async_exchange_end(exch);
     155       
     156        if (rc != EOK)
     157                return rc;
     158       
     159        inet_addr_unpack(local_addr, local);
    143160        return EOK;
    144161}
    … …  
    148165        int rc;
    149166        inet_dgram_t dgram;
    150 
    151         dgram.src.ipv4 = IPC_GET_ARG1(*call);
    152         dgram.dest.ipv4 = IPC_GET_ARG2(*call);
     167       
     168        inet_addr_unpack(IPC_GET_ARG1(*call), &dgram.src);
     169        inet_addr_unpack(IPC_GET_ARG2(*call), &dgram.dest);
    153170        dgram.tos = IPC_GET_ARG3(*call);
    154171

  • uspace/lib/c/generic/inetcfg.c

    r3abf0760 r89ac5513  
    136136    sysarg_t link_id, sysarg_t *addr_id)
    137137{
    138         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    139 
    140         ipc_call_t answer;
    141         aid_t req = async_send_3(exch, INETCFG_ADDR_CREATE_STATIC, naddr->ipv4,
    142             naddr->bits, link_id, &answer);
     138        uint32_t naddr_addr;
     139        uint8_t naddr_bits;
     140        int rc = inet_naddr_pack(naddr, &naddr_addr, &naddr_bits);
     141        if (rc != EOK)
     142                return rc;
     143       
     144        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     145       
     146        ipc_call_t answer;
     147        aid_t req = async_send_3(exch, INETCFG_ADDR_CREATE_STATIC,
     148            (sysarg_t) naddr_addr, (sysarg_t) naddr_bits, link_id, &answer);
    143149        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
    144 
    145         async_exchange_end(exch);
    146 
    147         if (retval != EOK) {
    148                 async_forget(req);
    149                 return retval;
    150         }
    151 
     150       
     151        async_exchange_end(exch);
     152       
     153        if (retval != EOK) {
     154                async_forget(req);
     155                return retval;
     156        }
     157       
    152158        async_wait_for(req, &retval);
    153159        *addr_id = IPC_GET_ARG1(answer);
    154 
     160       
    155161        return retval;
    156162}
    … …  
    196202        assert(act_size <= LOC_NAME_MAXLEN);
    197203        name_buf[act_size] = '\0';
    198 
    199         ainfo->naddr.ipv4 = IPC_GET_ARG1(answer);
    200         ainfo->naddr.bits = IPC_GET_ARG2(answer);
     204       
     205        inet_naddr_unpack(IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
     206            &ainfo->naddr);
    201207        ainfo->ilink = IPC_GET_ARG3(answer);
    202208        ainfo->name = str_dup(name_buf);
    … …  
    284290    inet_addr_t *router, sysarg_t *sroute_id)
    285291{
    286         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    287 
     292        uint32_t dest_addr;
     293        uint8_t dest_bits;
     294        int rc = inet_naddr_pack(dest, &dest_addr, &dest_bits);
     295        if (rc != EOK)
     296                return rc;
     297       
     298        uint32_t router_addr;
     299        rc = inet_addr_pack(router, &router_addr);
     300        if (rc != EOK)
     301                return rc;
     302       
     303        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     304       
    288305        ipc_call_t answer;
    289306        aid_t req = async_send_3(exch, INETCFG_SROUTE_CREATE,
    290             dest->ipv4, dest->bits, router->ipv4, &answer);
     307            (sysarg_t) dest_addr, (sysarg_t) dest_bits, (sysarg_t) router_addr,
     308            &answer);
    291309        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
    292 
    293         async_exchange_end(exch);
    294 
    295         if (retval != EOK) {
    296                 async_forget(req);
    297                 return retval;
    298         }
    299 
     310       
     311        async_exchange_end(exch);
     312       
     313        if (retval != EOK) {
     314                async_forget(req);
     315                return retval;
     316        }
     317       
    300318        async_wait_for(req, &retval);
    301319        *sroute_id = IPC_GET_ARG1(answer);
    302 
     320       
    303321        return retval;
    304322}
    … …  
    345363        name_buf[act_size] = '\0';
    346364
    347         srinfo->dest.ipv4 = IPC_GET_ARG1(answer);
    348         srinfo->dest.bits = IPC_GET_ARG2(answer);
    349         srinfo->router.ipv4 = IPC_GET_ARG3(answer);
     365        inet_naddr_unpack(IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
     366            &srinfo->dest);
     367        inet_addr_unpack(IPC_GET_ARG3(answer), &srinfo->router);
    350368        srinfo->name = str_dup(name_buf);
    351369

  • uspace/lib/c/generic/inetping.c

    r3abf0760 r89ac5513  
    7979{
    8080        async_exch_t *exch = async_exchange_begin(inetping_sess);
    81 
     81       
    8282        ipc_call_t answer;
    83         aid_t req = async_send_3(exch, INETPING_SEND, sdu->src.ipv4,
    84             sdu->dest.ipv4, sdu->seq_no, &answer);
     83        aid_t req = async_send_3(exch, INETPING_SEND, (sysarg_t) sdu->src,
     84            (sysarg_t) sdu->dest, sdu->seq_no, &answer);
    8585        sysarg_t retval = async_data_write_start(exch, sdu->data, sdu->size);
    86 
     86       
    8787        async_exchange_end(exch);
    88 
     88       
    8989        if (retval != EOK) {
    9090                async_forget(req);
    9191                return retval;
    9292        }
    93 
     93       
    9494        async_wait_for(req, &retval);
    9595        return retval;
    9696}
    9797
    98 int inetping_get_srcaddr(inet_addr_t *remote, inet_addr_t *local)
     98int inetping_get_srcaddr(uint32_t remote, uint32_t *local)
    9999{
     100        async_exch_t *exch = async_exchange_begin(inetping_sess);
     101       
    100102        sysarg_t local_addr;
    101         async_exch_t *exch = async_exchange_begin(inetping_sess);
    102 
    103         int rc = async_req_1_1(exch, INETPING_GET_SRCADDR, remote->ipv4,
     103        int rc = async_req_1_1(exch, INETPING_GET_SRCADDR, (sysarg_t) remote,
    104104            &local_addr);
     105       
    105106        async_exchange_end(exch);
    106 
     107       
    107108        if (rc != EOK)
    108109                return rc;
    109 
    110         local->ipv4 = local_addr;
     110       
     111        *local = (uint32_t) local_addr;
    111112        return EOK;
    112113}
    … …  
    114115static void inetping_ev_recv(ipc_callid_t callid, ipc_call_t *call)
    115116{
    116         int rc;
    117117        inetping_sdu_t sdu;
    118 
    119         sdu.src.ipv4 = IPC_GET_ARG1(*call);
    120         sdu.dest.ipv4 = IPC_GET_ARG2(*call);
     118       
     119        sdu.src = IPC_GET_ARG1(*call);
     120        sdu.dest = IPC_GET_ARG2(*call);
    121121        sdu.seq_no = IPC_GET_ARG3(*call);
    122 
    123         rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     122       
     123        int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
    124124        if (rc != EOK) {
    125125                async_answer_0(callid, rc);
    126126                return;
    127127        }
    128 
     128       
    129129        rc = inetping_ev_ops->recv(&sdu);
    130130        free(sdu.data);

  • uspace/lib/c/generic/iplink.c

    r3abf0760 r89ac5513  
    3939#include <errno.h>
    4040#include <inet/iplink.h>
     41#include <inet/addr.h>
    4142#include <ipc/iplink.h>
    4243#include <ipc/services.h>
    … …  
    8384{
    8485        async_exch_t *exch = async_exchange_begin(iplink->sess);
    85 
     86       
    8687        ipc_call_t answer;
    87         aid_t req = async_send_2(exch, IPLINK_SEND, sdu->lsrc.ipv4,
    88             sdu->ldest.ipv4, &answer);
     88        aid_t req = async_send_2(exch, IPLINK_SEND, (sysarg_t) sdu->lsrc,
     89            (sysarg_t) sdu->ldest, &answer);
    8990        int rc = async_data_write_start(exch, sdu->data, sdu->size);
     91       
    9092        async_exchange_end(exch);
    91 
     93       
    9294        if (rc != EOK) {
    9395                async_forget(req);
    9496                return rc;
    9597        }
    96 
     98       
    9799        sysarg_t retval;
    98100        async_wait_for(req, &retval);
    99101        if (retval != EOK)
    100102                return retval;
    101 
     103       
    102104        return EOK;
    103105}
    … …  
    118120}
    119121
    120 int iplink_addr_add(iplink_t *iplink, iplink_addr_t *addr)
     122int iplink_addr_add(iplink_t *iplink, inet_addr_t *addr)
    121123{
     124        uint32_t addr_addr;
     125        int rc = inet_addr_pack(addr, &addr_addr);
     126        if (rc != EOK)
     127                return rc;
     128       
    122129        async_exch_t *exch = async_exchange_begin(iplink->sess);
    123 
    124         int rc = async_req_1_0(exch, IPLINK_ADDR_ADD, (sysarg_t)addr->ipv4);
     130        rc = async_req_1_0(exch, IPLINK_ADDR_ADD, (sysarg_t) addr_addr);
    125131        async_exchange_end(exch);
    126 
     132       
    127133        return rc;
    128134}
    129135
    130 int iplink_addr_remove(iplink_t *iplink, iplink_addr_t *addr)
     136int iplink_addr_remove(iplink_t *iplink, inet_addr_t *addr)
    131137{
     138        uint32_t addr_addr;
     139        int rc = inet_addr_pack(addr, &addr_addr);
     140        if (rc != EOK)
     141                return rc;
     142       
    132143        async_exch_t *exch = async_exchange_begin(iplink->sess);
    133 
    134         int rc = async_req_1_0(exch, IPLINK_ADDR_REMOVE, (sysarg_t)addr->ipv4);
     144        rc = async_req_1_0(exch, IPLINK_ADDR_REMOVE, (sysarg_t) addr_addr);
    135145        async_exchange_end(exch);
    136 
     146       
    137147        return rc;
    138148}
    … …  
    141151    ipc_call_t *call)
    142152{
    143         int rc;
    144153        iplink_sdu_t sdu;
    145 
    146         sdu.lsrc.ipv4 = IPC_GET_ARG1(*call);
    147         sdu.ldest.ipv4 = IPC_GET_ARG2(*call);
    148 
    149         rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     154       
     155        sdu.lsrc = IPC_GET_ARG1(*call);
     156        sdu.ldest = IPC_GET_ARG2(*call);
     157       
     158        int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
    150159        if (rc != EOK) {
    151160                async_answer_0(callid, rc);
    152161                return;
    153162        }
    154 
     163       
    155164        rc = iplink->ev_ops->recv(iplink, &sdu);
    156165        free(sdu.data);

  • uspace/lib/c/generic/iplink_srv.c

    r3abf0760 r89ac5513  
    5454    ipc_call_t *call)
    5555{
    56         int rc;
    57         iplink_srv_addr_t addr;
    58 
    59         addr.ipv4 = IPC_GET_ARG1(*call);
    60 
    61         rc = srv->ops->addr_add(srv, &addr);
     56        int rc = srv->ops->addr_add(srv, IPC_GET_ARG1(*call));
    6257        async_answer_0(callid, rc);
    6358}
    … …  
    6661    ipc_call_t *call)
    6762{
    68         int rc;
    69         iplink_srv_addr_t addr;
    70 
    71         addr.ipv4 = IPC_GET_ARG1(*call);
    72 
    73         rc = srv->ops->addr_remove(srv, &addr);
     63        int rc = srv->ops->addr_remove(srv, IPC_GET_ARG1(*call));
    7464        async_answer_0(callid, rc);
    7565}
    … …  
    8171        int rc;
    8272
    83         sdu.lsrc.ipv4 = IPC_GET_ARG1(*call);
    84         sdu.ldest.ipv4 = IPC_GET_ARG2(*call);
     73        sdu.lsrc = IPC_GET_ARG1(*call);
     74        sdu.ldest = IPC_GET_ARG2(*call);
    8575
    8676        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
    … …  
    139129                if (!method) {
    140130                        /* The other side has hung up */
    141                         fibril_mutex_lock(&srv->lock);
     131                        fibril_mutex_lock(&srv->lock);
    142132                        srv->connected = false;
    143                         fibril_mutex_unlock(&srv->lock);
     133                        fibril_mutex_unlock(&srv->lock);
    144134                        async_answer_0(callid, EOK);
    145135                        break;
    … …  
    175165
    176166        ipc_call_t answer;
    177         aid_t req = async_send_2(exch, IPLINK_EV_RECV, sdu->lsrc.ipv4,
    178             sdu->ldest.ipv4, &answer);
     167        aid_t req = async_send_2(exch, IPLINK_EV_RECV, (sysarg_t) sdu->lsrc,
     168            (sysarg_t) sdu->ldest, &answer);
    179169        int rc = async_data_write_start(exch, sdu->data, sdu->size);
    180170        async_exchange_end(exch);

  • uspace/lib/c/generic/mem.c

    r3abf0760 r89ac5513  
    224224 * @param s1  Pointer to the first area to compare.
    225225 * @param s2  Pointer to the second area to compare.
    226  * @param len Size of the first area in bytes. Both areas must have
    227  *            the same length.
    228  *
    229  * @return If len is 0, return zero. If the areas match, return
    230  *         zero. Otherwise return non-zero.
    231  *
    232  */
    233 int bcmp(const void *s1, const void *s2, size_t len)
     226 * @param len Size of the areas in bytes.
     227 *
     228 * @return Zero if areas have the same contents. If they differ,
     229 *         the sign of the result is the same as the sign of the
     230 *         difference of the first pair of different bytes.
     231 *
     232 */
     233int memcmp(const void *s1, const void *s2, size_t len)
    234234{
    235235        uint8_t *u1 = (uint8_t *) s1;
    236236        uint8_t *u2 = (uint8_t *) s2;
    237        
    238         for (; (len != 0) && (*u1++ == *u2++); len--);
    239        
    240         return len;
     237        size_t i;
     238
     239        for (i = 0; i < len; i++) {
     240                if (*u1 != *u2)
     241                        return (int)(*u1) - (int)(*u2);
     242                ++u1;
     243                ++u2;
     244        }
     245
     246        return 0;
    241247}
    242248

  • uspace/lib/c/generic/net/inet.c

    r3abf0760 r89ac5513  
    3939#include <net/in6.h>
    4040#include <net/inet.h>
    41 
     41#include <inet/addr.h>
    4242#include <errno.h>
    4343#include <mem.h>
    … …  
    9494}
    9595
     96static int inet_pton4(const char *address, uint8_t *data)
     97{
     98        memset(data, 0, 4);
     99       
     100        const char *cur = address;
     101        size_t i = 0;
     102       
     103        while (i < 4) {
     104                int rc = str_uint8_t(cur, &cur, 10, false, &data[i]);
     105                if (rc != EOK)
     106                        return rc;
     107               
     108                i++;
     109               
     110                if (*cur == 0)
     111                        break;
     112               
     113                if (*cur != '.')
     114                        return EINVAL;
     115               
     116                if (i < 4)
     117                        cur++;
     118        }
     119       
     120        if ((i == 4) && (*cur != 0))
     121                return EINVAL;
     122       
     123        return EOK;
     124}
     125
     126static int inet_pton6(const char *address, uint8_t *data)
     127{
     128        // FIXME TODO
     129        return ENOTSUP;
     130}
     131
    96132/** Parses the character string into the address.
    97133 *
    98  *  If the string is shorter than the full address, zero bytes are added.
     134 * @param[in]  family  The address family.
     135 * @param[in]  address The character buffer to be parsed.
     136 * @param[out] data    The address data to be filled.
    99137 *
    100  *  @param[in] family   The address family.
    101  *  @param[in] address  The character buffer to be parsed.
    102  *  @param[out] data    The address data to be filled.
    103  *  @return             EOK on success.
    104  *  @return             EINVAL if the data parameter is NULL.
    105  *  @return             ENOENT if the address parameter is NULL.
    106  *  @return             ENOTSUP if the address family is not supported.
     138 * @return EOK on success.
     139 * @return EINVAL if the data parameter is NULL.
     140 * @return ENOENT if the address parameter is NULL.
     141 * @return ENOTSUP if the address family is not supported.
     142 *
    107143 */
    108144int inet_pton(uint16_t family, const char *address, uint8_t *data)
    109145{
    110         /** The base number of the values. */
    111         int base;
    112         /** The number of bytes per a section. */
    113         size_t bytes;
    114         /** The number of bytes of the address data. */
    115         int count;
    116 
    117         const char *next;
    118         char *last;
    119         int index;
    120         size_t shift;
    121         unsigned long value;
    122 
    123         if (!data)
    124                 return EINVAL;
    125 
    126         /* Set processing parameters */
    127146        switch (family) {
    128147        case AF_INET:
    129                 count = 4;
    130                 base = 10;
    131                 bytes = 1;
    132                 break;
    133 
     148                return inet_pton4(address, data);
    134149        case AF_INET6:
    135                 count = 16;
    136                 base = 16;
    137                 bytes = 4;
    138                 break;
    139 
     150                return inet_pton6(address, data);
    140151        default:
     152                /** Unknown address family */
    141153                return ENOTSUP;
    142154        }
    143 
    144         /* Erase if no address */
    145         if (!address) {
    146                 bzero(data, count);
    147                 return ENOENT;
    148         }
    149 
    150         /* Process string from the beginning */
    151         next = address;
    152         index = 0;
    153         do {
    154                 /* If the actual character is set */
    155                 if (next && *next) {
    156 
    157                         /* If not on the first character */
    158                         if (index) {
    159                                 /* Move to the next character */
    160                                 ++next;
    161                         }
    162 
    163                         /* Parse the actual integral value */
    164                         value = strtoul(next, &last, base);
    165                         /*
    166                          * Remember the last problematic character
    167                          * should be either '.' or ':' but is ignored to be
    168                          * more generic
    169                          */
    170                         next = last;
    171 
    172                         /* Fill the address data byte by byte */
    173                         shift = bytes - 1;
    174                         do {
    175                                 /* like little endian */
    176                                 data[index + shift] = value;
    177                                 value >>= 8;
    178                         } while(shift --);
    179 
    180                         index += bytes;
    181                 } else {
    182                         /* Erase the rest of the address */
    183                         bzero(data + index, count - index);
    184                         return EOK;
    185                 }
    186         } while (index < count);
    187 
    188         return EOK;
    189155}
    190156

  • uspace/lib/c/generic/net/socket_client.c

    r3abf0760 r89ac5513  
    8787        /** Parent module service. */
    8888        services_t service;
     89        /** Socket family */
     90        int family;
    8991
    9092        /**
    … …  
    395397        switch (domain) {
    396398        case PF_INET:
     399        case PF_INET6:
    397400                switch (type) {
    398401                case SOCK_STREAM:
    … …  
    433436                break;
    434437
    435         case PF_INET6:
    436438        default:
    437439                return EPFNOSUPPORT;
    … …  
    446448                return ENOMEM;
    447449
    448         bzero(socket, sizeof(*socket));
     450        memset(socket, 0, sizeof(*socket));
     451        socket->family = domain;
    449452        fibril_rwlock_write_lock(&socket_globals.lock);
    450453
    … …  
    657660                return ENOMEM;
    658661        }
    659         bzero(new_socket, sizeof(*new_socket));
     662        memset(new_socket, 0, sizeof(*new_socket));
    660663        socket_id = socket_generate_new_id();
    661664        if (socket_id <= 0) {

  • uspace/lib/c/generic/net/socket_parse.c

    r3abf0760 r89ac5513  
    7979int socket_parse_protocol_family(const char *name, int *pf)
    8080{
     81        if (str_lcmp(name, "PF_INET6", 8) == 0) {
     82                *pf = PF_INET6;
     83                return EOK;
     84        }
     85
    8186        if (str_lcmp(name, "PF_INET", 7) == 0) {
    8287                *pf = PF_INET;
    83                 return EOK;
    84         }
    85        
    86         if (str_lcmp(name, "PF_INET6", 8) == 0) {
    87                 *pf = PF_INET6;
    8888                return EOK;
    8989        }

  • uspace/lib/c/generic/str.c

    r3abf0760 r89ac5513  
    15241524 *
    15251525 */
    1526 int str_uint8_t(const char *nptr, char **endptr, unsigned int base,
     1526int str_uint8_t(const char *nptr, const char **endptr, unsigned int base,
    15271527    bool strict, uint8_t *result)
    15281528{
    … …  
    15711571 *
    15721572 */
    1573 int str_uint16_t(const char *nptr, char **endptr, unsigned int base,
     1573int str_uint16_t(const char *nptr, const char **endptr, unsigned int base,
    15741574    bool strict, uint16_t *result)
    15751575{
    … …  
    16181618 *
    16191619 */
    1620 int str_uint32_t(const char *nptr, char **endptr, unsigned int base,
     1620int str_uint32_t(const char *nptr, const char **endptr, unsigned int base,
    16211621    bool strict, uint32_t *result)
    16221622{
    … …  
    16651665 *
    16661666 */
    1667 int str_uint64_t(const char *nptr, char **endptr, unsigned int base,
     1667int str_uint64_t(const char *nptr, const char **endptr, unsigned int base,
    16681668    bool strict, uint64_t *result)
    16691669{
    … …  
    17041704 *
    17051705 */
    1706 int str_size_t(const char *nptr, char **endptr, unsigned int base,
     1706int str_size_t(const char *nptr, const char **endptr, unsigned int base,
    17071707    bool strict, size_t *result)
    17081708{
Note: See TracChangeset for help on using the changeset viewer.