Changeset b7fd2a0 in mainline for uspace/lib/c/generic/inet

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
<sup>git add .
tools/srepl '\berrno_t\b' int
git add .
tools/srepl '\bsys_errno_t\b' sysarg_t
git reset
git diff
`</sup>

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

Location:

uspace/lib/c/generic/inet

Files:

• addr.c (modified) (10 diffs)
• host.c (modified) (5 diffs)
• hostname.c (modified) (1 diff)
• hostport.c (modified) (5 diffs)
• tcp.c (modified) (33 diffs)
• udp.c (modified) (20 diffs)

uspace/lib/c/generic/inet/addr.c

@@ -290 +290 @@
 }
 
-static int inet_addr_parse_v4(const char *str, inet_addr_t *raddr,
+static errno_t inet_addr_parse_v4(const char *str, inet_addr_t *raddr,
     int *prefix, char **endptr)
 {
@@ -299 +299 @@
 
         while (i < 4) {
-                int rc = str_uint8_t(cur, (const char **)&cur, 10, false, &b);
+                errno_t rc = str_uint8_t(cur, (const char **)&cur, 10, false, &b);
                 if (rc != EOK)
                         return rc;
@@ -339 +339 @@
 }
 
-static int inet_addr_parse_v6(const char *str, inet_addr_t *raddr, int *prefix,
+static errno_t inet_addr_parse_v6(const char *str, inet_addr_t *raddr, int *prefix,
     char **endptr)
 {
@@ -362 +362 @@
                 uint16_t bioctet;
                 const char *gend;
-                int rc = str_uint16_t(cur, &gend, 16, false, &bioctet);
+                errno_t rc = str_uint16_t(cur, &gend, 16, false, &bioctet);
                 if (rc != EOK)
                         break;
@@ -446 +446 @@
  *
  */
-int inet_addr_parse(const char *text, inet_addr_t *addr, char **endptr)
-{
-        int rc;
+errno_t inet_addr_parse(const char *text, inet_addr_t *addr, char **endptr)
+{
+        errno_t rc;
 
         rc = inet_addr_parse_v4(text, addr, NULL, endptr);
@@ -473 +473 @@
  *
  */
-int inet_naddr_parse(const char *text, inet_naddr_t *naddr, char **endptr)
-{
-        int rc;
+errno_t inet_naddr_parse(const char *text, inet_naddr_t *naddr, char **endptr)
+{
+        errno_t rc;
         inet_addr_t addr;
         int prefix;
@@ -494 +494 @@
 }
 
-static int inet_addr_format_v4(addr32_t addr, char **bufp)
+static errno_t inet_addr_format_v4(addr32_t addr, char **bufp)
 {
         int rc;
@@ -506 +506 @@
 }
 
-static int inet_addr_format_v6(const addr128_t addr, char **bufp)
+static errno_t inet_addr_format_v6(const addr128_t addr, char **bufp)
 {
         *bufp = (char *) malloc(INET6_ADDRSTRLEN);
@@ -581 +581 @@
  *
  */
-int inet_addr_format(const inet_addr_t *addr, char **bufp)
-{
-        int rc;
+errno_t inet_addr_format(const inet_addr_t *addr, char **bufp)
+{
+        errno_t rc;
         int ret;
 
@@ -616 +616 @@
  *
  */
-int inet_naddr_format(const inet_naddr_t *naddr, char **bufp)
-{
-        int rc;
+errno_t inet_naddr_format(const inet_naddr_t *naddr, char **bufp)
+{
+        errno_t rc;
         int ret;
         char *astr;

uspace/lib/c/generic/inet/host.c

@@ -54 +54 @@
  *         extra characters at the end. ENOMEM if out of memory
  */
-int inet_host_parse(const char *str, inet_host_t **rhost,
+errno_t inet_host_parse(const char *str, inet_host_t **rhost,
     char **endptr)
 {
@@ -61 +61 @@
         char *name;
         char *aend;
-        int rc;
+        errno_t rc;
 
         host = calloc(1, sizeof(inet_host_t));
@@ -106 +106 @@
  * @return EOK on success, ENOMEM if out of memory
  */
-int inet_host_format(inet_host_t *host, char **rstr)
-{
-        int rc;
+errno_t inet_host_format(inet_host_t *host, char **rstr)
+{
+        errno_t rc;
         char *str = NULL;
 
@@ -161 +161 @@
  * @reutrn EOK on success, ENOENT on resolurion failure
  */
-int inet_host_lookup_one(inet_host_t *host, ip_ver_t version, inet_addr_t *addr)
+errno_t inet_host_lookup_one(inet_host_t *host, ip_ver_t version, inet_addr_t *addr)
 {
         dnsr_hostinfo_t *hinfo = NULL;
-        int rc;
+        errno_t rc;
 
         switch (host->hform) {
@@ -201 +201 @@
  *         ENOMEM if out of memory
  */
-int inet_host_plookup_one(const char *str, ip_ver_t version, inet_addr_t *addr,
+errno_t inet_host_plookup_one(const char *str, ip_ver_t version, inet_addr_t *addr,
     char **endptr, const char **errmsg)
 {
         inet_host_t *host = NULL;
         char *eptr;
-        int rc;
+        errno_t rc;
 
         rc = inet_host_parse(str, &host, endptr != NULL ? &eptr : NULL);

uspace/lib/c/generic/inet/hostname.c

@@ -58 +58 @@
  *         extra characters at the end. ENOMEM if out of memory
  */
-int inet_hostname_parse(const char *str, char **rname, char **endptr)
+errno_t inet_hostname_parse(const char *str, char **rname, char **endptr)
 {
         const char *c;

uspace/lib/c/generic/inet/hostport.c

@@ -56 +56 @@
  *         extra characters at the end. ENOMEM if out of memory
  */
-int inet_hostport_parse(const char *str, inet_hostport_t **rhp,
+errno_t inet_hostport_parse(const char *str, inet_hostport_t **rhp,
     char **endptr)
 {
@@ -65 +65 @@
         char *aend;
         const char *pend;
-        int rc;
+        errno_t rc;
 
         hp = calloc(1, sizeof(inet_hostport_t));
@@ -137 +137 @@
  * @return EOK on success, ENOMEM if out of memory
  */
-int inet_hostport_format(inet_hostport_t *hp, char **rstr)
-{
-        int rc;
+errno_t inet_hostport_format(inet_hostport_t *hp, char **rstr)
+{
+        errno_t rc;
         int ret;
         char *astr, *str;
@@ -211 +211 @@
  * @return EOK on success, ENOENT on resolution failure
  */
-int inet_hostport_lookup_one(inet_hostport_t *hp, ip_ver_t version,
+errno_t inet_hostport_lookup_one(inet_hostport_t *hp, ip_ver_t version,
     inet_ep_t *ep)
 {
         dnsr_hostinfo_t *hinfo = NULL;
-        int rc;
+        errno_t rc;
 
         inet_ep_init(ep);
@@ -255 +255 @@
  *         ENOMEM if out of memory
  */
-int inet_hostport_plookup_one(const char *str, ip_ver_t version, inet_ep_t *ep,
+errno_t inet_hostport_plookup_one(const char *str, ip_ver_t version, inet_ep_t *ep,
     char **endptr, const char **errmsg)
 {
         inet_hostport_t *hp = NULL;
         char *eptr;
-        int rc;
+        errno_t rc;
 
         rc = inet_hostport_parse(str, &hp, endptr != NULL ? &eptr : NULL);

uspace/lib/c/generic/inet/tcp.c

@@ -42 +42 @@
 
 static void tcp_cb_conn(ipc_callid_t, ipc_call_t *, void *);
-static int tcp_conn_fibril(void *);
+static errno_t tcp_conn_fibril(void *);
 
 /** Incoming TCP connection info
@@ -61 +61 @@
  * @return EOK on success or an error code
  */
-static int tcp_callback_create(tcp_t *tcp)
+static errno_t tcp_callback_create(tcp_t *tcp)
 {
         async_exch_t *exch = async_exchange_begin(tcp->sess);
@@ -68 +68 @@
         
         port_id_t port;
-        int rc = async_create_callback_port(exch, INTERFACE_TCP_CB, 0, 0,
+        errno_t rc = async_create_callback_port(exch, INTERFACE_TCP_CB, 0, 0,
             tcp_cb_conn, tcp, &port);
         
@@ -76 +76 @@
                 return rc;
 
-        int retval;
+        errno_t retval;
         async_wait_for(req, &retval);
 
@@ -88 +88 @@
  *         cannot be contacted
  */
-int tcp_create(tcp_t **rtcp)
+errno_t tcp_create(tcp_t **rtcp)
 {
         tcp_t *tcp;
         service_id_t tcp_svcid;
-        int rc;
+        errno_t rc;
 
         tcp = calloc(1, sizeof(tcp_t));
@@ -161 +161 @@
  * @return EOK on success, ENOMEM if out of memory
  */
-static int tcp_conn_new(tcp_t *tcp, sysarg_t id, tcp_cb_t *cb, void *arg,
+static errno_t tcp_conn_new(tcp_t *tcp, sysarg_t id, tcp_cb_t *cb, void *arg,
     tcp_conn_t **rconn)
 {
@@ -207 +207 @@
  * @return EOK on success or an error code.
  */
-int tcp_conn_create(tcp_t *tcp, inet_ep2_t *epp, tcp_cb_t *cb, void *arg,
+errno_t tcp_conn_create(tcp_t *tcp, inet_ep2_t *epp, tcp_cb_t *cb, void *arg,
     tcp_conn_t **rconn)
 {
@@ -216 +216 @@
         exch = async_exchange_begin(tcp->sess);
         aid_t req = async_send_0(exch, TCP_CONN_CREATE, &answer);
-        int rc = async_data_write_start(exch, (void *)epp,
+        errno_t rc = async_data_write_start(exch, (void *)epp,
             sizeof(inet_ep2_t));
         async_exchange_end(exch);
 
         if (rc != EOK) {
-                int rc_orig;
+                errno_t rc_orig;
                 async_wait_for(req, &rc_orig);
                 if (rc_orig != EOK)
@@ -240 +240 @@
         return EOK;
 error:
-        return (int) rc;
+        return (errno_t) rc;
 }
 
@@ -260 +260 @@
 
         exch = async_exchange_begin(conn->tcp->sess);
-        int rc = async_req_1_0(exch, TCP_CONN_DESTROY, conn->id);
+        errno_t rc = async_req_1_0(exch, TCP_CONN_DESTROY, conn->id);
         async_exchange_end(exch);
 
@@ -275 +275 @@
  * @return EOK on success, EINVAL if no connection with the given ID exists
  */
-static int tcp_conn_get(tcp_t *tcp, sysarg_t id, tcp_conn_t **rconn)
+static errno_t tcp_conn_get(tcp_t *tcp, sysarg_t id, tcp_conn_t **rconn)
 {
         list_foreach(tcp->conn, ltcp, tcp_conn_t, conn) {
@@ -318 +318 @@
  * @return EOK on success or an error code
  */
-int tcp_listener_create(tcp_t *tcp, inet_ep_t *ep, tcp_listen_cb_t *lcb,
+errno_t tcp_listener_create(tcp_t *tcp, inet_ep_t *ep, tcp_listen_cb_t *lcb,
     void *larg, tcp_cb_t *cb, void *arg, tcp_listener_t **rlst)
 {
@@ -331 +331 @@
         exch = async_exchange_begin(tcp->sess);
         aid_t req = async_send_0(exch, TCP_LISTENER_CREATE, &answer);
-        int rc = async_data_write_start(exch, (void *)ep,
+        errno_t rc = async_data_write_start(exch, (void *)ep,
             sizeof(inet_ep_t));
         async_exchange_end(exch);
 
         if (rc != EOK) {
-                int rc_orig;
+                errno_t rc_orig;
                 async_wait_for(req, &rc_orig);
                 if (rc_orig != EOK)
@@ -360 +360 @@
 error:
         free(lst);
-        return (int) rc;
+        return (errno_t) rc;
 }
 
@@ -377 +377 @@
 
         exch = async_exchange_begin(lst->tcp->sess);
-        int rc = async_req_1_0(exch, TCP_LISTENER_DESTROY, lst->id);
+        errno_t rc = async_req_1_0(exch, TCP_LISTENER_DESTROY, lst->id);
         async_exchange_end(exch);
 
@@ -392 +392 @@
  * @return EOK on success, EINVAL if no listener with the given ID is found
  */
-static int tcp_listener_get(tcp_t *tcp, sysarg_t id, tcp_listener_t **rlst)
+static errno_t tcp_listener_get(tcp_t *tcp, sysarg_t id, tcp_listener_t **rlst)
 {
         list_foreach(tcp->listener, ltcp, tcp_listener_t, lst) {
@@ -424 +424 @@
  * @return EOK if connection is established, EIO otherwise
  */
-int tcp_conn_wait_connected(tcp_conn_t *conn)
+errno_t tcp_conn_wait_connected(tcp_conn_t *conn)
 {
         fibril_mutex_lock(&conn->lock);
@@ -448 +448 @@
  * @return EOK on success or an error code
  */
-int tcp_conn_send(tcp_conn_t *conn, const void *data, size_t bytes)
-{
-        async_exch_t *exch;
-        int rc;
+errno_t tcp_conn_send(tcp_conn_t *conn, const void *data, size_t bytes)
+{
+        async_exch_t *exch;
+        errno_t rc;
 
         exch = async_exchange_begin(conn->tcp->sess);
@@ -480 +480 @@
  * @return EOK on success or an error code
  */
-int tcp_conn_send_fin(tcp_conn_t *conn)
+errno_t tcp_conn_send_fin(tcp_conn_t *conn)
 {
         async_exch_t *exch;
 
         exch = async_exchange_begin(conn->tcp->sess);
-        int rc = async_req_1_0(exch, TCP_CONN_SEND_FIN, conn->id);
+        errno_t rc = async_req_1_0(exch, TCP_CONN_SEND_FIN, conn->id);
         async_exchange_end(exch);
 
@@ -496 +496 @@
  * @return EOK on success or an error code
  */
-int tcp_conn_push(tcp_conn_t *conn)
+errno_t tcp_conn_push(tcp_conn_t *conn)
 {
         async_exch_t *exch;
 
         exch = async_exchange_begin(conn->tcp->sess);
-        int rc = async_req_1_0(exch, TCP_CONN_PUSH, conn->id);
+        errno_t rc = async_req_1_0(exch, TCP_CONN_PUSH, conn->id);
         async_exchange_end(exch);
 
@@ -512 +512 @@
  * @return EOK on success or an error code
  */
-int tcp_conn_reset(tcp_conn_t *conn)
+errno_t tcp_conn_reset(tcp_conn_t *conn)
 {
         async_exch_t *exch;
 
         exch = async_exchange_begin(conn->tcp->sess);
-        int rc = async_req_1_0(exch, TCP_CONN_RESET, conn->id);
+        errno_t rc = async_req_1_0(exch, TCP_CONN_RESET, conn->id);
         async_exchange_end(exch);
 
@@ -540 +540 @@
  *         error code in case of other error
  */
-int tcp_conn_recv(tcp_conn_t *conn, void *buf, size_t bsize, size_t *nrecv)
+errno_t tcp_conn_recv(tcp_conn_t *conn, void *buf, size_t bsize, size_t *nrecv)
 {
         async_exch_t *exch;
@@ -553 +553 @@
         exch = async_exchange_begin(conn->tcp->sess);
         aid_t req = async_send_1(exch, TCP_CONN_RECV, conn->id, &answer);
-        int rc = async_data_read_start(exch, buf, bsize);
+        errno_t rc = async_data_read_start(exch, buf, bsize);
         async_exchange_end(exch);
 
@@ -562 +562 @@
         }
 
-        int retval;
+        errno_t retval;
         async_wait_for(req, &retval);
         if (retval != EOK) {
@@ -588 +588 @@
  * @return EOK on success or an error code
  */
-int tcp_conn_recv_wait(tcp_conn_t *conn, void *buf, size_t bsize,
+errno_t tcp_conn_recv_wait(tcp_conn_t *conn, void *buf, size_t bsize,
     size_t *nrecv)
 {
@@ -602 +602 @@
         exch = async_exchange_begin(conn->tcp->sess);
         aid_t req = async_send_1(exch, TCP_CONN_RECV_WAIT, conn->id, &answer);
-        int rc = async_data_read_start(exch, buf, bsize);
+        errno_t rc = async_data_read_start(exch, buf, bsize);
         async_exchange_end(exch);
 
@@ -616 +616 @@
         }
 
-        int retval;
+        errno_t retval;
         async_wait_for(req, &retval);
         if (retval != EOK) {
@@ -641 +641 @@
         tcp_conn_t *conn;
         sysarg_t conn_id;
-        int rc;
+        errno_t rc;
 
         conn_id = IPC_GET_ARG1(*icall);
@@ -669 +669 @@
         tcp_conn_t *conn;
         sysarg_t conn_id;
-        int rc;
+        errno_t rc;
 
         conn_id = IPC_GET_ARG1(*icall);
@@ -697 +697 @@
         tcp_conn_t *conn;
         sysarg_t conn_id;
-        int rc;
+        errno_t rc;
 
         conn_id = IPC_GET_ARG1(*icall);
@@ -725 +725 @@
         tcp_conn_t *conn;
         sysarg_t conn_id;
-        int rc;
+        errno_t rc;
 
         conn_id = IPC_GET_ARG1(*icall);
@@ -769 +769 @@
         fid_t fid;
         tcp_in_conn_t *cinfo;
-        int rc;
+        errno_t rc;
 
         lst_id = IPC_GET_ARG1(*icall);
@@ -863 +863 @@
  * @param arg Argument, incoming connection information (@c tcp_in_conn_t)
  */
-static int tcp_conn_fibril(void *arg)
+static errno_t tcp_conn_fibril(void *arg)
 {
         tcp_in_conn_t *cinfo = (tcp_in_conn_t *)arg;

uspace/lib/c/generic/inet/udp.c

@@ -48 +48 @@
  * @return EOK on success or an error code
  */
-static int udp_callback_create(udp_t *udp)
+static errno_t udp_callback_create(udp_t *udp)
 {
         async_exch_t *exch = async_exchange_begin(udp->sess);
@@ -55 +55 @@
         
         port_id_t port;
-        int rc = async_create_callback_port(exch, INTERFACE_UDP_CB, 0, 0,
+        errno_t rc = async_create_callback_port(exch, INTERFACE_UDP_CB, 0, 0,
             udp_cb_conn, udp, &port);
         
@@ -63 +63 @@
                 return rc;
 
-        int retval;
+        errno_t retval;
         async_wait_for(req, &retval);
 
@@ -75 +75 @@
  *         cannot be contacted
  */
-int udp_create(udp_t **rudp)
+errno_t udp_create(udp_t **rudp)
 {
         udp_t *udp;
         service_id_t udp_svcid;
-        int rc;
+        errno_t rc;
 
         udp = calloc(1, sizeof(udp_t));
@@ -160 +160 @@
  * @return EOK on success or an error code.
  */
-int udp_assoc_create(udp_t *udp, inet_ep2_t *epp, udp_cb_t *cb, void *arg,
+errno_t udp_assoc_create(udp_t *udp, inet_ep2_t *epp, udp_cb_t *cb, void *arg,
     udp_assoc_t **rassoc)
 {
@@ -173 +173 @@
         exch = async_exchange_begin(udp->sess);
         aid_t req = async_send_0(exch, UDP_ASSOC_CREATE, &answer);
-        int rc = async_data_write_start(exch, (void *)epp,
+        errno_t rc = async_data_write_start(exch, (void *)epp,
             sizeof(inet_ep2_t));
         async_exchange_end(exch);
 
         if (rc != EOK) {
-                int rc_orig;
+                errno_t rc_orig;
                 async_wait_for(req, &rc_orig);
                 if (rc_orig != EOK)
@@ -200 +200 @@
 error:
         free(assoc);
-        return (int) rc;
+        return (errno_t) rc;
 }
 
@@ -220 +220 @@
 
         exch = async_exchange_begin(assoc->udp->sess);
-        int rc = async_req_1_0(exch, UDP_ASSOC_DESTROY, assoc->id);
+        errno_t rc = async_req_1_0(exch, UDP_ASSOC_DESTROY, assoc->id);
         async_exchange_end(exch);
 
@@ -232 +232 @@
  * @param flags Flags
  */
-int udp_assoc_set_nolocal(udp_assoc_t *assoc)
+errno_t udp_assoc_set_nolocal(udp_assoc_t *assoc)
 {
         async_exch_t *exch;
 
         exch = async_exchange_begin(assoc->udp->sess);
-        int rc = async_req_1_0(exch, UDP_ASSOC_SET_NOLOCAL, assoc->id);
+        errno_t rc = async_req_1_0(exch, UDP_ASSOC_SET_NOLOCAL, assoc->id);
         async_exchange_end(exch);
 
@@ -252 +252 @@
  * @return EOK on success or an error code
  */
-int udp_assoc_send_msg(udp_assoc_t *assoc, inet_ep_t *dest, void *data,
+errno_t udp_assoc_send_msg(udp_assoc_t *assoc, inet_ep_t *dest, void *data,
     size_t bytes)
 {
@@ -260 +260 @@
         aid_t req = async_send_1(exch, UDP_ASSOC_SEND_MSG, assoc->id, NULL);
 
-        int rc = async_data_write_start(exch, (void *)dest,
+        errno_t rc = async_data_write_start(exch, (void *)dest,
             sizeof(inet_ep_t));
         if (rc != EOK) {
@@ -318 +318 @@
  * @return EOK on success or an error code.
  */
-int udp_rmsg_read(udp_rmsg_t *rmsg, size_t off, void *buf, size_t bsize)
+errno_t udp_rmsg_read(udp_rmsg_t *rmsg, size_t off, void *buf, size_t bsize)
 {
         async_exch_t *exch;
@@ -325 +325 @@
         exch = async_exchange_begin(rmsg->udp->sess);
         aid_t req = async_send_1(exch, UDP_RMSG_READ, off, &answer);
-        int rc = async_data_read_start(exch, buf, bsize);
+        errno_t rc = async_data_read_start(exch, buf, bsize);
         async_exchange_end(exch);
 
@@ -333 +333 @@
         }
 
-        int retval;
+        errno_t retval;
         async_wait_for(req, &retval);
         if (retval != EOK) {
@@ -382 +382 @@
  * @return EOK on success or an error code
  */
-static int udp_rmsg_info(udp_t *udp, udp_rmsg_t *rmsg)
+static errno_t udp_rmsg_info(udp_t *udp, udp_rmsg_t *rmsg)
 {
         async_exch_t *exch;
@@ -390 +390 @@
         exch = async_exchange_begin(udp->sess);
         aid_t req = async_send_0(exch, UDP_RMSG_INFO, &answer);
-        int rc = async_data_read_start(exch, &ep, sizeof(inet_ep_t));
+        errno_t rc = async_data_read_start(exch, &ep, sizeof(inet_ep_t));
         async_exchange_end(exch);
 
@@ -398 +398 @@
         }
 
-        int retval;
+        errno_t retval;
         async_wait_for(req, &retval);
         if (retval != EOK)
@@ -415 +415 @@
  * @return EOK on success or an error code
  */
-static int udp_rmsg_discard(udp_t *udp)
+static errno_t udp_rmsg_discard(udp_t *udp)
 {
         async_exch_t *exch;
 
         exch = async_exchange_begin(udp->sess);
-        int rc = async_req_0_0(exch, UDP_RMSG_DISCARD);
+        errno_t rc = async_req_0_0(exch, UDP_RMSG_DISCARD);
         async_exchange_end(exch);
 
@@ -434 +434 @@
  * @return EOK on success, EINVAL if no association with the given ID exists
  */
-static int udp_assoc_get(udp_t *udp, sysarg_t id, udp_assoc_t **rassoc)
+static errno_t udp_assoc_get(udp_t *udp, sysarg_t id, udp_assoc_t **rassoc)
 {
         list_foreach(udp->assoc, ludp, udp_assoc_t, assoc) {
@@ -459 +459 @@
         udp_rmsg_t rmsg;
         udp_assoc_t *assoc;
-        int rc;
+        errno_t rc;
 
         while (true) {