Changeset b7fd2a0 in mainline for uspace/srv/net


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/srv/net
Files:
82 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/dhcp/dhcp.c

    r36f0738 rb7fd2a0  
    117117
    118118/** Decode subnet mask into subnet prefix length. */
    119 static int subnet_mask_decode(uint32_t mask, int *bits)
     119static errno_t subnet_mask_decode(uint32_t mask, int *bits)
    120120{
    121121        int zbits;
    … …  
    148148}
    149149
    150 static int dhcp_send_discover(dhcp_link_t *dlink)
     150static errno_t dhcp_send_discover(dhcp_link_t *dlink)
    151151{
    152152        dhcp_hdr_t *hdr = (dhcp_hdr_t *)msgbuf;
    … …  
    171171}
    172172
    173 static int dhcp_send_request(dhcp_link_t *dlink, dhcp_offer_t *offer)
     173static errno_t dhcp_send_request(dhcp_link_t *dlink, dhcp_offer_t *offer)
    174174{
    175175        dhcp_hdr_t *hdr = (dhcp_hdr_t *)msgbuf;
    … …  
    212212}
    213213
    214 static int dhcp_parse_reply(void *msg, size_t size, dhcp_offer_t *offer)
     214static errno_t dhcp_parse_reply(void *msg, size_t size, dhcp_offer_t *offer)
    215215{
    216216        dhcp_hdr_t *hdr = (dhcp_hdr_t *)msg;
    … …  
    225225        uint8_t opt_type, opt_len;
    226226        uint8_t *msgb;
    227         int rc;
     227        errno_t rc;
    228228        size_t i;
    229229
    … …  
    360360}
    361361
    362 static int dhcp_cfg_create(service_id_t iplink, dhcp_offer_t *offer)
    363 {
    364         int rc;
     362static errno_t dhcp_cfg_create(service_id_t iplink, dhcp_offer_t *offer)
     363{
     364        errno_t rc;
    365365        service_id_t addr_id;
    366366        service_id_t sroute_id;
    … …  
    420420}
    421421
    422 static int dhcp_discover_proc(dhcp_link_t *dlink)
     422static errno_t dhcp_discover_proc(dhcp_link_t *dlink)
    423423{
    424424        dlink->state = ds_selecting;
    425425
    426         int rc = dhcp_send_discover(dlink);
     426        errno_t rc = dhcp_send_discover(dlink);
    427427        if (rc != EOK)
    428428                return EIO;
    … …  
    438438}
    439439
    440 int dhcpsrv_link_add(service_id_t link_id)
     440errno_t dhcpsrv_link_add(service_id_t link_id)
    441441{
    442442        dhcp_link_t *dlink;
    443         int rc;
     443        errno_t rc;
    444444
    445445        log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcpsrv_link_add(%zu)", link_id);
    … …  
    498498}
    499499
    500 int dhcpsrv_link_remove(service_id_t link_id)
     500errno_t dhcpsrv_link_remove(service_id_t link_id)
    501501{
    502502        return ENOTSUP;
    503503}
    504504
    505 int dhcpsrv_discover(service_id_t link_id)
     505errno_t dhcpsrv_discover(service_id_t link_id)
    506506{
    507507        log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcpsrv_link_add(%zu)", link_id);
    … …  
    520520static void dhcpsrv_recv_offer(dhcp_link_t *dlink, dhcp_offer_t *offer)
    521521{
    522         int rc;
     522        errno_t rc;
    523523
    524524        if (dlink->state != ds_selecting) {
    … …  
    546546static void dhcpsrv_recv_ack(dhcp_link_t *dlink, dhcp_offer_t *offer)
    547547{
    548         int rc;
     548        errno_t rc;
    549549
    550550        if (dlink->state != ds_requesting) {
    … …  
    572572        dhcp_link_t *dlink = (dhcp_link_t *)arg;
    573573        dhcp_offer_t offer;
    574         int rc;
     574        errno_t rc;
    575575
    576576        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: dhcpsrv_recv() %zu bytes",
    … …  
    600600{
    601601        dhcp_link_t *dlink = (dhcp_link_t *)arg;
    602         int rc;
     602        errno_t rc;
    603603
    604604        assert(dlink->state == ds_selecting);
    … …  
    628628{
    629629        dhcp_link_t *dlink = (dhcp_link_t *)arg;
    630         int rc;
     630        errno_t rc;
    631631
    632632        assert(dlink->state == ds_requesting);

  • uspace/srv/net/dhcp/dhcp.h

    r36f0738 rb7fd2a0  
    4141
    4242extern void dhcpsrv_links_init(void);
    43 extern int dhcpsrv_link_add(service_id_t);
    44 extern int dhcpsrv_link_remove(service_id_t);
    45 extern int dhcpsrv_discover(service_id_t);
     43extern errno_t dhcpsrv_link_add(service_id_t);
     44extern errno_t dhcpsrv_link_remove(service_id_t);
     45extern errno_t dhcpsrv_discover(service_id_t);
    4646
    4747#endif

  • uspace/srv/net/dhcp/main.c

    r36f0738 rb7fd2a0  
    5252static void dhcp_client_conn(ipc_callid_t, ipc_call_t *, void *);
    5353
    54 static int dhcp_init(void)
     54static errno_t dhcp_init(void)
    5555{
    56         int rc;
     56        errno_t rc;
    5757
    5858        log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcp_init()");
    … …  
    8787{
    8888        sysarg_t link_id;
    89         int rc;
     89        errno_t rc;
    9090
    9191        log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcp_link_add_srv()");
    … …  
    100100{
    101101        sysarg_t link_id;
    102         int rc;
     102        errno_t rc;
    103103
    104104        log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcp_link_remove_srv()");
    … …  
    113113{
    114114        sysarg_t link_id;
    115         int rc;
     115        errno_t rc;
    116116
    117117        log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcp_discover_srv()");
    … …  
    159159int main(int argc, char *argv[])
    160160{
    161         int rc;
     161        errno_t rc;
    162162
    163163        printf("%s: DHCP Service\n", NAME);

  • uspace/srv/net/dhcp/transport.c

    r36f0738 rb7fd2a0  
    7575};
    7676
    77 int dhcp_send(dhcp_transport_t *dt, void *msg, size_t size)
     77errno_t dhcp_send(dhcp_transport_t *dt, void *msg, size_t size)
    7878{
    7979        inet_ep_t ep;
    80         int rc;
     80        errno_t rc;
    8181
    8282        inet_ep_init(&ep);
    … …  
    9797        dhcp_transport_t *dt;
    9898        size_t s;
    99         int rc;
     99        errno_t rc;
    100100
    101101        log_msg(LOG_DEFAULT, LVL_NOTE, "dhcp_recv_msg()");
    … …  
    126126}
    127127
    128 int dhcp_transport_init(dhcp_transport_t *dt, service_id_t link_id,
     128errno_t dhcp_transport_init(dhcp_transport_t *dt, service_id_t link_id,
    129129    dhcp_recv_cb_t recv_cb, void *arg)
    130130{
    … …  
    132132        udp_assoc_t *assoc = NULL;
    133133        inet_ep2_t epp;
    134         int rc;
     134        errno_t rc;
    135135
    136136        log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcp_transport_init()");

  • uspace/srv/net/dhcp/transport.h

    r36f0738 rb7fd2a0  
    5858};
    5959
    60 extern int dhcp_transport_init(dhcp_transport_t *, service_id_t,
     60extern errno_t dhcp_transport_init(dhcp_transport_t *, service_id_t,
    6161    dhcp_recv_cb_t, void *);
    6262extern void dhcp_transport_fini(dhcp_transport_t *);
    63 extern int dhcp_send(dhcp_transport_t *dt, void *msg, size_t size);
     63extern errno_t dhcp_send(dhcp_transport_t *dt, void *msg, size_t size);
    6464
    6565#endif

  • uspace/srv/net/dnsrsrv/dns_msg.c

    r36f0738 rb7fd2a0  
    5656 * fit in and append @a suff.
    5757 */
    58 static int dns_dstr_ext(char **dstr, const char *suff)
     58static errno_t dns_dstr_ext(char **dstr, const char *suff)
    5959{
    6060        size_t s1, s2;
    … …  
    9393 * @param act_size      Place to store actual encoded size
    9494 */
    95 static int dns_name_encode(char *name, uint8_t *buf, size_t buf_size,
     95static errno_t dns_name_encode(char *name, uint8_t *buf, size_t buf_size,
    9696    size_t *act_size)
    9797{
    … …  
    158158 * @param eoff  Place to store end offset (offset after last decoded byte)
    159159 */
    160 int dns_name_decode(dns_pdu_t *pdu, size_t boff, char **rname,
     160errno_t dns_name_decode(dns_pdu_t *pdu, size_t boff, char **rname,
    161161    size_t *eoff)
    162162{
    … …  
    169169        char *name;
    170170        char dbuf[2];
    171         int rc;
     171        errno_t rc;
    172172        bool first;
    173173
    … …  
    325325 * @param act_size      Place to store actual encoded size
    326326 */
    327 static int dns_question_encode(dns_question_t *question, uint8_t *buf,
     327static errno_t dns_question_encode(dns_question_t *question, uint8_t *buf,
    328328    size_t buf_size, size_t *act_size)
    329329{
    330330        size_t name_size;
    331331        size_t di;
    332         int rc;
     332        errno_t rc;
    333333
    334334        rc = dns_name_encode(question->qname, buf, buf_size, &name_size);
    … …  
    358358 * @param eoff          Place to store end offset (offset after last decoded byte)
    359359 */
    360 static int dns_question_decode(dns_pdu_t *pdu, size_t boff,
     360static errno_t dns_question_decode(dns_pdu_t *pdu, size_t boff,
    361361    dns_question_t **rquestion, size_t *eoff)
    362362{
    363363        dns_question_t *question;
    364364        size_t name_eoff;
    365         int rc;
     365        errno_t rc;
    366366
    367367        question = calloc(1, sizeof (dns_question_t));
    … …  
    398398 * @param eoff          Place to store end offset (offset after last decoded byte)
    399399 */
    400 static int dns_rr_decode(dns_pdu_t *pdu, size_t boff, dns_rr_t **retrr,
     400static errno_t dns_rr_decode(dns_pdu_t *pdu, size_t boff, dns_rr_t **retrr,
    401401    size_t *eoff)
    402402{
    … …  
    406406        size_t bsz;
    407407        size_t rdlength;
    408         int rc;
     408        errno_t rc;
    409409
    410410        rr = calloc(1, sizeof(dns_rr_t));
    … …  
    492492 *              ENOMEM if out of memory
    493493 */
    494 int dns_message_encode(dns_message_t *msg, void **rdata, size_t *rsize)
     494errno_t dns_message_encode(dns_message_t *msg, void **rdata, size_t *rsize)
    495495{
    496496        uint8_t *data;
    … …  
    499499        size_t q_size = 0;
    500500        size_t di;
    501         int rc;
     501        errno_t rc;
    502502
    503503        hdr.id = host2uint16_t_be(msg->id);
    … …  
    564564 *              ENOMEM if out of memory
    565565 */
    566 int dns_message_decode(void *data, size_t size, dns_message_t **rmsg)
     566errno_t dns_message_decode(void *data, size_t size, dns_message_t **rmsg)
    567567{
    568568        dns_message_t *msg;
    … …  
    575575        size_t an_count;
    576576        size_t i;
    577         int rc;
     577        errno_t rc;
    578578
    579579        msg = dns_message_new();

  • uspace/srv/net/dnsrsrv/dns_msg.h

    r36f0738 rb7fd2a0  
    4444#include "dns_type.h"
    4545
    46 extern int dns_message_encode(dns_message_t *, void **, size_t *);
    47 extern int dns_message_decode(void *, size_t, dns_message_t **);
     46extern errno_t dns_message_encode(dns_message_t *, void **, size_t *);
     47extern errno_t dns_message_decode(void *, size_t, dns_message_t **);
    4848extern dns_message_t *dns_message_new(void);
    4949extern void dns_message_destroy(dns_message_t *);
    50 extern int dns_name_decode(dns_pdu_t *, size_t, char **, size_t *);
     50extern errno_t dns_name_decode(dns_pdu_t *, size_t, char **, size_t *);
    5151extern uint32_t dns_uint32_t_decode(uint8_t *, size_t);
    5252extern void dns_addr128_t_decode(uint8_t *, size_t, addr128_t);

  • uspace/srv/net/dnsrsrv/dnsrsrv.c

    r36f0738 rb7fd2a0  
    5454static void dnsr_client_conn(ipc_callid_t, ipc_call_t *, void *);
    5555
    56 static int dnsr_init(void)
    57 {
    58         int rc;
     56static errno_t dnsr_init(void)
     57{
     58        errno_t rc;
    5959        log_msg(LOG_DEFAULT, LVL_DEBUG, "dnsr_init()");
    6060
    … …  
    9393       
    9494        char *name;
    95         int rc = async_data_write_accept((void **) &name, true, 0,
     95        errno_t rc = async_data_write_accept((void **) &name, true, 0,
    9696            DNS_NAME_MAX_SIZE, 0, NULL);
    9797        if (rc != EOK) {
    … …  
    171171        // FIXME locking
    172172       
    173         int rc = async_data_read_finalize(callid, &dns_server_addr, size);
     173        errno_t rc = async_data_read_finalize(callid, &dns_server_addr, size);
    174174        if (rc != EOK)
    175175                async_answer_0(callid, rc);
    … …  
    199199        // FIXME locking
    200200       
    201         int rc = async_data_write_finalize(callid, &dns_server_addr, size);
     201        errno_t rc = async_data_write_finalize(callid, &dns_server_addr, size);
    202202        if (rc != EOK) {
    203203                async_answer_0(callid, rc);
    … …  
    246246int main(int argc, char *argv[])
    247247{
    248         int rc;
     248        errno_t rc;
    249249
    250250        printf("%s: DNS Resolution Service\n", NAME);

  • uspace/srv/net/dnsrsrv/query.c

    r36f0738 rb7fd2a0  
    4747static uint16_t msg_id;
    4848
    49 static int dns_name_query(const char *name, dns_qtype_t qtype,
     49static errno_t dns_name_query(const char *name, dns_qtype_t qtype,
    5050    dns_host_info_t *info)
    5151{
    … …  
    9292        log_msg(LOG_DEFAULT, LVL_DEBUG, "dns_name_query: send DNS request");
    9393        dns_message_t *amsg;
    94         int rc = dns_request(msg, &amsg);
     94        errno_t rc = dns_request(msg, &amsg);
    9595        if (rc != EOK) {
    9696                dns_message_destroy(msg);
    … …  
    190190}
    191191
    192 int dns_name2host(const char *name, dns_host_info_t **rinfo, ip_ver_t ver)
     192errno_t dns_name2host(const char *name, dns_host_info_t **rinfo, ip_ver_t ver)
    193193{
    194194        dns_host_info_t *info = calloc(1, sizeof(dns_host_info_t));
    … …  
    196196                return ENOMEM;
    197197       
    198         int rc;
     198        errno_t rc;
    199199       
    200200        switch (ver) {

  • uspace/srv/net/dnsrsrv/query.h

    r36f0738 rb7fd2a0  
    4040#include "dns_type.h"
    4141
    42 extern int dns_name2host(const char *, dns_host_info_t **, ip_ver_t);
     42extern errno_t dns_name2host(const char *, dns_host_info_t **, ip_ver_t);
    4343extern void dns_hostinfo_destroy(dns_host_info_t *);
    4444

  • uspace/srv/net/dnsrsrv/transport.c

    r36f0738 rb7fd2a0  
    6969        fibril_mutex_t done_lock;
    7070
    71         int status;
     71        errno_t status;
    7272} trans_req_t;
    7373
    … …  
    9090};
    9191
    92 int transport_init(void)
     92errno_t transport_init(void)
    9393{
    9494        inet_ep2_t epp;
    95         int rc;
     95        errno_t rc;
    9696
    9797        inet_ep2_init(&epp);
    … …  
    177177}
    178178
    179 int dns_request(dns_message_t *req, dns_message_t **rresp)
     179errno_t dns_request(dns_message_t *req, dns_message_t **rresp)
    180180{
    181181        trans_req_t *treq = NULL;
    … …  
    185185        size_t req_size;
    186186        log_msg(LOG_DEFAULT, LVL_DEBUG, "dns_request: Encode dns message");
    187         int rc = dns_message_encode(req, &req_data, &req_size);
     187        errno_t rc = dns_message_encode(req, &req_data, &req_size);
    188188        if (rc != EOK)
    189189                goto error;
    … …  
    255255        size_t size;
    256256        inet_ep_t remote_ep;
    257         int rc;
     257        errno_t rc;
    258258
    259259        size = udp_rmsg_size(rmsg);

  • uspace/srv/net/dnsrsrv/transport.h

    r36f0738 rb7fd2a0  
    4242extern inet_addr_t dns_server_addr;
    4343
    44 extern int transport_init(void);
     44extern errno_t transport_init(void);
    4545extern void transport_fini(void);
    46 extern int dns_request(dns_message_t *, dns_message_t **);
     46extern errno_t dns_request(dns_message_t *, dns_message_t **);
    4747
    4848#endif

  • uspace/srv/net/ethip/arp.c

    r36f0738 rb7fd2a0  
    5050#define ARP_REQUEST_TIMEOUT (3 * 1000 * 1000)
    5151
    52 static int arp_send_packet(ethip_nic_t *nic, arp_eth_packet_t *packet);
     52static errno_t arp_send_packet(ethip_nic_t *nic, arp_eth_packet_t *packet);
    5353
    5454void arp_received(ethip_nic_t *nic, eth_frame_t *frame)
    … …  
    5757       
    5858        arp_eth_packet_t packet;
    59         int rc = arp_pdu_decode(frame->data, frame->size, &packet);
     59        errno_t rc = arp_pdu_decode(frame->data, frame->size, &packet);
    6060        if (rc != EOK)
    6161                return;
    … …  
    9494}
    9595
    96 int arp_translate(ethip_nic_t *nic, addr32_t src_addr, addr32_t ip_addr,
     96errno_t arp_translate(ethip_nic_t *nic, addr32_t src_addr, addr32_t ip_addr,
    9797    addr48_t mac_addr)
    9898{
    … …  
    103103        }
    104104
    105         int rc = atrans_lookup(ip_addr, mac_addr);
     105        errno_t rc = atrans_lookup(ip_addr, mac_addr);
    106106        if (rc == EOK)
    107107                return EOK;
    … …  
    122122}
    123123
    124 static int arp_send_packet(ethip_nic_t *nic, arp_eth_packet_t *packet)
     124static errno_t arp_send_packet(ethip_nic_t *nic, arp_eth_packet_t *packet)
    125125{
    126         int rc;
     126        errno_t rc;
    127127        void *pdata;
    128128        size_t psize;

  • uspace/srv/net/ethip/arp.h

    r36f0738 rb7fd2a0  
    4343
    4444extern void arp_received(ethip_nic_t *, eth_frame_t *);
    45 extern int arp_translate(ethip_nic_t *, addr32_t, addr32_t, addr48_t);
     45extern errno_t arp_translate(ethip_nic_t *, addr32_t, addr32_t, addr48_t);
    4646
    4747#endif

  • uspace/srv/net/ethip/atrans.c

    r36f0738 rb7fd2a0  
    5959}
    6060
    61 int atrans_add(addr32_t ip_addr, addr48_t mac_addr)
     61errno_t atrans_add(addr32_t ip_addr, addr48_t mac_addr)
    6262{
    6363        ethip_atrans_t *atrans;
    … …  
    8585}
    8686
    87 int atrans_remove(addr32_t ip_addr)
     87errno_t atrans_remove(addr32_t ip_addr)
    8888{
    8989        ethip_atrans_t *atrans;
    … …  
    103103}
    104104
    105 static int atrans_lookup_locked(addr32_t ip_addr, addr48_t mac_addr)
     105static errno_t atrans_lookup_locked(addr32_t ip_addr, addr48_t mac_addr)
    106106{
    107107        ethip_atrans_t *atrans = atrans_find(ip_addr);
    … …  
    113113}
    114114
    115 int atrans_lookup(addr32_t ip_addr, addr48_t mac_addr)
     115errno_t atrans_lookup(addr32_t ip_addr, addr48_t mac_addr)
    116116{
    117         int rc;
     117        errno_t rc;
    118118
    119119        fibril_mutex_lock(&atrans_list_lock);
    … …  
    134134}
    135135
    136 int atrans_lookup_timeout(addr32_t ip_addr, suseconds_t timeout,
     136errno_t atrans_lookup_timeout(addr32_t ip_addr, suseconds_t timeout,
    137137    addr48_t mac_addr)
    138138{
    139139        fibril_timer_t *t;
    140140        bool timedout;
    141         int rc;
     141        errno_t rc;
    142142
    143143        t = fibril_timer_create(NULL);

  • uspace/srv/net/ethip/atrans.h

    r36f0738 rb7fd2a0  
    4242#include "ethip.h"
    4343
    44 extern int atrans_add(addr32_t, addr48_t);
    45 extern int atrans_remove(addr32_t);
    46 extern int atrans_lookup(addr32_t, addr48_t);
    47 extern int atrans_lookup_timeout(addr32_t, suseconds_t, addr48_t);
     44extern errno_t atrans_add(addr32_t, addr48_t);
     45extern errno_t atrans_remove(addr32_t);
     46extern errno_t atrans_lookup(addr32_t, addr48_t);
     47extern errno_t atrans_lookup_timeout(addr32_t, suseconds_t, addr48_t);
    4848
    4949#endif

  • uspace/srv/net/ethip/ethip.c

    r36f0738 rb7fd2a0  
    5353#define NAME "ethip"
    5454
    55 static int ethip_open(iplink_srv_t *srv);
    56 static int ethip_close(iplink_srv_t *srv);
    57 static int ethip_send(iplink_srv_t *srv, iplink_sdu_t *sdu);
    58 static int ethip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu);
    59 static int ethip_get_mtu(iplink_srv_t *srv, size_t *mtu);
    60 static int ethip_get_mac48(iplink_srv_t *srv, addr48_t *mac);
    61 static int ethip_set_mac48(iplink_srv_t *srv, addr48_t *mac);
    62 static int ethip_addr_add(iplink_srv_t *srv, inet_addr_t *addr);
    63 static int ethip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr);
     55static errno_t ethip_open(iplink_srv_t *srv);
     56static errno_t ethip_close(iplink_srv_t *srv);
     57static errno_t ethip_send(iplink_srv_t *srv, iplink_sdu_t *sdu);
     58static errno_t ethip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu);
     59static errno_t ethip_get_mtu(iplink_srv_t *srv, size_t *mtu);
     60static errno_t ethip_get_mac48(iplink_srv_t *srv, addr48_t *mac);
     61static errno_t ethip_set_mac48(iplink_srv_t *srv, addr48_t *mac);
     62static errno_t ethip_addr_add(iplink_srv_t *srv, inet_addr_t *addr);
     63static errno_t ethip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr);
    6464
    6565static void ethip_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    … …  
    7777};
    7878
    79 static int ethip_init(void)
     79static errno_t ethip_init(void)
    8080{
    8181        async_set_fallback_port_handler(ethip_client_conn, NULL);
    8282       
    83         int rc = loc_server_register(NAME);
     83        errno_t rc = loc_server_register(NAME);
    8484        if (rc != EOK) {
    8585                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server.");
    … …  
    9494}
    9595
    96 int ethip_iplink_init(ethip_nic_t *nic)
    97 {
    98         int rc;
     96errno_t ethip_iplink_init(ethip_nic_t *nic)
     97{
     98        errno_t rc;
    9999        service_id_t sid;
    100100        category_id_t iplink_cat;
    … …  
    158158}
    159159
    160 static int ethip_open(iplink_srv_t *srv)
     160static errno_t ethip_open(iplink_srv_t *srv)
    161161{
    162162        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_open()");
    … …  
    164164}
    165165
    166 static int ethip_close(iplink_srv_t *srv)
     166static errno_t ethip_close(iplink_srv_t *srv)
    167167{
    168168        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_close()");
    … …  
    170170}
    171171
    172 static int ethip_send(iplink_srv_t *srv, iplink_sdu_t *sdu)
     172static errno_t ethip_send(iplink_srv_t *srv, iplink_sdu_t *sdu)
    173173{
    174174        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_send()");
    … …  
    177177        eth_frame_t frame;
    178178       
    179         int rc = arp_translate(nic, sdu->src, sdu->dest, frame.dest);
     179        errno_t rc = arp_translate(nic, sdu->src, sdu->dest, frame.dest);
    180180        if (rc != EOK) {
    181181                log_msg(LOG_DEFAULT, LVL_WARN, "Failed to look up IPv4 address 0x%"
    … …  
    201201}
    202202
    203 static int ethip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu)
     203static errno_t ethip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu)
    204204{
    205205        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_send6()");
    … …  
    216216        void *data;
    217217        size_t size;
    218         int rc = eth_pdu_encode(&frame, &data, &size);
     218        errno_t rc = eth_pdu_encode(&frame, &data, &size);
    219219        if (rc != EOK)
    220220                return rc;
    … …  
    226226}
    227227
    228 int ethip_received(iplink_srv_t *srv, void *data, size_t size)
     228errno_t ethip_received(iplink_srv_t *srv, void *data, size_t size)
    229229{
    230230        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_received(): srv=%p", srv);
    … …  
    234234       
    235235        eth_frame_t frame;
    236         int rc = eth_pdu_decode(data, size, &frame);
     236        errno_t rc = eth_pdu_decode(data, size, &frame);
    237237        if (rc != EOK) {
    238238                log_msg(LOG_DEFAULT, LVL_DEBUG, " - eth_pdu_decode failed");
    … …  
    269269}
    270270
    271 static int ethip_get_mtu(iplink_srv_t *srv, size_t *mtu)
     271static errno_t ethip_get_mtu(iplink_srv_t *srv, size_t *mtu)
    272272{
    273273        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_get_mtu()");
    … …  
    276276}
    277277
    278 static int ethip_get_mac48(iplink_srv_t *srv, addr48_t *mac)
     278static errno_t ethip_get_mac48(iplink_srv_t *srv, addr48_t *mac)
    279279{
    280280        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_get_mac48()");
    … …  
    286286}
    287287
    288 static int ethip_set_mac48(iplink_srv_t *srv, addr48_t *mac)
     288static errno_t ethip_set_mac48(iplink_srv_t *srv, addr48_t *mac)
    289289{
    290290        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_set_mac48()");
    … …  
    296296}
    297297
    298 static int ethip_addr_add(iplink_srv_t *srv, inet_addr_t *addr)
     298static errno_t ethip_addr_add(iplink_srv_t *srv, inet_addr_t *addr)
    299299{
    300300        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
    … …  
    303303}
    304304
    305 static int ethip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr)
     305static errno_t ethip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr)
    306306{
    307307        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
    … …  
    312312int main(int argc, char *argv[])
    313313{
    314         int rc;
     314        errno_t rc;
    315315
    316316        printf(NAME ": HelenOS IP over Ethernet service\n");

  • uspace/srv/net/ethip/ethip.h

    r36f0738 rb7fd2a0  
    116116} ethip_atrans_t;
    117117
    118 extern int ethip_iplink_init(ethip_nic_t *);
    119 extern int ethip_received(iplink_srv_t *, void *, size_t);
     118extern errno_t ethip_iplink_init(ethip_nic_t *);
     119extern errno_t ethip_received(iplink_srv_t *, void *, size_t);
    120120
    121121#endif

  • uspace/srv/net/ethip/ethip_nic.c

    r36f0738 rb7fd2a0  
    5151#include "pdu.h"
    5252
    53 static int ethip_nic_open(service_id_t sid);
     53static errno_t ethip_nic_open(service_id_t sid);
    5454static void ethip_nic_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    5555
    … …  
    5757static FIBRIL_MUTEX_INITIALIZE(ethip_discovery_lock);
    5858
    59 static int ethip_nic_check_new(void)
     59static errno_t ethip_nic_check_new(void)
    6060{
    6161        bool already_known;
    … …  
    6363        service_id_t *svcs;
    6464        size_t count, i;
    65         int rc;
     65        errno_t rc;
    6666
    6767        fibril_mutex_lock(&ethip_discovery_lock);
    … …  
    147147}
    148148
    149 static int ethip_nic_open(service_id_t sid)
     149static errno_t ethip_nic_open(service_id_t sid)
    150150{
    151151        bool in_list = false;
    … …  
    157157                return ENOMEM;
    158158       
    159         int rc = loc_service_get_name(sid, &nic->svc_name);
     159        errno_t rc = loc_service_get_name(sid, &nic->svc_name);
    160160        if (rc != EOK) {
    161161                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting service name.");
    … …  
    234234        uint8_t *addr;
    235235        size_t size;
    236         int rc;
     236        errno_t rc;
    237237
    238238        rc = async_data_write_accept((void **)&addr, false, 0, 0, 0, &size);
    … …  
    261261    ipc_call_t *call)
    262262{
    263         int rc;
     263        errno_t rc;
    264264        void *data;
    265265        size_t size;
    … …  
    324324}
    325325
    326 int ethip_nic_discovery_start(void)
    327 {
    328         int rc = loc_register_cat_change_cb(ethip_nic_cat_change_cb);
     326errno_t ethip_nic_discovery_start(void)
     327{
     328        errno_t rc = loc_register_cat_change_cb(ethip_nic_cat_change_cb);
    329329        if (rc != EOK) {
    330330                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback for NIC "
    … …  
    353353}
    354354
    355 int ethip_nic_send(ethip_nic_t *nic, void *data, size_t size)
    356 {
    357         int rc;
     355errno_t ethip_nic_send(ethip_nic_t *nic, void *data, size_t size)
     356{
     357        errno_t rc;
    358358        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_send(size=%zu)", size);
    359359        rc = nic_send_frame(nic->sess, data, size);
    … …  
    368368 *
    369369 */
    370 static int ethip_nic_setup_multicast(ethip_nic_t *nic)
     370static errno_t ethip_nic_setup_multicast(ethip_nic_t *nic)
    371371{
    372372        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_setup_multicast()");
    … …  
    425425        /* Setup the multicast MAC list */
    426426       
    427         int rc = nic_multicast_set_mode(nic->sess, NIC_MULTICAST_LIST,
     427        errno_t rc = nic_multicast_set_mode(nic->sess, NIC_MULTICAST_LIST,
    428428            mac_list, count);
    429429       
    … …  
    432432}
    433433
    434 int ethip_nic_addr_add(ethip_nic_t *nic, inet_addr_t *addr)
     434errno_t ethip_nic_addr_add(ethip_nic_t *nic, inet_addr_t *addr)
    435435{
    436436        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_add()");
    … …  
    445445}
    446446
    447 int ethip_nic_addr_remove(ethip_nic_t *nic, inet_addr_t *addr)
     447errno_t ethip_nic_addr_remove(ethip_nic_t *nic, inet_addr_t *addr)
    448448{
    449449        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_remove()");

  • uspace/srv/net/ethip/ethip_nic.h

    r36f0738 rb7fd2a0  
    4242#include "ethip.h"
    4343
    44 extern int ethip_nic_discovery_start(void);
     44extern errno_t ethip_nic_discovery_start(void);
    4545extern ethip_nic_t *ethip_nic_find_by_iplink_sid(service_id_t);
    46 extern int ethip_nic_send(ethip_nic_t *, void *, size_t);
    47 extern int ethip_nic_addr_add(ethip_nic_t *, inet_addr_t *);
    48 extern int ethip_nic_addr_remove(ethip_nic_t *, inet_addr_t *);
     46extern errno_t ethip_nic_send(ethip_nic_t *, void *, size_t);
     47extern errno_t ethip_nic_addr_add(ethip_nic_t *, inet_addr_t *);
     48extern errno_t ethip_nic_addr_remove(ethip_nic_t *, inet_addr_t *);
    4949extern ethip_link_addr_t *ethip_nic_addr_find(ethip_nic_t *, inet_addr_t *);
    5050

  • uspace/srv/net/ethip/pdu.c

    r36f0738 rb7fd2a0  
    4747
    4848/** Encode Ethernet PDU. */
    49 int eth_pdu_encode(eth_frame_t *frame, void **rdata, size_t *rsize)
     49errno_t eth_pdu_encode(eth_frame_t *frame, void **rdata, size_t *rsize)
    5050{
    5151        void *data;
    … …  
    7575
    7676/** Decode Ethernet PDU. */
    77 int eth_pdu_decode(void *data, size_t size, eth_frame_t *frame)
     77errno_t eth_pdu_decode(void *data, size_t size, eth_frame_t *frame)
    7878{
    7979        eth_header_t *hdr;
    … …  
    106106
    107107/** Encode ARP PDU. */
    108 int arp_pdu_encode(arp_eth_packet_t *packet, void **rdata, size_t *rsize)
     108errno_t arp_pdu_encode(arp_eth_packet_t *packet, void **rdata, size_t *rsize)
    109109{
    110110        void *data;
    … …  
    149149
    150150/** Decode ARP PDU. */
    151 int arp_pdu_decode(void *data, size_t size, arp_eth_packet_t *packet)
     151errno_t arp_pdu_decode(void *data, size_t size, arp_eth_packet_t *packet)
    152152{
    153153        arp_eth_packet_fmt_t *pfmt;

  • uspace/srv/net/ethip/pdu.h

    r36f0738 rb7fd2a0  
    4040#include "ethip.h"
    4141
    42 extern int eth_pdu_encode(eth_frame_t *, void **, size_t *);
    43 extern int eth_pdu_decode(void *, size_t, eth_frame_t *);
    44 extern int arp_pdu_encode(arp_eth_packet_t *, void **, size_t *);
    45 extern int arp_pdu_decode(void *, size_t, arp_eth_packet_t *);
     42extern errno_t eth_pdu_encode(eth_frame_t *, void **, size_t *);
     43extern errno_t eth_pdu_decode(void *, size_t, eth_frame_t *);
     44extern errno_t arp_pdu_encode(arp_eth_packet_t *, void **, size_t *);
     45extern errno_t arp_pdu_decode(void *, size_t, arp_eth_packet_t *);
    4646
    4747#endif

  • uspace/srv/net/inetsrv/addrobj.c

    r36f0738 rb7fd2a0  
    7878}
    7979
    80 int inet_addrobj_add(inet_addrobj_t *addr)
     80errno_t inet_addrobj_add(inet_addrobj_t *addr)
    8181{
    8282        inet_addrobj_t *aobj;
    … …  
    212212
    213213/** Send datagram from address object */
    214 int inet_addrobj_send_dgram(inet_addrobj_t *addr, inet_addr_t *ldest,
     214errno_t inet_addrobj_send_dgram(inet_addrobj_t *addr, inet_addr_t *ldest,
    215215    inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df)
    216216{
    … …  
    229229                return EINVAL;
    230230
    231         int rc;
     231        errno_t rc;
    232232        addr48_t ldest_mac;
    233233
    … …  
    255255
    256256/** Get IDs of all address objects. */
    257 int inet_addrobj_get_id_list(sysarg_t **rid_list, size_t *rcount)
     257errno_t inet_addrobj_get_id_list(sysarg_t **rid_list, size_t *rcount)
    258258{
    259259        sysarg_t *id_list;

  • uspace/srv/net/inetsrv/addrobj.h

    r36f0738 rb7fd2a0  
    5151extern inet_addrobj_t *inet_addrobj_new(void);
    5252extern void inet_addrobj_delete(inet_addrobj_t *);
    53 extern int inet_addrobj_add(inet_addrobj_t *);
     53extern errno_t inet_addrobj_add(inet_addrobj_t *);
    5454extern void inet_addrobj_remove(inet_addrobj_t *);
    5555extern inet_addrobj_t *inet_addrobj_find(inet_addr_t *, inet_addrobj_find_t);
    5656extern inet_addrobj_t *inet_addrobj_find_by_name(const char *, inet_link_t *);
    5757extern inet_addrobj_t *inet_addrobj_get_by_id(sysarg_t);
    58 extern int inet_addrobj_send_dgram(inet_addrobj_t *, inet_addr_t *,
     58extern errno_t inet_addrobj_send_dgram(inet_addrobj_t *, inet_addr_t *,
    5959    inet_dgram_t *, uint8_t, uint8_t, int);
    60 extern int inet_addrobj_get_id_list(sysarg_t **, size_t *);
     60extern errno_t inet_addrobj_get_id_list(sysarg_t **, size_t *);
    6161
    6262#endif

  • uspace/srv/net/inetsrv/icmp.c

    r36f0738 rb7fd2a0  
    5050#define INET_TTL_MAX 255
    5151
    52 static int icmp_recv_echo_request(inet_dgram_t *);
    53 static int icmp_recv_echo_reply(inet_dgram_t *);
     52static errno_t icmp_recv_echo_request(inet_dgram_t *);
     53static errno_t icmp_recv_echo_reply(inet_dgram_t *);
    5454
    55 int icmp_recv(inet_dgram_t *dgram)
     55errno_t icmp_recv(inet_dgram_t *dgram)
    5656{
    5757        uint8_t type;
    … …  
    7676}
    7777
    78 static int icmp_recv_echo_request(inet_dgram_t *dgram)
     78static errno_t icmp_recv_echo_request(inet_dgram_t *dgram)
    7979{
    8080        icmp_echo_t *request, *reply;
    … …  
    8282        size_t size;
    8383        inet_dgram_t rdgram;
    84         int rc;
     84        errno_t rc;
    8585
    8686        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmp_recv_echo_request()");
    … …  
    119119}
    120120
    121 static int icmp_recv_echo_reply(inet_dgram_t *dgram)
     121static errno_t icmp_recv_echo_reply(inet_dgram_t *dgram)
    122122{
    123123        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmp_recv_echo_reply()");
    … …  
    141141}
    142142
    143 int icmp_ping_send(uint16_t ident, inetping_sdu_t *sdu)
     143errno_t icmp_ping_send(uint16_t ident, inetping_sdu_t *sdu)
    144144{
    145145        size_t rsize = sizeof(icmp_echo_t) + sdu->size;
    … …  
    170170        dgram.size = rsize;
    171171
    172         int rc = inet_route_packet(&dgram, IP_PROTO_ICMP, INET_TTL_MAX, 0);
     172        errno_t rc = inet_route_packet(&dgram, IP_PROTO_ICMP, INET_TTL_MAX, 0);
    173173
    174174        free(rdata);

  • uspace/srv/net/inetsrv/icmp.h

    r36f0738 rb7fd2a0  
    4141#include "inetsrv.h"
    4242
    43 extern int icmp_recv(inet_dgram_t *);
    44 extern int icmp_ping_send(uint16_t, inetping_sdu_t *);
     43extern errno_t icmp_recv(inet_dgram_t *);
     44extern errno_t icmp_ping_send(uint16_t, inetping_sdu_t *);
    4545
    4646#endif

  • uspace/srv/net/inetsrv/icmpv6.c

    r36f0738 rb7fd2a0  
    4747#include "pdu.h"
    4848
    49 static int icmpv6_recv_echo_request(inet_dgram_t *dgram)
     49static errno_t icmpv6_recv_echo_request(inet_dgram_t *dgram)
    5050{
    5151        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmpv6_recv_echo_request()");
    … …  
    101101        reply->checksum = host2uint16_t_be(cs_all);
    102102       
    103         int rc = inet_route_packet(&rdgram, IP_PROTO_ICMPV6,
     103        errno_t rc = inet_route_packet(&rdgram, IP_PROTO_ICMPV6,
    104104            INET6_HOP_LIMIT_MAX, 0);
    105105       
    … …  
    109109}
    110110
    111 static int icmpv6_recv_echo_reply(inet_dgram_t *dgram)
     111static errno_t icmpv6_recv_echo_reply(inet_dgram_t *dgram)
    112112{
    113113        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmpv6_recv_echo_reply()");
    … …  
    132132}
    133133
    134 int icmpv6_recv(inet_dgram_t *dgram)
     134errno_t icmpv6_recv(inet_dgram_t *dgram)
    135135{
    136136        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmpv6_recv()");
    … …  
    157157}
    158158
    159 int icmpv6_ping_send(uint16_t ident, inetping_sdu_t *sdu)
     159errno_t icmpv6_ping_send(uint16_t ident, inetping_sdu_t *sdu)
    160160{
    161161        size_t rsize = sizeof(icmpv6_message_t) + sdu->size;
    … …  
    202202        request->checksum = host2uint16_t_be(cs_all);
    203203       
    204         int rc = inet_route_packet(&dgram, IP_PROTO_ICMPV6,
     204        errno_t rc = inet_route_packet(&dgram, IP_PROTO_ICMPV6,
    205205            INET6_HOP_LIMIT_MAX, 0);
    206206       

  • uspace/srv/net/inetsrv/icmpv6.h

    r36f0738 rb7fd2a0  
    4141#include "inetsrv.h"
    4242
    43 extern int icmpv6_recv(inet_dgram_t *);
    44 extern int icmpv6_ping_send(uint16_t, inetping_sdu_t *);
     43extern errno_t icmpv6_recv(inet_dgram_t *);
     44extern errno_t icmpv6_ping_send(uint16_t, inetping_sdu_t *);
    4545
    4646#endif

  • uspace/srv/net/inetsrv/inet_link.c

    r36f0738 rb7fd2a0  
    5555static uint16_t ip_ident = 0;
    5656
    57 static int inet_iplink_recv(iplink_t *, iplink_recv_sdu_t *, ip_ver_t);
    58 static int inet_iplink_change_addr(iplink_t *, addr48_t);
     57static errno_t inet_iplink_recv(iplink_t *, iplink_recv_sdu_t *, ip_ver_t);
     58static errno_t inet_iplink_change_addr(iplink_t *, addr48_t);
    5959static inet_link_t *inet_link_get_by_id_locked(sysarg_t);
    6060
    … …  
    8383}
    8484
    85 static int inet_iplink_recv(iplink_t *iplink, iplink_recv_sdu_t *sdu, ip_ver_t ver)
     85static errno_t inet_iplink_recv(iplink_t *iplink, iplink_recv_sdu_t *sdu, ip_ver_t ver)
    8686{
    8787        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_iplink_recv()");
    8888
    89         int rc;
     89        errno_t rc;
    9090        inet_packet_t packet;
    9191        inet_link_t *ilink;
    … …  
    121121}
    122122
    123 static int inet_iplink_change_addr(iplink_t *iplink, addr48_t mac)
     123static errno_t inet_iplink_change_addr(iplink_t *iplink, addr48_t mac)
    124124{
    125125        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_iplink_change_addr(): "
    … …  
    158158}
    159159
    160 int inet_link_open(service_id_t sid)
     160errno_t inet_link_open(service_id_t sid)
    161161{
    162162        inet_link_t *ilink;
    163163        inet_addr_t iaddr;
    164         int rc;
     164        errno_t rc;
    165165
    166166        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_link_open()");
    … …  
    312312 *
    313313 */
    314 int inet_link_send_dgram(inet_link_t *ilink, addr32_t lsrc, addr32_t ldest,
     314errno_t inet_link_send_dgram(inet_link_t *ilink, addr32_t lsrc, addr32_t ldest,
    315315    inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df)
    316316{
    … …  
    352352        packet.size = dgram->size;
    353353       
    354         int rc;
     354        errno_t rc;
    355355        size_t offs = 0;
    356356       
    … …  
    387387 *
    388388 */
    389 int inet_link_send_dgram6(inet_link_t *ilink, addr48_t ldest,
     389errno_t inet_link_send_dgram6(inet_link_t *ilink, addr48_t ldest,
    390390    inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df)
    391391{
    … …  
    425425        packet.size = dgram->size;
    426426       
    427         int rc;
     427        errno_t rc;
    428428        size_t offs = 0;
    429429       
    … …  
    471471
    472472/** Get IDs of all links. */
    473 int inet_link_get_id_list(sysarg_t **rid_list, size_t *rcount)
     473errno_t inet_link_get_id_list(sysarg_t **rid_list, size_t *rcount)
    474474{
    475475        sysarg_t *id_list;

  • uspace/srv/net/inetsrv/inet_link.h

    r36f0738 rb7fd2a0  
    4242#include "inetsrv.h"
    4343
    44 extern int inet_link_open(service_id_t);
    45 extern int inet_link_send_dgram(inet_link_t *, addr32_t,
     44extern errno_t inet_link_open(service_id_t);
     45extern errno_t inet_link_send_dgram(inet_link_t *, addr32_t,
    4646    addr32_t, inet_dgram_t *, uint8_t, uint8_t, int);
    47 extern int inet_link_send_dgram6(inet_link_t *, addr48_t, inet_dgram_t *,
     47extern errno_t inet_link_send_dgram6(inet_link_t *, addr48_t, inet_dgram_t *,
    4848    uint8_t, uint8_t, int);
    4949extern inet_link_t *inet_link_get_by_id(sysarg_t);
    50 extern int inet_link_get_id_list(sysarg_t **, size_t *);
     50extern errno_t inet_link_get_id_list(sysarg_t **, size_t *);
    5151
    5252#endif

  • uspace/srv/net/inetsrv/inetcfg.c

    r36f0738 rb7fd2a0  
    5252#include "sroute.h"
    5353
    54 static int inetcfg_addr_create_static(char *name, inet_naddr_t *naddr,
     54static errno_t inetcfg_addr_create_static(char *name, inet_naddr_t *naddr,
    5555    sysarg_t link_id, sysarg_t *addr_id)
    5656{
    … …  
    5858        inet_addrobj_t *addr;
    5959        inet_addr_t iaddr;
    60         int rc;
     60        errno_t rc;
    6161
    6262        ilink = inet_link_get_by_id(link_id);
    … …  
    9595}
    9696
    97 static int inetcfg_addr_delete(sysarg_t addr_id)
     97static errno_t inetcfg_addr_delete(sysarg_t addr_id)
    9898{
    9999        inet_addrobj_t *addr;
    … …  
    109109}
    110110
    111 static int inetcfg_addr_get(sysarg_t addr_id, inet_addr_info_t *ainfo)
     111static errno_t inetcfg_addr_get(sysarg_t addr_id, inet_addr_info_t *ainfo)
    112112{
    113113        inet_addrobj_t *addr;
    … …  
    124124}
    125125
    126 static int inetcfg_addr_get_id(char *name, sysarg_t link_id, sysarg_t *addr_id)
     126static errno_t inetcfg_addr_get_id(char *name, sysarg_t link_id, sysarg_t *addr_id)
    127127{
    128128        inet_link_t *ilink;
    … …  
    145145}
    146146
    147 static int inetcfg_get_addr_list(sysarg_t **addrs, size_t *count)
     147static errno_t inetcfg_get_addr_list(sysarg_t **addrs, size_t *count)
    148148{
    149149        return inet_addrobj_get_id_list(addrs, count);
    150150}
    151151
    152 static int inetcfg_get_link_list(sysarg_t **addrs, size_t *count)
     152static errno_t inetcfg_get_link_list(sysarg_t **addrs, size_t *count)
    153153{
    154154        return inet_link_get_id_list(addrs, count);
    155155}
    156156
    157 static int inetcfg_get_sroute_list(sysarg_t **sroutes, size_t *count)
     157static errno_t inetcfg_get_sroute_list(sysarg_t **sroutes, size_t *count)
    158158{
    159159        return inet_sroute_get_id_list(sroutes, count);
    160160}
    161161
    162 static int inetcfg_link_add(sysarg_t link_id)
     162static errno_t inetcfg_link_add(sysarg_t link_id)
    163163{
    164164        return inet_link_open(link_id);
    165165}
    166166
    167 static int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
     167static errno_t inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
    168168{
    169169        inet_link_t *ilink;
    … …  
    185185}
    186186
    187 static int inetcfg_link_remove(sysarg_t link_id)
     187static errno_t inetcfg_link_remove(sysarg_t link_id)
    188188{
    189189        return ENOTSUP;
    190190}
    191191
    192 static int inetcfg_sroute_create(char *name, inet_naddr_t *dest,
     192static errno_t inetcfg_sroute_create(char *name, inet_naddr_t *dest,
    193193    inet_addr_t *router, sysarg_t *sroute_id)
    194194{
    … …  
    210210}
    211211
    212 static int inetcfg_sroute_delete(sysarg_t sroute_id)
     212static errno_t inetcfg_sroute_delete(sysarg_t sroute_id)
    213213{
    214214        inet_sroute_t *sroute;
    … …  
    224224}
    225225
    226 static int inetcfg_sroute_get(sysarg_t sroute_id, inet_sroute_info_t *srinfo)
     226static errno_t inetcfg_sroute_get(sysarg_t sroute_id, inet_sroute_info_t *srinfo)
    227227{
    228228        inet_sroute_t *sroute;
    … …  
    239239}
    240240
    241 static int inetcfg_sroute_get_id(char *name, sysarg_t *sroute_id)
     241static errno_t inetcfg_sroute_get_id(char *name, sysarg_t *sroute_id)
    242242{
    243243        inet_sroute_t *sroute;
    … …  
    275275       
    276276        inet_naddr_t naddr;
    277         int rc = async_data_write_finalize(callid, &naddr, size);
     277        errno_t rc = async_data_write_finalize(callid, &naddr, size);
    278278        if (rc != EOK) {
    279279                async_answer_0(callid, rc);
    … …  
    299299{
    300300        sysarg_t addr_id;
    301         int rc;
     301        errno_t rc;
    302302
    303303        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_delete_srv()");
    … …  
    321321        ainfo.name = NULL;
    322322       
    323         int rc = inetcfg_addr_get(addr_id, &ainfo);
     323        errno_t rc = inetcfg_addr_get(addr_id, &ainfo);
    324324        if (rc != EOK) {
    325325                async_answer_0(iid, rc);
    … …  
    372372        sysarg_t link_id;
    373373        sysarg_t addr_id;
    374         int rc;
     374        errno_t rc;
    375375
    376376        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_id_srv()");
    … …  
    399399        size_t size;
    400400        sysarg_t *id_buf;
    401         int rc;
     401        errno_t rc;
    402402
    403403        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_addr_list_srv()");
    … …  
    419419        size = min(act_size, max_size);
    420420
    421         int retval = async_data_read_finalize(rcallid, id_buf, size);
     421        errno_t retval = async_data_read_finalize(rcallid, id_buf, size);
    422422        free(id_buf);
    423423
    … …  
    433433        size_t size;
    434434        sysarg_t *id_buf;
    435         int rc;
     435        errno_t rc;
    436436
    437437        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_addr_list_srv()");
    … …  
    453453        size = min(act_size, max_size);
    454454
    455         int retval = async_data_read_finalize(rcallid, id_buf, size);
     455        errno_t retval = async_data_read_finalize(rcallid, id_buf, size);
    456456        free(id_buf);
    457457
    … …  
    467467        size_t size;
    468468        sysarg_t *id_buf;
    469         int rc;
     469        errno_t rc;
    470470
    471471        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_sroute_list_srv()");
    … …  
    487487        size = min(act_size, max_size);
    488488
    489         int retval = async_data_read_finalize(rcallid, id_buf, size);
     489        errno_t retval = async_data_read_finalize(rcallid, id_buf, size);
    490490        free(id_buf);
    491491
    … …  
    496496{
    497497        sysarg_t link_id;
    498         int rc;
     498        errno_t rc;
    499499
    500500        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_link_add_srv()");
    … …  
    515515        sysarg_t link_id;
    516516        inet_link_info_t linfo;
    517         int rc;
     517        errno_t rc;
    518518
    519519        link_id = IPC_GET_ARG1(*call);
    … …  
    542542        }
    543543
    544         int retval = async_data_read_finalize(name_callid, linfo.name,
     544        errno_t retval = async_data_read_finalize(name_callid, linfo.name,
    545545            min(name_max_size, str_size(linfo.name)));
    546546        if (retval != EOK) {
    … …  
    562562{
    563563        sysarg_t link_id;
    564         int rc;
     564        errno_t rc;
    565565
    566566        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_link_remove_srv()");
    … …  
    592592       
    593593        inet_naddr_t dest;
    594         int rc = async_data_write_finalize(callid, &dest, size);
     594        errno_t rc = async_data_write_finalize(callid, &dest, size);
    595595        if (rc != EOK) {
    596596                async_answer_0(callid, rc);
    … …  
    636636{
    637637        sysarg_t sroute_id;
    638         int rc;
     638        errno_t rc;
    639639
    640640        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_delete_srv()");
    … …  
    658658        srinfo.name = NULL;
    659659       
    660         int rc = inetcfg_sroute_get(sroute_id, &srinfo);
     660        errno_t rc = inetcfg_sroute_get(sroute_id, &srinfo);
    661661        if (rc != EOK) {
    662662                async_answer_0(iid, rc);
    … …  
    721721        char *name;
    722722        sysarg_t sroute_id;
    723         int rc;
     723        errno_t rc;
    724724
    725725        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_id_srv()");

  • uspace/srv/net/inetsrv/inetping.c

    r36f0738 rb7fd2a0  
    5858static uint16_t inetping_ident = 0;
    5959
    60 static int inetping_send(inetping_client_t *client, inetping_sdu_t *sdu)
     60static errno_t inetping_send(inetping_client_t *client, inetping_sdu_t *sdu)
    6161{
    6262        if (sdu->src.version != sdu->dest.version)
    … …  
    7373}
    7474
    75 static int inetping_get_srcaddr(inetping_client_t *client,
     75static errno_t inetping_get_srcaddr(inetping_client_t *client,
    7676    inet_addr_t *remote, inet_addr_t *local)
    7777{
    … …  
    9494}
    9595
    96 int inetping_recv(uint16_t ident, inetping_sdu_t *sdu)
     96errno_t inetping_recv(uint16_t ident, inetping_sdu_t *sdu)
    9797{
    9898        inetping_client_t *client = inetping_client_find(ident);
    … …  
    107107        aid_t req = async_send_1(exch, INETPING_EV_RECV, sdu->seq_no, &answer);
    108108
    109         int rc = async_data_write_start(exch, &sdu->src, sizeof(sdu->src));
     109        errno_t rc = async_data_write_start(exch, &sdu->src, sizeof(sdu->src));
    110110        if (rc != EOK) {
    111111                async_exchange_end(exch);
    … …  
    130130        }
    131131
    132         int retval;
     132        errno_t retval;
    133133        async_wait_for(req, &retval);
    134134
    … …  
    142142
    143143        inetping_sdu_t sdu;
    144         int rc;
     144        errno_t rc;
    145145
    146146        sdu.seq_no = IPC_GET_ARG1(*icall);
    … …  
    222222        }
    223223
    224         int rc = async_data_write_finalize(callid, &remote, size);
     224        errno_t rc = async_data_write_finalize(callid, &remote, size);
    225225        if (rc != EOK) {
    226226                async_answer_0(callid, rc);
    … …  
    254254}
    255255
    256 static int inetping_client_init(inetping_client_t *client)
     256static errno_t inetping_client_init(inetping_client_t *client)
    257257{
    258258        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    … …  
    289289
    290290        inetping_client_t client;
    291         int rc = inetping_client_init(&client);
     291        errno_t rc = inetping_client_init(&client);
    292292        if (rc != EOK)
    293293                return;

  • uspace/srv/net/inetsrv/inetping.h

    r36f0738 rb7fd2a0  
    4242
    4343extern void inetping_conn(ipc_callid_t, ipc_call_t *, void *);
    44 extern int inetping_recv(uint16_t, inetping_sdu_t *);
     44extern errno_t inetping_recv(uint16_t, inetping_sdu_t *);
    4545
    4646#endif

  • uspace/srv/net/inetsrv/inetsrv.c

    r36f0738 rb7fd2a0  
    8484static void inet_default_conn(ipc_callid_t, ipc_call_t *, void *);
    8585
    86 static int inet_init(void)
     86static errno_t inet_init(void)
    8787{
    8888        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_init()");
    8989       
    9090        port_id_t port;
    91         int rc = async_create_port(INTERFACE_INET,
     91        errno_t rc = async_create_port(INTERFACE_INET,
    9292            inet_default_conn, NULL, &port);
    9393        if (rc != EOK)
    … …  
    135135}
    136136
    137 static int inet_find_dir(inet_addr_t *src, inet_addr_t *dest, uint8_t tos,
     137static errno_t inet_find_dir(inet_addr_t *src, inet_addr_t *dest, uint8_t tos,
    138138    inet_dir_t *dir)
    139139{
    … …  
    165165}
    166166
    167 int inet_route_packet(inet_dgram_t *dgram, uint8_t proto, uint8_t ttl,
     167errno_t inet_route_packet(inet_dgram_t *dgram, uint8_t proto, uint8_t ttl,
    168168    int df)
    169169{
    170170        inet_dir_t dir;
    171171        inet_link_t *ilink;
    172         int rc;
     172        errno_t rc;
    173173
    174174        if (dgram->iplink != 0) {
    … …  
    201201}
    202202
    203 static int inet_send(inet_client_t *client, inet_dgram_t *dgram,
     203static errno_t inet_send(inet_client_t *client, inet_dgram_t *dgram,
    204204    uint8_t proto, uint8_t ttl, int df)
    205205{
    … …  
    207207}
    208208
    209 int inet_get_srcaddr(inet_addr_t *remote, uint8_t tos, inet_addr_t *local)
     209errno_t inet_get_srcaddr(inet_addr_t *remote, uint8_t tos, inet_addr_t *local)
    210210{
    211211        inet_dir_t dir;
    212         int rc;
     212        errno_t rc;
    213213
    214214        rc = inet_find_dir(NULL, remote, tos, &dir);
    … …  
    252252       
    253253        inet_addr_t remote;
    254         int rc = async_data_write_finalize(callid, &remote, size);
     254        errno_t rc = async_data_write_finalize(callid, &remote, size);
    255255        if (rc != EOK) {
    256256                async_answer_0(callid, rc);
    … …  
    314314        }
    315315       
    316         int rc = async_data_write_finalize(callid, &dgram.src, size);
     316        errno_t rc = async_data_write_finalize(callid, &dgram.src, size);
    317317        if (rc != EOK) {
    318318                async_answer_0(callid, rc);
    … …  
    445445}
    446446
    447 int inet_ev_recv(inet_client_t *client, inet_dgram_t *dgram)
     447errno_t inet_ev_recv(inet_client_t *client, inet_dgram_t *dgram)
    448448{
    449449        async_exch_t *exch = async_exchange_begin(client->sess);
    … …  
    457457            dgram->iplink, &answer);
    458458
    459         int rc = async_data_write_start(exch, &dgram->src, sizeof(inet_addr_t));
     459        errno_t rc = async_data_write_start(exch, &dgram->src, sizeof(inet_addr_t));
    460460        if (rc != EOK) {
    461461                async_exchange_end(exch);
    … …  
    480480        }
    481481
    482         int retval;
     482        errno_t retval;
    483483        async_wait_for(req, &retval);
    484484
    … …  
    486486}
    487487
    488 int inet_recv_dgram_local(inet_dgram_t *dgram, uint8_t proto)
     488errno_t inet_recv_dgram_local(inet_dgram_t *dgram, uint8_t proto)
    489489{
    490490        inet_client_t *client;
    … …  
    509509}
    510510
    511 int inet_recv_packet(inet_packet_t *packet)
     511errno_t inet_recv_packet(inet_packet_t *packet)
    512512{
    513513        inet_addrobj_t *addr;
    … …  
    543543int main(int argc, char *argv[])
    544544{
    545         int rc;
     545        errno_t rc;
    546546
    547547        printf(NAME ": HelenOS Internet Protocol service\n");

  • uspace/srv/net/inetsrv/inetsrv.h

    r36f0738 rb7fd2a0  
    151151} inet_dir_t;
    152152
    153 extern int inet_ev_recv(inet_client_t *, inet_dgram_t *);
    154 extern int inet_recv_packet(inet_packet_t *);
    155 extern int inet_route_packet(inet_dgram_t *, uint8_t, uint8_t, int);
    156 extern int inet_get_srcaddr(inet_addr_t *, uint8_t, inet_addr_t *);
    157 extern int inet_recv_dgram_local(inet_dgram_t *, uint8_t);
     153extern errno_t inet_ev_recv(inet_client_t *, inet_dgram_t *);
     154extern errno_t inet_recv_packet(inet_packet_t *);
     155extern errno_t inet_route_packet(inet_dgram_t *, uint8_t, uint8_t, int);
     156extern errno_t inet_get_srcaddr(inet_addr_t *, uint8_t, inet_addr_t *);
     157extern errno_t inet_recv_dgram_local(inet_dgram_t *, uint8_t);
    158158
    159159#endif

  • uspace/srv/net/inetsrv/ndp.c

    r36f0738 rb7fd2a0  
    6464}
    6565
    66 static int ndp_send_packet(inet_link_t *link, ndp_packet_t *packet)
     66static errno_t ndp_send_packet(inet_link_t *link, ndp_packet_t *packet)
    6767{
    6868        inet_dgram_t dgram;
    … …  
    7777}
    7878
    79 static int ndp_router_advertisement(inet_dgram_t *dgram, inet_addr_t *router)
     79static errno_t ndp_router_advertisement(inet_dgram_t *dgram, inet_addr_t *router)
    8080{
    8181        // FIXME TODO
    … …  
    8383}
    8484
    85 int ndp_received(inet_dgram_t *dgram)
     85errno_t ndp_received(inet_dgram_t *dgram)
    8686{
    8787        log_msg(LOG_DEFAULT, LVL_DEBUG, "ndp_received()");
    8888       
    8989        ndp_packet_t packet;
    90         int rc = ndp_pdu_decode(dgram, &packet);
     90        errno_t rc = ndp_pdu_decode(dgram, &packet);
    9191        if (rc != EOK)
    9292                return rc;
    … …  
    151151 *
    152152 */
    153 int ndp_translate(addr128_t src_addr, addr128_t ip_addr, addr48_t mac_addr,
     153errno_t ndp_translate(addr128_t src_addr, addr128_t ip_addr, addr48_t mac_addr,
    154154    inet_link_t *ilink)
    155155{
    … …  
    160160        }
    161161       
    162         int rc = ntrans_lookup(ip_addr, mac_addr);
     162        errno_t rc = ntrans_lookup(ip_addr, mac_addr);
    163163        if (rc == EOK)
    164164                return EOK;

  • uspace/srv/net/inetsrv/ndp.h

    r36f0738 rb7fd2a0  
    6363} ndp_packet_t;
    6464
    65 extern int ndp_received(inet_dgram_t *);
    66 extern int ndp_translate(addr128_t, addr128_t, addr48_t, inet_link_t *);
     65extern errno_t ndp_received(inet_dgram_t *);
     66extern errno_t ndp_translate(addr128_t, addr128_t, addr48_t, inet_link_t *);
    6767
    6868#endif

  • uspace/srv/net/inetsrv/ntrans.c

    r36f0738 rb7fd2a0  
    7373 *
    7474 */
    75 int ntrans_add(addr128_t ip_addr, addr48_t mac_addr)
     75errno_t ntrans_add(addr128_t ip_addr, addr48_t mac_addr)
    7676{
    7777        inet_ntrans_t *ntrans;
    … …  
    107107 *
    108108 */
    109 int ntrans_remove(addr128_t ip_addr)
     109errno_t ntrans_remove(addr128_t ip_addr)
    110110{
    111111        inet_ntrans_t *ntrans;
    … …  
    134134 *
    135135 */
    136 int ntrans_lookup(addr128_t ip_addr, addr48_t mac_addr)
     136errno_t ntrans_lookup(addr128_t ip_addr, addr48_t mac_addr)
    137137{
    138138        fibril_mutex_lock(&ntrans_list_lock);
    … …  
    156156 *
    157157 */
    158 int ntrans_wait_timeout(suseconds_t timeout)
     158errno_t ntrans_wait_timeout(suseconds_t timeout)
    159159{
    160160        fibril_mutex_lock(&ntrans_list_lock);
    161         int rc = fibril_condvar_wait_timeout(&ntrans_cv, &ntrans_list_lock,
     161        errno_t rc = fibril_condvar_wait_timeout(&ntrans_cv, &ntrans_list_lock,
    162162            timeout);
    163163        fibril_mutex_unlock(&ntrans_list_lock);

  • uspace/srv/net/inetsrv/ntrans.h

    r36f0738 rb7fd2a0  
    4848} inet_ntrans_t;
    4949
    50 extern int ntrans_add(addr128_t, addr48_t);
    51 extern int ntrans_remove(addr128_t);
    52 extern int ntrans_lookup(addr128_t, addr48_t);
    53 extern int ntrans_wait_timeout(suseconds_t);
     50extern errno_t ntrans_add(addr128_t, addr48_t);
     51extern errno_t ntrans_remove(addr128_t);
     52extern errno_t ntrans_lookup(addr128_t, addr48_t);
     53extern errno_t ntrans_wait_timeout(suseconds_t);
    5454
    5555#endif

  • uspace/srv/net/inetsrv/pdu.c

    r36f0738 rb7fd2a0  
    102102 *
    103103 */
    104 int inet_pdu_encode(inet_packet_t *packet, addr32_t src, addr32_t dest,
     104errno_t inet_pdu_encode(inet_packet_t *packet, addr32_t src, addr32_t dest,
    105105    size_t offs, size_t mtu, void **rdata, size_t *rsize, size_t *roffs)
    106106{
    … …  
    194194 *
    195195 */
    196 int inet_pdu_encode6(inet_packet_t *packet, addr128_t src, addr128_t dest,
     196errno_t inet_pdu_encode6(inet_packet_t *packet, addr128_t src, addr128_t dest,
    197197    size_t offs, size_t mtu, void **rdata, size_t *rsize, size_t *roffs)
    198198{
    … …  
    308308 *
    309309 */
    310 int inet_pdu_decode(void *data, size_t size, service_id_t link_id,
     310errno_t inet_pdu_decode(void *data, size_t size, service_id_t link_id,
    311311    inet_packet_t *packet)
    312312{
    … …  
    385385 *
    386386 */
    387 int inet_pdu_decode6(void *data, size_t size, service_id_t link_id,
     387errno_t inet_pdu_decode6(void *data, size_t size, service_id_t link_id,
    388388    inet_packet_t *packet)
    389389{
    … …  
    474474 *
    475475 */
    476 int ndp_pdu_encode(ndp_packet_t *ndp, inet_dgram_t *dgram)
     476errno_t ndp_pdu_encode(ndp_packet_t *ndp, inet_dgram_t *dgram)
    477477{
    478478        inet_addr_set6(ndp->sender_proto_addr, &dgram->src);
    … …  
    535535 *
    536536 */
    537 int ndp_pdu_decode(inet_dgram_t *dgram, ndp_packet_t *ndp)
     537errno_t ndp_pdu_decode(inet_dgram_t *dgram, ndp_packet_t *ndp)
    538538{
    539539        ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL,

  • uspace/srv/net/inetsrv/pdu.h

    r36f0738 rb7fd2a0  
    4848extern uint16_t inet_checksum_calc(uint16_t, void *, size_t);
    4949
    50 extern int inet_pdu_encode(inet_packet_t *, addr32_t, addr32_t, size_t, size_t,
     50extern errno_t inet_pdu_encode(inet_packet_t *, addr32_t, addr32_t, size_t, size_t,
    5151    void **, size_t *, size_t *);
    52 extern int inet_pdu_encode6(inet_packet_t *, addr128_t, addr128_t, size_t,
     52extern errno_t inet_pdu_encode6(inet_packet_t *, addr128_t, addr128_t, size_t,
    5353    size_t, void **, size_t *, size_t *);
    54 extern int inet_pdu_decode(void *, size_t, service_id_t, inet_packet_t *);
    55 extern int inet_pdu_decode6(void *, size_t, service_id_t, inet_packet_t *);
     54extern errno_t inet_pdu_decode(void *, size_t, service_id_t, inet_packet_t *);
     55extern errno_t inet_pdu_decode6(void *, size_t, service_id_t, inet_packet_t *);
    5656
    57 extern int ndp_pdu_decode(inet_dgram_t *, ndp_packet_t *);
    58 extern int ndp_pdu_encode(ndp_packet_t *, inet_dgram_t *);
     57extern errno_t ndp_pdu_decode(inet_dgram_t *, ndp_packet_t *);
     58extern errno_t ndp_pdu_encode(ndp_packet_t *, inet_dgram_t *);
    5959
    6060#endif

  • uspace/srv/net/inetsrv/reass.c

    r36f0738 rb7fd2a0  
    7070static reass_dgram_t *reass_dgram_new(void);
    7171static reass_dgram_t *reass_dgram_get(inet_packet_t *);
    72 static int reass_dgram_insert_frag(reass_dgram_t *, inet_packet_t *);
     72static errno_t reass_dgram_insert_frag(reass_dgram_t *, inet_packet_t *);
    7373static bool reass_dgram_complete(reass_dgram_t *);
    7474static void reass_dgram_remove(reass_dgram_t *);
    75 static int reass_dgram_deliver(reass_dgram_t *);
     75static errno_t reass_dgram_deliver(reass_dgram_t *);
    7676static void reass_dgram_destroy(reass_dgram_t *);
    7777
    … …  
    8181 * @return              EOK on success or ENOMEM.
    8282 */
    83 int inet_reass_queue_packet(inet_packet_t *packet)
     83errno_t inet_reass_queue_packet(inet_packet_t *packet)
    8484{
    8585        reass_dgram_t *rdg;
    86         int rc;
     86        errno_t rc;
    8787
    8888        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_reass_queue_packet()");
    … …  
    180180}
    181181
    182 static int reass_dgram_insert_frag(reass_dgram_t *rdg, inet_packet_t *packet)
     182static errno_t reass_dgram_insert_frag(reass_dgram_t *rdg, inet_packet_t *packet)
    183183{
    184184        reass_frag_t *frag;
    … …  
    290290 * @param rdg           Datagram reassembly structure.
    291291 */
    292 static int reass_dgram_deliver(reass_dgram_t *rdg)
     292static errno_t reass_dgram_deliver(reass_dgram_t *rdg)
    293293{
    294294        size_t dgram_size;
    … …  
    297297        uint8_t proto;
    298298        reass_frag_t *frag;
    299         int rc;
     299        errno_t rc;
    300300
    301301        /*

  • uspace/srv/net/inetsrv/reass.h

    r36f0738 rb7fd2a0  
    4040#include "inetsrv.h"
    4141
    42 extern int inet_reass_queue_packet(inet_packet_t *);
     42extern errno_t inet_reass_queue_packet(inet_packet_t *);
    4343
    4444#endif

  • uspace/srv/net/inetsrv/sroute.c

    r36f0738 rb7fd2a0  
    183183
    184184/** Get IDs of all static routes. */
    185 int inet_sroute_get_id_list(sysarg_t **rid_list, size_t *rcount)
     185errno_t inet_sroute_get_id_list(sysarg_t **rid_list, size_t *rcount)
    186186{
    187187        sysarg_t *id_list;

  • uspace/srv/net/inetsrv/sroute.h

    r36f0738 rb7fd2a0  
    4949extern inet_sroute_t *inet_sroute_find_by_name(const char *);
    5050extern inet_sroute_t *inet_sroute_get_by_id(sysarg_t);
    51 extern int inet_sroute_send_dgram(inet_sroute_t *, inet_addr_t *,
     51extern errno_t inet_sroute_send_dgram(inet_sroute_t *, inet_addr_t *,
    5252    inet_dgram_t *, uint8_t, uint8_t, int);
    53 extern int inet_sroute_get_id_list(sysarg_t **, size_t *);
     53extern errno_t inet_sroute_get_id_list(sysarg_t **, size_t *);
    5454
    5555

  • uspace/srv/net/loopip/loopip.c

    r36f0738 rb7fd2a0  
    4949#define NAME  "loopip"
    5050
    51 static int loopip_open(iplink_srv_t *srv);
    52 static int loopip_close(iplink_srv_t *srv);
    53 static int loopip_send(iplink_srv_t *srv, iplink_sdu_t *sdu);
    54 static int loopip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu);
    55 static int loopip_get_mtu(iplink_srv_t *srv, size_t *mtu);
    56 static int loopip_get_mac48(iplink_srv_t *srv, addr48_t *mac);
    57 static int loopip_addr_add(iplink_srv_t *srv, inet_addr_t *addr);
    58 static int loopip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr);
     51static errno_t loopip_open(iplink_srv_t *srv);
     52static errno_t loopip_close(iplink_srv_t *srv);
     53static errno_t loopip_send(iplink_srv_t *srv, iplink_sdu_t *sdu);
     54static errno_t loopip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu);
     55static errno_t loopip_get_mtu(iplink_srv_t *srv, size_t *mtu);
     56static errno_t loopip_get_mac48(iplink_srv_t *srv, addr48_t *mac);
     57static errno_t loopip_addr_add(iplink_srv_t *srv, inet_addr_t *addr);
     58static errno_t loopip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr);
    5959
    6060static void loopip_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    … …  
    8282} rqueue_entry_t;
    8383
    84 static int loopip_recv_fibril(void *arg)
     84static errno_t loopip_recv_fibril(void *arg)
    8585{
    8686        while (true) {
    … …  
    9999}
    100100
    101 static int loopip_init(void)
     101static errno_t loopip_init(void)
    102102{
    103103        async_set_fallback_port_handler(loopip_client_conn, NULL);
    104104       
    105         int rc = loc_server_register(NAME);
     105        errno_t rc = loc_server_register(NAME);
    106106        if (rc != EOK) {
    107107                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server.");
    … …  
    153153}
    154154
    155 static int loopip_open(iplink_srv_t *srv)
     155static errno_t loopip_open(iplink_srv_t *srv)
    156156{
    157157        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_open()");
    … …  
    159159}
    160160
    161 static int loopip_close(iplink_srv_t *srv)
     161static errno_t loopip_close(iplink_srv_t *srv)
    162162{
    163163        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_close()");
    … …  
    165165}
    166166
    167 static int loopip_send(iplink_srv_t *srv, iplink_sdu_t *sdu)
     167static errno_t loopip_send(iplink_srv_t *srv, iplink_sdu_t *sdu)
    168168{
    169169        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_send()");
    … …  
    194194}
    195195
    196 static int loopip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu)
     196static errno_t loopip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu)
    197197{
    198198        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip6_send()");
    … …  
    223223}
    224224
    225 static int loopip_get_mtu(iplink_srv_t *srv, size_t *mtu)
     225static errno_t loopip_get_mtu(iplink_srv_t *srv, size_t *mtu)
    226226{
    227227        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_get_mtu()");
    … …  
    230230}
    231231
    232 static int loopip_get_mac48(iplink_srv_t *src, addr48_t *mac)
     232static errno_t loopip_get_mac48(iplink_srv_t *src, addr48_t *mac)
    233233{
    234234        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_get_mac48()");
    … …  
    236236}
    237237
    238 static int loopip_addr_add(iplink_srv_t *srv, inet_addr_t *addr)
    239 {
    240         return EOK;
    241 }
    242 
    243 static int loopip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr)
     238static errno_t loopip_addr_add(iplink_srv_t *srv, inet_addr_t *addr)
     239{
     240        return EOK;
     241}
     242
     243static errno_t loopip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr)
    244244{
    245245        return EOK;
    … …  
    250250        printf("%s: HelenOS loopback IP link provider\n", NAME);
    251251       
    252         int rc = log_init(NAME);
     252        errno_t rc = log_init(NAME);
    253253        if (rc != EOK) {
    254254                printf("%s: Failed to initialize logging: %s.\n", NAME, str_error(rc));

  • uspace/srv/net/nconfsrv/iplink.c

    r36f0738 rb7fd2a0  
    4949#include "nconfsrv.h"
    5050
    51 static int ncs_link_add(service_id_t);
     51static errno_t ncs_link_add(service_id_t);
    5252
    5353static LIST_INITIALIZE(ncs_links);
    5454static FIBRIL_MUTEX_INITIALIZE(ncs_links_lock);
    5555
    56 static int ncs_link_check_new(void)
     56static errno_t ncs_link_check_new(void)
    5757{
    5858        bool already_known;
    … …  
    6060        service_id_t *svcs;
    6161        size_t count, i;
    62         int rc;
     62        errno_t rc;
    6363
    6464        fibril_mutex_lock(&ncs_links_lock);
    … …  
    124124}
    125125
    126 static int ncs_link_add(service_id_t sid)
     126static errno_t ncs_link_add(service_id_t sid)
    127127{
    128128        ncs_link_t *nlink;
    129         int rc;
     129        errno_t rc;
    130130
    131131        assert(fibril_mutex_is_locked(&ncs_links_lock));
    … …  
    175175}
    176176
    177 int ncs_link_discovery_start(void)
    178 {
    179         int rc;
     177errno_t ncs_link_discovery_start(void)
     178{
     179        errno_t rc;
    180180
    181181        rc = loc_register_cat_change_cb(ncs_link_cat_change_cb);
    … …  
    205205
    206206/** Get IDs of all links. */
    207 int ncs_link_get_id_list(sysarg_t **rid_list, size_t *rcount)
     207errno_t ncs_link_get_id_list(sysarg_t **rid_list, size_t *rcount)
    208208{
    209209        sysarg_t *id_list;

  • uspace/srv/net/nconfsrv/iplink.h

    r36f0738 rb7fd2a0  
    4141#include "nconfsrv.h"
    4242
    43 extern int ncs_link_discovery_start(void);
     43extern errno_t ncs_link_discovery_start(void);
    4444extern ncs_link_t *ncs_link_get_by_id(sysarg_t);
    45 extern int ncs_link_get_id_list(sysarg_t **, size_t *);
     45extern errno_t ncs_link_get_id_list(sysarg_t **, size_t *);
    4646
    4747#endif

  • uspace/srv/net/nconfsrv/nconfsrv.c

    r36f0738 rb7fd2a0  
    5656static void ncs_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    5757
    58 static int ncs_init(void)
     58static errno_t ncs_init(void)
    5959{
    6060        service_id_t sid;
    61         int rc;
     61        errno_t rc;
    6262
    6363        log_msg(LOG_DEFAULT, LVL_DEBUG, "ncs_init()");
    … …  
    105105int main(int argc, char *argv[])
    106106{
    107         int rc;
     107        errno_t rc;
    108108
    109109        printf(NAME ": HelenOS Network configuration service\n");

  • uspace/srv/net/slip/slip.c

    r36f0738 rb7fd2a0  
    5757#define SLIP_ESC_ESC    0335
    5858
    59 static int slip_open(iplink_srv_t *);
    60 static int slip_close(iplink_srv_t *);
    61 static int slip_send(iplink_srv_t *, iplink_sdu_t *);
    62 static int slip_send6(iplink_srv_t *, iplink_sdu6_t *);
    63 static int slip_get_mtu(iplink_srv_t *, size_t *);
    64 static int slip_get_mac48(iplink_srv_t *, addr48_t *);
    65 static int slip_addr_add(iplink_srv_t *, inet_addr_t *);
    66 static int slip_addr_remove(iplink_srv_t *, inet_addr_t *);
     59static errno_t slip_open(iplink_srv_t *);
     60static errno_t slip_close(iplink_srv_t *);
     61static errno_t slip_send(iplink_srv_t *, iplink_sdu_t *);
     62static errno_t slip_send6(iplink_srv_t *, iplink_sdu6_t *);
     63static errno_t slip_get_mtu(iplink_srv_t *, size_t *);
     64static errno_t slip_get_mac48(iplink_srv_t *, addr48_t *);
     65static errno_t slip_addr_add(iplink_srv_t *, inet_addr_t *);
     66static errno_t slip_addr_remove(iplink_srv_t *, inet_addr_t *);
    6767
    6868static iplink_srv_t slip_iplink;
    … …  
    8686static size_t slip_recv_read;
    8787
    88 int slip_open(iplink_srv_t *srv)
     88errno_t slip_open(iplink_srv_t *srv)
    8989{
    9090        log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_open()");
    … …  
    9292}
    9393
    94 int slip_close(iplink_srv_t *srv)
     94errno_t slip_close(iplink_srv_t *srv)
    9595{
    9696        log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_close()");
    … …  
    103103
    104104        while (slip_send_pending > 0) {
    105                 int rc;
     105                errno_t rc;
    106106                size_t nwr;
    107107
    … …  
    126126}
    127127
    128 int slip_send(iplink_srv_t *srv, iplink_sdu_t *sdu)
     128errno_t slip_send(iplink_srv_t *srv, iplink_sdu_t *sdu)
    129129{
    130130        log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_send()");
    … …  
    162162}
    163163
    164 int slip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu)
     164errno_t slip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu)
    165165{
    166166        log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_send6()");
    … …  
    169169}
    170170
    171 int slip_get_mtu(iplink_srv_t *srv, size_t *mtu)
     171errno_t slip_get_mtu(iplink_srv_t *srv, size_t *mtu)
    172172{
    173173        log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_get_mtu()");
    … …  
    176176}
    177177
    178 int slip_get_mac48(iplink_srv_t *src, addr48_t *mac)
     178errno_t slip_get_mac48(iplink_srv_t *src, addr48_t *mac)
    179179{
    180180        log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_get_mac48()");
    … …  
    182182}
    183183
    184 int slip_addr_add(iplink_srv_t *srv, inet_addr_t *addr)
     184errno_t slip_addr_add(iplink_srv_t *srv, inet_addr_t *addr)
    185185{
    186186        log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_addr_add()");
    … …  
    188188}
    189189
    190 int slip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr)
     190errno_t slip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr)
    191191{
    192192        log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_addr_remove()");
    … …  
    208208{
    209209        while (slip_recv_pending == 0) {
    210                 int rc;
     210                errno_t rc;
    211211                size_t nread;
    212212
    … …  
    228228}
    229229
    230 static int slip_recv_fibril(void *arg)
     230static errno_t slip_recv_fibril(void *arg)
    231231{
    232232        chardev_t *chardev = (chardev_t *) arg;
    … …  
    234234        iplink_recv_sdu_t sdu;
    235235        uint8_t ch;
    236         int rc;
     236        errno_t rc;
    237237
    238238        sdu.data = recv_final;
    … …  
    294294}
    295295
    296 static int slip_init(const char *svcstr, const char *linkstr)
     296static errno_t slip_init(const char *svcstr, const char *linkstr)
    297297{
    298298        service_id_t svcid;
    … …  
    304304        chardev_t *chardev_out = NULL;
    305305        fid_t fid;
    306         int rc;
     306        errno_t rc;
    307307
    308308        iplink_srv_init(&slip_iplink);
    … …  
    415415int main(int argc, char *argv[])
    416416{
    417         int rc;
     417        errno_t rc;
    418418
    419419        printf(NAME ": IP over serial line service\n");

  • uspace/srv/net/tcp/conn.c

    r36f0738 rb7fd2a0  
    8484
    8585/** Initialize connections. */
    86 int tcp_conns_init(void)
    87 {
    88         int rc;
     86errno_t tcp_conns_init(void)
     87{
     88        errno_t rc;
    8989
    9090        rc = amap_create(&amap);
    … …  
    303303 * Add connection to the connection map.
    304304 */
    305 int tcp_conn_add(tcp_conn_t *conn)
     305errno_t tcp_conn_add(tcp_conn_t *conn)
    306306{
    307307        inet_ep2_t aepp;
    308         int rc;
     308        errno_t rc;
    309309
    310310        tcp_conn_addref(conn);
    … …  
    425425tcp_conn_t *tcp_conn_find_ref(inet_ep2_t *epp)
    426426{
    427         int rc;
     427        errno_t rc;
    428428        void *arg;
    429429        tcp_conn_t *conn;
    … …  
    12421242        inet_ep2_t aepp;
    12431243        inet_ep2_t oldepp;
    1244         int rc;
     1244        errno_t rc;
    12451245
    12461246        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_segment_arrived(%p)",

  • uspace/srv/net/tcp/conn.h

    r36f0738 rb7fd2a0  
    4040#include "tcp_type.h"
    4141
    42 extern int tcp_conns_init(void);
     42extern errno_t tcp_conns_init(void);
    4343extern void tcp_conns_fini(void);
    4444extern tcp_conn_t *tcp_conn_new(inet_ep2_t *);
    4545extern void tcp_conn_delete(tcp_conn_t *);
    46 extern int tcp_conn_add(tcp_conn_t *);
     46extern errno_t tcp_conn_add(tcp_conn_t *);
    4747extern void tcp_conn_reset(tcp_conn_t *conn);
    4848extern void tcp_conn_sync(tcp_conn_t *);

  • uspace/srv/net/tcp/inet.c

    r36f0738 rb7fd2a0  
    5050#define NAME       "tcp"
    5151
    52 static int tcp_inet_ev_recv(inet_dgram_t *dgram);
     52static errno_t tcp_inet_ev_recv(inet_dgram_t *dgram);
    5353static void tcp_received_pdu(tcp_pdu_t *pdu);
    5454
    … …  
    5858
    5959/** Received datagram callback */
    60 static int tcp_inet_ev_recv(inet_dgram_t *dgram)
     60static errno_t tcp_inet_ev_recv(inet_dgram_t *dgram)
    6161{
    6262        uint8_t *pdu_raw;
    … …  
    121121void tcp_transmit_pdu(tcp_pdu_t *pdu)
    122122{
    123         int rc;
     123        errno_t rc;
    124124        uint8_t *pdu_raw;
    125125        size_t pdu_raw_size;
    … …  
    169169
    170170/** Initialize TCP inet interface. */
    171 int tcp_inet_init(void)
     171errno_t tcp_inet_init(void)
    172172{
    173         int rc;
     173        errno_t rc;
    174174
    175175        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_inet_init()");

  • uspace/srv/net/tcp/inet.h

    r36f0738 rb7fd2a0  
    3838#include "tcp_type.h"
    3939
    40 extern int tcp_inet_init(void);
     40extern errno_t tcp_inet_init(void);
    4141extern void tcp_transmit_pdu(tcp_pdu_t *);
    4242

  • uspace/srv/net/tcp/iqueue.c

    r36f0738 rb7fd2a0  
    137137 * @return              EOK on success, ENOENT if no segment is ready
    138138 */
    139 int tcp_iqueue_get_ready_seg(tcp_iqueue_t *iqueue, tcp_segment_t **seg)
     139errno_t tcp_iqueue_get_ready_seg(tcp_iqueue_t *iqueue, tcp_segment_t **seg)
    140140{
    141141        tcp_iqueue_entry_t *iqe;

  • uspace/srv/net/tcp/iqueue.h

    r36f0738 rb7fd2a0  
    4141extern void tcp_iqueue_insert_seg(tcp_iqueue_t *, tcp_segment_t *);
    4242extern void tcp_iqueue_remove_seg(tcp_iqueue_t *, tcp_segment_t *);
    43 extern int tcp_iqueue_get_ready_seg(tcp_iqueue_t *, tcp_segment_t **);
     43extern errno_t tcp_iqueue_get_ready_seg(tcp_iqueue_t *, tcp_segment_t **);
    4444
    4545#endif

  • uspace/srv/net/tcp/ncsim.c

    r36f0738 rb7fd2a0  
    123123
    124124/** Network condition simulator handler fibril. */
    125 static int tcp_ncsim_fibril(void *arg)
     125static errno_t tcp_ncsim_fibril(void *arg)
    126126{
    127127        link_t *link;
    128128        tcp_squeue_entry_t *sqe;
    129129        inet_ep2_t rident;
    130         int rc;
     130        errno_t rc;
    131131
    132132        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ncsim_fibril()");

  • uspace/srv/net/tcp/pdu.c

    r36f0738 rb7fd2a0  
    191191}
    192192
    193 static int tcp_header_encode(inet_ep2_t *epp, tcp_segment_t *seg,
     193static errno_t tcp_header_encode(inet_ep2_t *epp, tcp_segment_t *seg,
    194194    void **header, size_t *size)
    195195{
    … …  
    295295
    296296/** Decode incoming PDU */
    297 int tcp_pdu_decode(tcp_pdu_t *pdu, inet_ep2_t *epp, tcp_segment_t **seg)
     297errno_t tcp_pdu_decode(tcp_pdu_t *pdu, inet_ep2_t *epp, tcp_segment_t **seg)
    298298{
    299299        tcp_segment_t *nseg;
    … …  
    319319
    320320/** Encode outgoing PDU */
    321 int tcp_pdu_encode(inet_ep2_t *epp, tcp_segment_t *seg, tcp_pdu_t **pdu)
     321errno_t tcp_pdu_encode(inet_ep2_t *epp, tcp_segment_t *seg, tcp_pdu_t **pdu)
    322322{
    323323        tcp_pdu_t *npdu;
    324324        size_t text_size;
    325325        uint16_t checksum;
    326         int rc;
     326        errno_t rc;
    327327
    328328        npdu = tcp_pdu_new();

  • uspace/srv/net/tcp/pdu.h

    r36f0738 rb7fd2a0  
    4343extern tcp_pdu_t *tcp_pdu_create(void *, size_t, void *, size_t);
    4444extern void tcp_pdu_delete(tcp_pdu_t *);
    45 extern int tcp_pdu_decode(tcp_pdu_t *, inet_ep2_t *, tcp_segment_t **);
    46 extern int tcp_pdu_encode(inet_ep2_t *, tcp_segment_t *, tcp_pdu_t **);
     45extern errno_t tcp_pdu_decode(tcp_pdu_t *, inet_ep2_t *, tcp_segment_t **);
     46extern errno_t tcp_pdu_encode(inet_ep2_t *, tcp_segment_t *, tcp_pdu_t **);
    4747
    4848#endif

  • uspace/srv/net/tcp/rqueue.c

    r36f0738 rb7fd2a0  
    105105
    106106/** Receive queue handler fibril. */
    107 static int tcp_rqueue_fibril(void *arg)
     107static errno_t tcp_rqueue_fibril(void *arg)
    108108{
    109109        link_t *link;

  • uspace/srv/net/tcp/service.c

    r36f0738 rb7fd2a0  
    6868static void tcp_service_lst_cstate_change(tcp_conn_t *, void *, tcp_cstate_t);
    6969
    70 static int tcp_cconn_create(tcp_client_t *, tcp_conn_t *, tcp_cconn_t **);
     70static errno_t tcp_cconn_create(tcp_client_t *, tcp_conn_t *, tcp_cconn_t **);
    7171
    7272/** Connection callbacks to tie us to lower layer */
    … …  
    132132        tcp_cconn_t *cconn;
    133133        inet_ep2_t epp;
    134         int rc;
     134        errno_t rc;
    135135        tcp_error_t trc;
    136136
    … …  
    298298 * @return EOK on success or ENOMEM if out of memory
    299299 */
    300 static int tcp_cconn_create(tcp_client_t *client, tcp_conn_t *conn,
     300static errno_t tcp_cconn_create(tcp_client_t *client, tcp_conn_t *conn,
    301301    tcp_cconn_t **rcconn)
    302302{
    … …  
    345345 * @return EOK on success or ENOMEM if out of memory
    346346 */
    347 static int tcp_clistener_create(tcp_client_t *client, tcp_conn_t *conn,
     347static errno_t tcp_clistener_create(tcp_client_t *client, tcp_conn_t *conn,
    348348    tcp_clst_t **rclst)
    349349{
    … …  
    390390 *         is found.
    391391 */
    392 static int tcp_cconn_get(tcp_client_t *client, sysarg_t id,
     392static errno_t tcp_cconn_get(tcp_client_t *client, sysarg_t id,
    393393    tcp_cconn_t **rcconn)
    394394{
    … …  
    412412 *         is found.
    413413 */
    414 static int tcp_clistener_get(tcp_client_t *client, sysarg_t id,
     414static errno_t tcp_clistener_get(tcp_client_t *client, sysarg_t id,
    415415    tcp_clst_t **rclst)
    416416{
    … …  
    435435 * @return EOK on success or an error code
    436436 */
    437 static int tcp_conn_create_impl(tcp_client_t *client, inet_ep2_t *epp,
     437static errno_t tcp_conn_create_impl(tcp_client_t *client, inet_ep2_t *epp,
    438438    sysarg_t *rconn_id)
    439439{
    440440        tcp_conn_t *conn;
    441441        tcp_cconn_t *cconn;
    442         int rc;
     442        errno_t rc;
    443443        tcp_error_t trc;
    444444        char *slocal;
    … …  
    482482 * @return EOK on success, ENOENT if no such connection is found
    483483 */
    484 static int tcp_conn_destroy_impl(tcp_client_t *client, sysarg_t conn_id)
     484static errno_t tcp_conn_destroy_impl(tcp_client_t *client, sysarg_t conn_id)
    485485{
    486486        tcp_cconn_t *cconn;
    487         int rc;
     487        errno_t rc;
    488488
    489489        rc = tcp_cconn_get(client, conn_id, &cconn);
    … …  
    509509 * @return EOK on success or an error code
    510510*/
    511 static int tcp_listener_create_impl(tcp_client_t *client, inet_ep_t *ep,
     511static errno_t tcp_listener_create_impl(tcp_client_t *client, inet_ep_t *ep,
    512512    sysarg_t *rlst_id)
    513513{
    … …  
    515515        tcp_clst_t *clst;
    516516        inet_ep2_t epp;
    517         int rc;
     517        errno_t rc;
    518518        tcp_error_t trc;
    519519
    … …  
    555555 * @return EOK on success, ENOENT if no such listener is found
    556556 */
    557 static int tcp_listener_destroy_impl(tcp_client_t *client, sysarg_t lst_id)
     557static errno_t tcp_listener_destroy_impl(tcp_client_t *client, sysarg_t lst_id)
    558558{
    559559        tcp_clst_t *clst;
    560         int rc;
     560        errno_t rc;
    561561
    562562        rc = tcp_clistener_get(client, lst_id, &clst);
    … …  
    580580 * @return EOK on success or an error code
    581581 */
    582 static int tcp_conn_send_fin_impl(tcp_client_t *client, sysarg_t conn_id)
     582static errno_t tcp_conn_send_fin_impl(tcp_client_t *client, sysarg_t conn_id)
    583583{
    584584        tcp_cconn_t *cconn;
    585         int rc;
     585        errno_t rc;
    586586
    587587        rc = tcp_cconn_get(client, conn_id, &cconn);
    … …  
    605605 * @return EOK on success or an error code
    606606 */
    607 static int tcp_conn_push_impl(tcp_client_t *client, sysarg_t conn_id)
     607static errno_t tcp_conn_push_impl(tcp_client_t *client, sysarg_t conn_id)
    608608{
    609609        tcp_cconn_t *cconn;
    610         int rc;
     610        errno_t rc;
    611611
    612612        rc = tcp_cconn_get(client, conn_id, &cconn);
    … …  
    630630 * @return EOK on success or an error code
    631631 */
    632 static int tcp_conn_reset_impl(tcp_client_t *client, sysarg_t conn_id)
     632static errno_t tcp_conn_reset_impl(tcp_client_t *client, sysarg_t conn_id)
    633633{
    634634        tcp_cconn_t *cconn;
    635         int rc;
     635        errno_t rc;
    636636
    637637        rc = tcp_cconn_get(client, conn_id, &cconn);
    … …  
    656656 * @return EOK on success or an error code
    657657 */
    658 static int tcp_conn_send_impl(tcp_client_t *client, sysarg_t conn_id,
     658static errno_t tcp_conn_send_impl(tcp_client_t *client, sysarg_t conn_id,
    659659    void *data, size_t size)
    660660{
    661661        tcp_cconn_t *cconn;
    662         int rc;
     662        errno_t rc;
    663663        tcp_error_t trc;
    664664
    … …  
    686686 * @return EOK on success or an error code
    687687 */
    688 static int tcp_conn_recv_impl(tcp_client_t *client, sysarg_t conn_id,
     688static errno_t tcp_conn_recv_impl(tcp_client_t *client, sysarg_t conn_id,
    689689    void *data, size_t size, size_t *nrecv)
    690690{
    691691        tcp_cconn_t *cconn;
    692692        xflags_t xflags;
    693         int rc;
     693        errno_t rc;
    694694        tcp_error_t trc;
    695695
    … …  
    758758        inet_ep2_t epp;
    759759        sysarg_t conn_id;
    760         int rc;
     760        errno_t rc;
    761761
    762762        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create_srv()");
    … …  
    802802{
    803803        sysarg_t conn_id;
    804         int rc;
     804        errno_t rc;
    805805
    806806        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_destroy_srv()");
    … …  
    826826        inet_ep_t ep;
    827827        sysarg_t lst_id;
    828         int rc;
     828        errno_t rc;
    829829
    830830        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_listener_create_srv()");
    … …  
    870870{
    871871        sysarg_t lst_id;
    872         int rc;
     872        errno_t rc;
    873873
    874874        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_listener_destroy_srv()");
    … …  
    891891{
    892892        sysarg_t conn_id;
    893         int rc;
     893        errno_t rc;
    894894
    895895        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_send_fin_srv()");
    … …  
    912912{
    913913        sysarg_t conn_id;
    914         int rc;
     914        errno_t rc;
    915915
    916916        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_push_srv()");
    … …  
    933933{
    934934        sysarg_t conn_id;
    935         int rc;
     935        errno_t rc;
    936936
    937937        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_reset_srv()");
    … …  
    957957        sysarg_t conn_id;
    958958        void *data;
    959         int rc;
     959        errno_t rc;
    960960
    961961        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_send_srv())");
    … …  
    10181018        size_t size, rsize;
    10191019        void *data;
    1020         int rc;
     1020        errno_t rc;
    10211021
    10221022        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_srv()");
    … …  
    10741074        size_t size, rsize;
    10751075        void *data;
    1076         int rc;
     1076        errno_t rc;
    10771077
    10781078        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv()");
    … …  
    12461246 * @return EOK on success or an error code.
    12471247 */
    1248 int tcp_service_init(void)
    1249 {
    1250         int rc;
     1248errno_t tcp_service_init(void)
     1249{
     1250        errno_t rc;
    12511251        service_id_t sid;
    12521252

  • uspace/srv/net/tcp/service.h

    r36f0738 rb7fd2a0  
    3636#define SERVICE_H
    3737
    38 extern int tcp_service_init(void);
     38extern errno_t tcp_service_init(void);
    3939
    4040#endif

  • uspace/srv/net/tcp/tcp.c

    r36f0738 rb7fd2a0  
    5555};
    5656
    57 static int tcp_init(void)
     57static errno_t tcp_init(void)
    5858{
    59         int rc;
     59        errno_t rc;
    6060
    6161        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_init()");
    … …  
    9191int main(int argc, char **argv)
    9292{
    93         int rc;
     93        errno_t rc;
    9494
    9595        printf(NAME ": TCP (Transmission Control Protocol) network module\n");

  • uspace/srv/net/tcp/test.c

    r36f0738 rb7fd2a0  
    4747#define RCV_BUF_SIZE 64
    4848
    49 static int test_srv(void *arg)
     49static errno_t test_srv(void *arg)
    5050{
    5151        tcp_conn_t *conn;
    … …  
    9191}
    9292
    93 static int test_cli(void *arg)
     93static errno_t test_cli(void *arg)
    9494{
    9595        tcp_conn_t *conn;

  • uspace/srv/net/tcp/test/conn.c

    r36f0738 rb7fd2a0  
    4646PCUT_TEST_BEFORE
    4747{
    48         int rc;
     48        errno_t rc;
    4949
    5050        /* We will be calling functions that perform logging */
    … …  
    8989        tcp_conn_t *conn, *cfound;
    9090        inet_ep2_t epp;
    91         int rc;
     91        errno_t rc;
    9292
    9393        inet_ep2_init(&epp);
    … …  
    119119        tcp_conn_t *conn;
    120120        inet_ep2_t epp;
    121         int rc;
     121        errno_t rc;
    122122
    123123        inet_ep2_init(&epp);
    … …  
    152152        tcp_conn_t *cconn, *sconn;
    153153        inet_ep2_t cepp, sepp;
    154         int rc;
     154        errno_t rc;
    155155
    156156        /* Client EPP */

  • uspace/srv/net/tcp/test/iqueue.c

    r36f0738 rb7fd2a0  
    4545        inet_ep2_t epp;
    4646        tcp_segment_t *rseg;
    47         int rc;
     47        errno_t rc;
    4848
    4949        inet_ep2_init(&epp);
    … …  
    7171        void *data;
    7272        size_t dsize;
    73         int rc;
     73        errno_t rc;
    7474
    7575        inet_ep2_init(&epp);
    … …  
    117117        void *data;
    118118        size_t dsize;
    119         int rc;
     119        errno_t rc;
    120120
    121121        inet_ep2_init(&epp);

  • uspace/srv/net/tcp/test/pdu.c

    r36f0738 rb7fd2a0  
    4747        tcp_pdu_t *pdu;
    4848        inet_ep2_t epp, depp;
    49         int rc;
     49        errno_t rc;
    5050
    5151        inet_ep2_init(&epp);
    … …  
    7878        uint8_t *data;
    7979        size_t i, dsize;
    80         int rc;
     80        errno_t rc;
    8181
    8282        inet_ep2_init(&epp);

  • uspace/srv/net/tcp/test/rqueue.c

    r36f0738 rb7fd2a0  
    5959PCUT_TEST_BEFORE
    6060{
    61         int rc;
     61        errno_t rc;
    6262
    6363        /* We will be calling functions that perform logging */

  • uspace/srv/net/tcp/test/tqueue.c

    r36f0738 rb7fd2a0  
    5353PCUT_TEST_BEFORE
    5454{
    55         int rc;
     55        errno_t rc;
    5656
    5757        /* We will be calling functions that perform logging */

  • uspace/srv/net/tcp/test/ucall.c

    r36f0738 rb7fd2a0  
    6060PCUT_TEST_BEFORE
    6161{
    62         int rc;
     62        errno_t rc;
    6363
    6464        /* We will be calling functions that perform logging */

  • uspace/srv/net/tcp/tqueue.c

    r36f0738 rb7fd2a0  
    6363static void tcp_tqueue_send_immed(tcp_conn_t *, tcp_segment_t *);
    6464
    65 int tcp_tqueue_init(tcp_tqueue_t *tqueue, tcp_conn_t *conn,
     65errno_t tcp_tqueue_init(tcp_tqueue_t *tqueue, tcp_conn_t *conn,
    6666    tcp_tqueue_cb_t *cb)
    6767{

  • uspace/srv/net/tcp/tqueue.h

    r36f0738 rb7fd2a0  
    4040#include "tcp_type.h"
    4141
    42 extern int tcp_tqueue_init(tcp_tqueue_t *, tcp_conn_t *,
     42extern errno_t tcp_tqueue_init(tcp_tqueue_t *, tcp_conn_t *,
    4343    tcp_tqueue_cb_t *);
    4444extern void tcp_tqueue_clear(tcp_tqueue_t *);

  • uspace/srv/net/tcp/ucall.c

    r36f0738 rb7fd2a0  
    6969{
    7070        tcp_conn_t *nconn;
    71         int rc;
     71        errno_t rc;
    7272
    7373        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open(%p, %s, %s, %p)",

  • uspace/srv/net/udp/assoc.c

    r36f0738 rb7fd2a0  
    5656
    5757static udp_assoc_t *udp_assoc_find_ref(inet_ep2_t *);
    58 static int udp_assoc_queue_msg(udp_assoc_t *, inet_ep2_t *, udp_msg_t *);
     58static errno_t udp_assoc_queue_msg(udp_assoc_t *, inet_ep2_t *, udp_msg_t *);
    5959
    6060/** Initialize associations. */
    61 int udp_assocs_init(void)
    62 {
    63         int rc;
     61errno_t udp_assocs_init(void)
     62{
     63        errno_t rc;
    6464
    6565        rc = amap_create(&amap);
    … …  
    182182 * Add association to the association map.
    183183 */
    184 int udp_assoc_add(udp_assoc_t *assoc)
     184errno_t udp_assoc_add(udp_assoc_t *assoc)
    185185{
    186186        inet_ep2_t aepp;
    187         int rc;
     187        errno_t rc;
    188188
    189189        udp_assoc_addref(assoc);
    … …  
    242242 *                      EIO if no route to destination exists
    243243 */
    244 int udp_assoc_send(udp_assoc_t *assoc, inet_ep_t *remote, udp_msg_t *msg)
     244errno_t udp_assoc_send(udp_assoc_t *assoc, inet_ep_t *remote, udp_msg_t *msg)
    245245{
    246246        udp_pdu_t *pdu;
    247247        inet_ep2_t epp;
    248         int rc;
     248        errno_t rc;
    249249
    250250        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_send(%p, %p, %p)",
    … …  
    302302 * Pull one message from the association's receive queue.
    303303 */
    304 int udp_assoc_recv(udp_assoc_t *assoc, udp_msg_t **msg, inet_ep_t *remote)
     304errno_t udp_assoc_recv(udp_assoc_t *assoc, udp_msg_t **msg, inet_ep_t *remote)
    305305{
    306306        link_t *link;
    … …  
    341341{
    342342        udp_assoc_t *assoc;
    343         int rc;
     343        errno_t rc;
    344344
    345345        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_received(%p, %p)", repp, msg);
    … …  
    380380}
    381381
    382 static int udp_assoc_queue_msg(udp_assoc_t *assoc, inet_ep2_t *epp,
     382static errno_t udp_assoc_queue_msg(udp_assoc_t *assoc, inet_ep2_t *epp,
    383383    udp_msg_t *msg)
    384384{
    … …  
    416416static udp_assoc_t *udp_assoc_find_ref(inet_ep2_t *epp)
    417417{
    418         int rc;
     418        errno_t rc;
    419419        void *arg;
    420420        udp_assoc_t *assoc;

  • uspace/srv/net/udp/assoc.h

    r36f0738 rb7fd2a0  
    4040#include "udp_type.h"
    4141
    42 extern int udp_assocs_init(void);
     42extern errno_t udp_assocs_init(void);
    4343extern udp_assoc_t *udp_assoc_new(inet_ep2_t *, udp_assoc_cb_t *, void *);
    4444extern void udp_assoc_delete(udp_assoc_t *);
    45 extern int udp_assoc_add(udp_assoc_t *);
     45extern errno_t udp_assoc_add(udp_assoc_t *);
    4646extern void udp_assoc_remove(udp_assoc_t *);
    4747extern void udp_assoc_addref(udp_assoc_t *);
    4848extern void udp_assoc_delref(udp_assoc_t *);
    4949extern void udp_assoc_set_iplink(udp_assoc_t *, service_id_t);
    50 extern int udp_assoc_send(udp_assoc_t *, inet_ep_t *, udp_msg_t *);
    51 extern int udp_assoc_recv(udp_assoc_t *, udp_msg_t **, inet_ep_t *);
     50extern errno_t udp_assoc_send(udp_assoc_t *, inet_ep_t *, udp_msg_t *);
     51extern errno_t udp_assoc_recv(udp_assoc_t *, udp_msg_t **, inet_ep_t *);
    5252extern void udp_assoc_received(inet_ep2_t *, udp_msg_t *);
    5353extern void udp_assoc_reset(udp_assoc_t *);

  • uspace/srv/net/udp/pdu.c

    r36f0738 rb7fd2a0  
    162162
    163163/** Decode incoming PDU */
    164 int udp_pdu_decode(udp_pdu_t *pdu, inet_ep2_t *epp, udp_msg_t **msg)
     164errno_t udp_pdu_decode(udp_pdu_t *pdu, inet_ep2_t *epp, udp_msg_t **msg)
    165165{
    166166        udp_msg_t *nmsg;
    … …  
    209209
    210210/** Encode outgoing PDU */
    211 int udp_pdu_encode(inet_ep2_t *epp, udp_msg_t *msg, udp_pdu_t **pdu)
     211errno_t udp_pdu_encode(inet_ep2_t *epp, udp_msg_t *msg, udp_pdu_t **pdu)
    212212{
    213213        udp_pdu_t *npdu;

  • uspace/srv/net/udp/pdu.h

    r36f0738 rb7fd2a0  
    4242extern udp_pdu_t *udp_pdu_new(void);
    4343extern void udp_pdu_delete(udp_pdu_t *);
    44 extern int udp_pdu_decode(udp_pdu_t *, inet_ep2_t *, udp_msg_t **);
    45 extern int udp_pdu_encode(inet_ep2_t *, udp_msg_t *, udp_pdu_t **);
     44extern errno_t udp_pdu_decode(udp_pdu_t *, inet_ep2_t *, udp_msg_t **);
     45extern errno_t udp_pdu_encode(inet_ep2_t *, udp_msg_t *, udp_pdu_t **);
    4646
    4747#endif

  • uspace/srv/net/udp/service.c

    r36f0738 rb7fd2a0  
    7070 * @return EOK on success, ENOMEM if out of memory
    7171 */
    72 static int udp_cassoc_queue_msg(udp_cassoc_t *cassoc, inet_ep2_t *epp,
     72static errno_t udp_cassoc_queue_msg(udp_cassoc_t *cassoc, inet_ep2_t *epp,
    7373    udp_msg_t *msg)
    7474{
    … …  
    123123 * @return EOK on soccess, ENOMEM if out of memory
    124124 */
    125 static int udp_cassoc_create(udp_client_t *client, udp_assoc_t *assoc,
     125static errno_t udp_cassoc_create(udp_client_t *client, udp_assoc_t *assoc,
    126126    udp_cassoc_t **rcassoc)
    127127{
    … …  
    168168 *         is found.
    169169 */
    170 static int udp_cassoc_get(udp_client_t *client, sysarg_t id,
     170static errno_t udp_cassoc_get(udp_client_t *client, sysarg_t id,
    171171    udp_cassoc_t **rcassoc)
    172172{
    … …  
    207207 * @return EOK on success or an error code
    208208 */
    209 static int udp_assoc_create_impl(udp_client_t *client, inet_ep2_t *epp,
     209static errno_t udp_assoc_create_impl(udp_client_t *client, inet_ep2_t *epp,
    210210    sysarg_t *rassoc_id)
    211211{
    212212        udp_assoc_t *assoc;
    213213        udp_cassoc_t *cassoc;
    214         int rc;
     214        errno_t rc;
    215215
    216216        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_create_impl");
    … …  
    252252 * @return EOK on success, ENOENT if no such association is found
    253253 */
    254 static int udp_assoc_destroy_impl(udp_client_t *client, sysarg_t assoc_id)
     254static errno_t udp_assoc_destroy_impl(udp_client_t *client, sysarg_t assoc_id)
    255255{
    256256        udp_cassoc_t *cassoc;
    257         int rc;
     257        errno_t rc;
    258258
    259259        rc = udp_cassoc_get(client, assoc_id, &cassoc);
    … …  
    278278 * @return EOK on success, ENOENT if no such association is found
    279279 */
    280 static int udp_assoc_set_nolocal_impl(udp_client_t *client, sysarg_t assoc_id)
     280static errno_t udp_assoc_set_nolocal_impl(udp_client_t *client, sysarg_t assoc_id)
    281281{
    282282        udp_cassoc_t *cassoc;
    283         int rc;
     283        errno_t rc;
    284284
    285285        rc = udp_cassoc_get(client, assoc_id, &cassoc);
    … …  
    307307 * @return EOK on success or an error code
    308308 */
    309 static int udp_assoc_send_msg_impl(udp_client_t *client, sysarg_t assoc_id,
     309static errno_t udp_assoc_send_msg_impl(udp_client_t *client, sysarg_t assoc_id,
    310310    inet_ep_t *dest, void *data, size_t size)
    311311{
    312312        udp_msg_t msg;
    313313        udp_cassoc_t *cassoc;
    314         int rc;
     314        errno_t rc;
    315315
    316316        rc = udp_cassoc_get(client, assoc_id, &cassoc);
    … …  
    365365        inet_ep2_t epp;
    366366        sysarg_t assoc_id;
    367         int rc;
     367        errno_t rc;
    368368
    369369        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_create_srv()");
    … …  
    409409{
    410410        sysarg_t assoc_id;
    411         int rc;
     411        errno_t rc;
    412412
    413413        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_destroy_srv()");
    … …  
    430430{
    431431        sysarg_t assoc_id;
    432         int rc;
     432        errno_t rc;
    433433
    434434        log_msg(LOG_DEFAULT, LVL_NOTE, "udp_assoc_set_nolocal_srv()");
    … …  
    455455        sysarg_t assoc_id;
    456456        void *data;
    457         int rc;
     457        errno_t rc;
    458458
    459459        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_send_msg_srv()");
    … …  
    552552        udp_crcv_queue_entry_t *enext;
    553553        sysarg_t assoc_id;
    554         int rc;
     554        errno_t rc;
    555555
    556556        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_info_srv()");
    … …  
    601601        size_t size;
    602602        size_t off;
    603         int rc;
     603        errno_t rc;
    604604
    605605        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_read_srv()");
    … …  
    752752 * @return EOK on success or an error code.
    753753 */
    754 int udp_service_init(void)
    755 {
    756         int rc;
     754errno_t udp_service_init(void)
     755{
     756        errno_t rc;
    757757        service_id_t sid;
    758758

  • uspace/srv/net/udp/service.h

    r36f0738 rb7fd2a0  
    3636#define SERVICE_H
    3737
    38 extern int udp_service_init(void);
     38extern errno_t udp_service_init(void);
    3939
    4040#endif

  • uspace/srv/net/udp/udp.c

    r36f0738 rb7fd2a0  
    4747#define NAME       "udp"
    4848
    49 static int udp_init(void)
     49static errno_t udp_init(void)
    5050{
    51         int rc;
     51        errno_t rc;
    5252
    5353        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_init()");
    … …  
    7676int main(int argc, char **argv)
    7777{
    78         int rc;
     78        errno_t rc;
    7979
    8080        printf(NAME ": UDP (User Datagram Protocol) service\n");

  • uspace/srv/net/udp/udp_inet.c

    r36f0738 rb7fd2a0  
    4545#include "udp_type.h"
    4646
    47 static int udp_inet_ev_recv(inet_dgram_t *dgram);
     47static errno_t udp_inet_ev_recv(inet_dgram_t *dgram);
    4848static void udp_received_pdu(udp_pdu_t *pdu);
    4949
    … …  
    5353
    5454/** Received datagram callback */
    55 static int udp_inet_ev_recv(inet_dgram_t *dgram)
     55static errno_t udp_inet_ev_recv(inet_dgram_t *dgram)
    5656{
    5757        udp_pdu_t *pdu;
    … …  
    7777
    7878/** Transmit PDU over network layer. */
    79 int udp_transmit_pdu(udp_pdu_t *pdu)
     79errno_t udp_transmit_pdu(udp_pdu_t *pdu)
    8080{
    81         int rc;
     81        errno_t rc;
    8282        inet_dgram_t dgram;
    8383
    … …  
    119119}
    120120
    121 int udp_inet_init(void)
     121errno_t udp_inet_init(void)
    122122{
    123         int rc;
     123        errno_t rc;
    124124
    125125        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_inet_init()");

  • uspace/srv/net/udp/udp_inet.h

    r36f0738 rb7fd2a0  
    3838#include "udp_type.h"
    3939
    40 extern int udp_inet_init(void);
    41 extern int udp_transmit_pdu(udp_pdu_t *);
     40extern errno_t udp_inet_init(void);
     41extern errno_t udp_transmit_pdu(udp_pdu_t *);
    4242
    4343#endif
Note: See TracChangeset for help on using the changeset viewer.