Changeset b7fd2a0 in mainline for uspace/lib/http/src


Ignore:
Timestamp:
2018-01-13T03:10:29Z (8 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a53ed3a
Parents:
36f0738
Message:

Use errno_t in all uspace and kernel code.

Change type of every variable, parameter and return value that holds an
<errno.h> constant to either errno_t (the usual case), or sys_errno_t
(some places in kernel). This is for the purpose of self-documentation,
as well as for type-checking with a bit of type definition hackery.

Although this is a massive commit, it is a simple text replacement, and thus
is very easy to verify. Simply do the following:

`
git checkout <this commit's hash>
git reset HEAD
git add .
tools/srepl '\berrno_t\b' int
git add .
tools/srepl '\bsys_errno_t\b' sysarg_t
git reset
git diff
`

While this doesn't ensure that the replacements are correct, it does ensure
that the commit doesn't do anything except those replacements. Since errno_t
is typedef'd to int in the usual case (and sys_errno_t to sysarg_t), even if
incorrect, this commit cannot change behavior.

Location:
uspace/lib/http/src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/http/src/headers.c

    r36f0738 rb7fd2a0  
    9494}
    9595
    96 int http_header_receive_name(receive_buffer_t *rb,
     96errno_t http_header_receive_name(receive_buffer_t *rb,
    9797    receive_buffer_mark_t *name_end)
    9898{
     
    102102                        recv_mark_update(rb, name_end);
    103103               
    104                 int rc = recv_char(rb, &c, true);
     104                errno_t rc = recv_char(rb, &c, true);
    105105                if (rc != EOK)
    106106                        return rc;
     
    113113}
    114114
    115 int http_header_receive_value(receive_buffer_t *rb,
     115errno_t http_header_receive_value(receive_buffer_t *rb,
    116116    receive_buffer_mark_t *value_start, receive_buffer_mark_t *value_end)
    117117{
    118         int rc = EOK;
     118        errno_t rc = EOK;
    119119        char c = 0;
    120120       
     
    167167}
    168168
    169 int http_header_receive(receive_buffer_t *rb, http_header_t *header,
     169errno_t http_header_receive(receive_buffer_t *rb, http_header_t *header,
    170170    size_t size_limit, size_t *out_bytes_used)
    171171{
     
    176176        recv_mark(rb, &mark_end);
    177177       
    178         int rc = http_header_receive_name(rb, &mark_end);
     178        errno_t rc = http_header_receive_name(rb, &mark_end);
    179179        if (rc != EOK)
    180180                goto end;
     
    259259}
    260260
    261 int http_headers_find_single(http_headers_t *headers, const char *name,
     261errno_t http_headers_find_single(http_headers_t *headers, const char *name,
    262262    http_header_t **out_header)
    263263{
     
    282282}
    283283
    284 int http_headers_append(http_headers_t *headers, const char *name,
     284errno_t http_headers_append(http_headers_t *headers, const char *name,
    285285    const char *value)
    286286{
     
    293293}
    294294
    295 int http_headers_set(http_headers_t *headers, const char *name,
     295errno_t http_headers_set(http_headers_t *headers, const char *name,
    296296    const char *value)
    297297{
    298298        http_header_t *header = NULL;
    299         int rc = http_headers_find_single(headers, name, &header);
     299        errno_t rc = http_headers_find_single(headers, name, &header);
    300300        if (rc != EOK && rc != HTTP_EMISSING_HEADER)
    301301                return rc;
     
    313313}
    314314
    315 int http_headers_get(http_headers_t *headers, const char *name, char **value)
     315errno_t http_headers_get(http_headers_t *headers, const char *name, char **value)
    316316{
    317317        http_header_t *header = NULL;
    318         int rc = http_headers_find_single(headers, name, &header);
     318        errno_t rc = http_headers_find_single(headers, name, &header);
    319319        if (rc != EOK)
    320320                return rc;
     
    324324}
    325325
    326 int http_headers_receive(receive_buffer_t *rb, http_headers_t *headers,
     326errno_t http_headers_receive(receive_buffer_t *rb, http_headers_t *headers,
    327327    size_t limit_alloc, unsigned limit_count)
    328328{
    329         int rc = EOK;
     329        errno_t rc = EOK;
    330330        unsigned added = 0;
    331331       
  • uspace/lib/http/src/http.c

    r36f0738 rb7fd2a0  
    4747#include <http/receive-buffer.h>
    4848
    49 static int http_receive(void *client_data, void *buf, size_t buf_size,
     49static errno_t http_receive(void *client_data, void *buf, size_t buf_size,
    5050    size_t *nrecv)
    5151{
     
    6969       
    7070        http->buffer_size = 4096;
    71         int rc = recv_buffer_init(&http->recv_buffer, http->buffer_size,
     71        errno_t rc = recv_buffer_init(&http->recv_buffer, http->buffer_size,
    7272            http_receive, http);
    7373        if (rc != EOK) {
     
    7979}
    8080
    81 int http_connect(http_t *http)
     81errno_t http_connect(http_t *http)
    8282{
    8383        if (http->conn != NULL)
    8484                return EBUSY;
    8585       
    86         int rc = inet_host_plookup_one(http->host, ip_any, &http->addr, NULL,
     86        errno_t rc = inet_host_plookup_one(http->host, ip_any, &http->addr, NULL,
    8787            NULL);
    8888        if (rc != EOK)
     
    110110}
    111111
    112 int http_close(http_t *http)
     112errno_t http_close(http_t *http)
    113113{
    114114        if (http->conn == NULL)
  • uspace/lib/http/src/receive-buffer.c

    r36f0738 rb7fd2a0  
    4343#include <http/receive-buffer.h>
    4444
    45 int recv_buffer_init(receive_buffer_t *rb, size_t buffer_size,
     45errno_t recv_buffer_init(receive_buffer_t *rb, size_t buffer_size,
    4646    receive_func_t receive, void *client_data)
    4747{
     
    6161}
    6262
    63 static int dummy_receive(void *unused, void *buf, size_t buf_size,
     63static errno_t dummy_receive(void *unused, void *buf, size_t buf_size,
    6464    size_t *nrecv)
    6565{
     
    6868}
    6969
    70 int recv_buffer_init_const(receive_buffer_t *rb, void *buf, size_t size)
    71 {
    72         int rc = recv_buffer_init(rb, size, dummy_receive, NULL);
     70errno_t recv_buffer_init_const(receive_buffer_t *rb, void *buf, size_t size)
     71{
     72        errno_t rc = recv_buffer_init(rb, size, dummy_receive, NULL);
    7373        if (rc != EOK)
    7474                return rc;
     
    107107}
    108108
    109 int recv_cut(receive_buffer_t *rb, receive_buffer_mark_t *a, receive_buffer_mark_t *b, void **out_buf, size_t *out_size)
     109errno_t recv_cut(receive_buffer_t *rb, receive_buffer_mark_t *a, receive_buffer_mark_t *b, void **out_buf, size_t *out_size)
    110110{
    111111        if (a->offset > b->offset)
     
    123123}
    124124
    125 int recv_cut_str(receive_buffer_t *rb, receive_buffer_mark_t *a, receive_buffer_mark_t *b, char **out_buf)
     125errno_t recv_cut_str(receive_buffer_t *rb, receive_buffer_mark_t *a, receive_buffer_mark_t *b, char **out_buf)
    126126{
    127127        if (a->offset > b->offset)
     
    147147
    148148/** Receive one character (with buffering) */
    149 int recv_char(receive_buffer_t *rb, char *c, bool consume)
     149errno_t recv_char(receive_buffer_t *rb, char *c, bool consume)
    150150{
    151151        if (rb->out == rb->in) {
     
    170170               
    171171                size_t nrecv;
    172                 int rc = rb->receive(rb->client_data, rb->buffer + rb->in, free, &nrecv);
     172                errno_t rc = rb->receive(rb->client_data, rb->buffer + rb->in, free, &nrecv);
    173173                if (rc != EOK)
    174174                        return rc;
     
    183183}
    184184
    185 int recv_buffer(receive_buffer_t *rb, char *buf, size_t buf_size,
     185errno_t recv_buffer(receive_buffer_t *rb, char *buf, size_t buf_size,
    186186    size_t *nrecv)
    187187{
     
    202202 * @return EOK or an error code
    203203 */
    204 int recv_discard(receive_buffer_t *rb, char discard, size_t *ndisc)
     204errno_t recv_discard(receive_buffer_t *rb, char discard, size_t *ndisc)
    205205{
    206206        char c = 0;
    207         int rc = recv_char(rb, &c, false);
     207        errno_t rc = recv_char(rb, &c, false);
    208208        if (rc != EOK)
    209209                return rc;
     
    223223 * @return EOK or an error code
    224224 */
    225 int recv_discard_str(receive_buffer_t *rb, const char *discard, size_t *ndisc)
     225errno_t recv_discard_str(receive_buffer_t *rb, const char *discard, size_t *ndisc)
    226226{
    227227        size_t discarded = 0;
    228228        while (*discard) {
    229229                size_t nd;
    230                 int rc = recv_discard(rb, *discard, &nd);
     230                errno_t rc = recv_discard(rb, *discard, &nd);
    231231                if (rc != EOK)
    232232                        return rc;
     
    241241}
    242242
    243 int recv_while(receive_buffer_t *rb, char_class_func_t class)
     243errno_t recv_while(receive_buffer_t *rb, char_class_func_t class)
    244244{
    245245        while (true) {
    246246                char c = 0;
    247                 int rc = recv_char(rb, &c, false);
     247                errno_t rc = recv_char(rb, &c, false);
    248248                if (rc != EOK)
    249249                        return rc;
     
    266266 * @return EOK on success or an error code
    267267 */
    268 int recv_eol(receive_buffer_t *rb, size_t *nrecv)
     268errno_t recv_eol(receive_buffer_t *rb, size_t *nrecv)
    269269{
    270270        char c = 0;
    271         int rc = recv_char(rb, &c, false);
     271        errno_t rc = recv_char(rb, &c, false);
    272272        if (rc != EOK)
    273273                return rc;
     
    292292
    293293/* Receive a single line */
    294 int recv_line(receive_buffer_t *rb, char *line, size_t size, size_t *nrecv)
     294errno_t recv_line(receive_buffer_t *rb, char *line, size_t size, size_t *nrecv)
    295295{
    296296        size_t written = 0;
     
    299299        while (written < size) {
    300300                char c = 0;
    301                 int rc = recv_char(rb, &c, true);
     301                errno_t rc = recv_char(rb, &c, true);
    302302                if (rc != EOK)
    303303                        return rc;
  • uspace/lib/http/src/request.c

    r36f0738 rb7fd2a0  
    9090}
    9191
    92 int http_request_format(http_request_t *req, char **out_buf,
     92errno_t http_request_format(http_request_t *req, char **out_buf,
    9393    size_t *out_buf_size)
    9494{
     
    141141}
    142142
    143 int http_send_request(http_t *http, http_request_t *req)
     143errno_t http_send_request(http_t *http, http_request_t *req)
    144144{
    145145        char *buf = NULL;
    146146        size_t buf_size = 0;
    147147       
    148         int rc = http_request_format(req, &buf, &buf_size);
     148        errno_t rc = http_request_format(req, &buf, &buf_size);
    149149        if (rc != EOK)
    150150                return rc;
  • uspace/lib/http/src/response.c

    r36f0738 rb7fd2a0  
    4747}
    4848
    49 static int receive_number(receive_buffer_t *rb, char **str)
     49static errno_t receive_number(receive_buffer_t *rb, char **str)
    5050{
    5151        receive_buffer_mark_t start;
     
    5353       
    5454        recv_mark(rb, &start);
    55         int rc = recv_while(rb, is_digit);
     55        errno_t rc = recv_while(rb, is_digit);
    5656        if (rc != EOK) {
    5757                recv_unmark(rb, &start);
     
    6666}
    6767
    68 static int receive_uint8_t(receive_buffer_t *rb, uint8_t *out_value)
     68static errno_t receive_uint8_t(receive_buffer_t *rb, uint8_t *out_value)
    6969{
    7070        char *str = NULL;
    71         int rc = receive_number(rb, &str);
     71        errno_t rc = receive_number(rb, &str);
    7272       
    7373        if (rc != EOK)
     
    8080}
    8181
    82 static int receive_uint16_t(receive_buffer_t *rb, uint16_t *out_value)
     82static errno_t receive_uint16_t(receive_buffer_t *rb, uint16_t *out_value)
    8383{
    8484        char *str = NULL;
    85         int rc = receive_number(rb, &str);
     85        errno_t rc = receive_number(rb, &str);
    8686       
    8787        if (rc != EOK)
     
    9494}
    9595
    96 static int expect(receive_buffer_t *rb, const char *expect)
     96static errno_t expect(receive_buffer_t *rb, const char *expect)
    9797{
    9898        size_t ndisc;
    99         int rc = recv_discard_str(rb, expect, &ndisc);
     99        errno_t rc = recv_discard_str(rb, expect, &ndisc);
    100100        if (rc != EOK)
    101101                return rc;
     
    110110}
    111111
    112 int http_receive_status(receive_buffer_t *rb, http_version_t *out_version,
     112errno_t http_receive_status(receive_buffer_t *rb, http_version_t *out_version,
    113113    uint16_t *out_status, char **out_message)
    114114{
     
    117117        char *message = NULL;
    118118       
    119         int rc = expect(rb, "HTTP/");
     119        errno_t rc = expect(rb, "HTTP/");
    120120        if (rc != EOK)
    121121                return rc;
     
    187187}
    188188
    189 int http_receive_response(receive_buffer_t *rb, http_response_t **out_response,
     189errno_t http_receive_response(receive_buffer_t *rb, http_response_t **out_response,
    190190    size_t max_headers_size, unsigned max_headers_count)
    191191{
     
    196196        http_headers_init(&resp->headers);
    197197       
    198         int rc = http_receive_status(rb, &resp->version, &resp->status,
     198        errno_t rc = http_receive_status(rb, &resp->version, &resp->status,
    199199            &resp->message);
    200200        if (rc != EOK)
Note: See TracChangeset for help on using the changeset viewer.