work on -Wconversion...

src/api/api_lib.c

@@ -1076,7 +1076,7 @@ netconn_err(struct netconn *conn)
 err_t
 netconn_shutdown(struct netconn *conn, u8_t shut_rx, u8_t shut_tx)
 {
-  return netconn_close_shutdown(conn, (shut_rx ? NETCONN_SHUT_RD : 0) | (shut_tx ? NETCONN_SHUT_WR : 0));
+  return netconn_close_shutdown(conn, (u8_t)((shut_rx ? NETCONN_SHUT_RD : 0) | (shut_tx ? NETCONN_SHUT_WR : 0)));
 }
 
 #if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD)

src/api/api_msg.c

@@ -60,10 +60,10 @@
 #define NETCONN_TCP_POLL_INTERVAL 2
 
 #define SET_NONBLOCKING_CONNECT(conn, val)  do { if (val) { \
-  (conn)->flags |= NETCONN_FLAG_IN_NONBLOCKING_CONNECT; \
+  netconn_set_flags(conn, NETCONN_FLAG_IN_NONBLOCKING_CONNECT); \
 } else { \
-  (conn)->flags &= ~ NETCONN_FLAG_IN_NONBLOCKING_CONNECT; }} while(0)
+  netconn_clear_flags(conn, NETCONN_FLAG_IN_NONBLOCKING_CONNECT); }} while(0)
-#define IN_NONBLOCKING_CONNECT(conn) (((conn)->flags & NETCONN_FLAG_IN_NONBLOCKING_CONNECT) != 0)
+#define IN_NONBLOCKING_CONNECT(conn) netconn_is_flag_set(conn, NETCONN_FLAG_IN_NONBLOCKING_CONNECT)
 
 /* forward declarations */
 #if LWIP_TCP
@@ -365,7 +365,7 @@ poll_tcp(void *arg, struct tcp_pcb *pcb)
        let select mark this pcb as writable again. */
     if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) &&
       (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) {
-      conn->flags &= ~NETCONN_FLAG_CHECK_WRITESPACE;
+      netconn_clear_flags(conn, NETCONN_FLAG_CHECK_WRITESPACE);
       API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
     }
   }
@@ -399,7 +399,7 @@ sent_tcp(void *arg, struct tcp_pcb *pcb, u16_t len)
        let select mark this pcb as writable again. */
     if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) &&
       (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) {
-      conn->flags &= ~NETCONN_FLAG_CHECK_WRITESPACE;
+      netconn_clear_flags(conn, NETCONN_FLAG_CHECK_WRITESPACE);
       API_EVENT(conn, NETCONN_EVT_SENDPLUS, len);
     }
   }
@@ -1543,7 +1543,7 @@ lwip_netconn_do_recv(void *m)
     if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) {
       size_t remaining = msg->msg.r.len;
       do {
-        u16_t recved = (remaining > 0xffff) ? 0xffff : (u16_t)remaining;
+        u16_t recved = (u16_t)((remaining > 0xffff) ? 0xffff : remaining);
         tcp_recved(msg->conn->pcb.tcp, recved);
         remaining -= recved;
       } while (remaining != 0);

src/api/sockets.c

@@ -182,14 +182,14 @@ static void sockaddr_to_ipaddr_port(const struct sockaddr* sockaddr, ip_addr_t*
 #if LWIP_SO_SNDRCVTIMEO_NONSTANDARD
 #define LWIP_SO_SNDRCVTIMEO_OPTTYPE int
 #define LWIP_SO_SNDRCVTIMEO_SET(optval, val) (*(int *)(optval) = (val))
-#define LWIP_SO_SNDRCVTIMEO_GET_MS(optval)   ((s32_t)*(const int*)(optval))
+#define LWIP_SO_SNDRCVTIMEO_GET_MS(optval)   ((long)*(const int*)(optval))
 #else
 #define LWIP_SO_SNDRCVTIMEO_OPTTYPE struct timeval
 #define LWIP_SO_SNDRCVTIMEO_SET(optval, val)  do { \
-  s32_t loc = (val); \
+  u32_t loc = (val); \
-  ((struct timeval *)(optval))->tv_sec = (loc) / 1000U; \
+  ((struct timeval *)(optval))->tv_sec = (long)((loc) / 1000U); \
-  ((struct timeval *)(optval))->tv_usec = ((loc) % 1000U) * 1000U; }while(0)
+  ((struct timeval *)(optval))->tv_usec = (long)(((loc) % 1000U) * 1000U); }while(0)
-#define LWIP_SO_SNDRCVTIMEO_GET_MS(optval) ((((const struct timeval *)(optval))->tv_sec * 1000U) + (((const struct timeval *)(optval))->tv_usec / 1000U))
+#define LWIP_SO_SNDRCVTIMEO_GET_MS(optval) ((((const struct timeval *)(optval))->tv_sec * 1000) + (((const struct timeval *)(optval))->tv_usec / 1000))
 #endif
 
 
@@ -1043,7 +1043,7 @@ lwip_recvfrom_udp_raw(struct lwip_sock *sock, int flags, struct msghdr *msg, u16
   copied = 0;
   /* copy the pbuf payload into the iovs */
   for (i = 0; (i < msg->msg_iovlen) && (copied < buflen); i++) {
-    u16_t len_left = buflen - copied;
+    u16_t len_left = (u16_t)(buflen - copied);
     if (msg->msg_iov[i].iov_len > len_left) {
       copylen = len_left;
     } else {
@@ -1053,7 +1053,7 @@ lwip_recvfrom_udp_raw(struct lwip_sock *sock, int flags, struct msghdr *msg, u16
     /* copy the contents of the received buffer into
         the supplied memory buffer */
     pbuf_copy_partial(buf->p, (u8_t*)msg->msg_iov[i].iov_base, copylen, copied);
-    copied += copylen;
+    copied = (u16_t)(copied + copylen);
   }
 
   /* Check to see from where the data was.*/
@@ -1203,14 +1203,14 @@ lwip_recvmsg(int s, struct msghdr *message, int flags)
   /* check for valid vectors */
   buflen = 0;
   for (i = 0; i < message->msg_iovlen; i++) {
-    if ((message->msg_iov[i].iov_base == NULL) || (message->msg_iov[i].iov_len == 0) ||
+    if ((message->msg_iov[i].iov_base == NULL) || ((ssize_t)message->msg_iov[i].iov_len <= 0) ||
         ((size_t)(ssize_t)message->msg_iov[i].iov_len != message->msg_iov[i].iov_len) ||
-        ((ssize_t)(buflen + message->msg_iov[i].iov_len) <= 0)) {
+        ((ssize_t)(buflen + (ssize_t)message->msg_iov[i].iov_len) <= 0)) {
       sock_set_errno(sock, ERR_VAL);
       done_socket(sock);
       return -1;
     }
-    buflen = (ssize_t)(buflen + message->msg_iov[i].iov_len);
+    buflen = (ssize_t)(buflen + (ssize_t)message->msg_iov[i].iov_len);
   }
 
   if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP) {
@@ -1307,9 +1307,9 @@ lwip_send(int s, const void *data, size_t size, int flags)
 #endif /* (LWIP_UDP || LWIP_RAW) */
   }
 
-  write_flags = NETCONN_COPY |
+  write_flags = (u8_t)(NETCONN_COPY |
     ((flags & MSG_MORE)     ? NETCONN_MORE      : 0) |
-    ((flags & MSG_DONTWAIT) ? NETCONN_DONTBLOCK : 0);
+    ((flags & MSG_DONTWAIT) ? NETCONN_DONTBLOCK : 0));
   written = 0;
   err = netconn_write_partly(sock->conn, data, size, write_flags, &written);
 
@@ -1350,9 +1350,9 @@ lwip_sendmsg(int s, const struct msghdr *msg, int flags)
 
   if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP) {
 #if LWIP_TCP
-    write_flags = NETCONN_COPY |
+    write_flags = (u8_t)(NETCONN_COPY |
     ((flags & MSG_MORE)     ? NETCONN_MORE      : 0) |
-    ((flags & MSG_DONTWAIT) ? NETCONN_DONTBLOCK : 0);
+    ((flags & MSG_DONTWAIT) ? NETCONN_DONTBLOCK : 0));
 
     written = 0;
     err = netconn_write_vectors_partly(sock->conn, (struct netvector *)msg->msg_iov, (u16_t)msg->msg_iovlen, write_flags, &written);
@@ -1935,10 +1935,12 @@ lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset,
           /* Wait forever */
           msectimeout = 0;
         } else {
-          msectimeout =  ((timeout->tv_sec * 1000) + ((timeout->tv_usec + 500)/1000));
+          long msecs_long = ((timeout->tv_sec * 1000) + ((timeout->tv_usec + 500)/1000));
-          if (msectimeout == 0) {
+          if (msecs_long <= 0) {
             /* Wait 1ms at least (0 means wait forever) */
             msectimeout = 1;
+          } else {
+            msectimeout = (u32_t)msecs_long;
           }
         }
 
@@ -2848,15 +2850,31 @@ lwip_setsockopt_impl(int s, int level, int optname, const void *optval, socklen_
 
 #if LWIP_SO_SNDTIMEO
     case SO_SNDTIMEO:
-      LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, LWIP_SO_SNDRCVTIMEO_OPTTYPE);
+      {
-      netconn_set_sendtimeout(sock->conn, LWIP_SO_SNDRCVTIMEO_GET_MS(optval));
+        long ms_long;
-      break;
+        LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, LWIP_SO_SNDRCVTIMEO_OPTTYPE);
+        ms_long = LWIP_SO_SNDRCVTIMEO_GET_MS(optval);
+        if (ms_long < 0) {
+          done_socket(sock);
+          return EINVAL;
+        }
+        netconn_set_sendtimeout(sock->conn, ms_long);
+        break;
+      }
 #endif /* LWIP_SO_SNDTIMEO */
 #if LWIP_SO_RCVTIMEO
     case SO_RCVTIMEO:
-      LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, LWIP_SO_SNDRCVTIMEO_OPTTYPE);
+      {
-      netconn_set_recvtimeout(sock->conn, (int)LWIP_SO_SNDRCVTIMEO_GET_MS(optval));
+        long ms_long;
-      break;
+        LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, LWIP_SO_SNDRCVTIMEO_OPTTYPE);
+        ms_long = LWIP_SO_SNDRCVTIMEO_GET_MS(optval);
+        if (ms_long < 0) {
+          done_socket(sock);
+          return EINVAL;
+        }
+        netconn_set_recvtimeout(sock->conn, (u32_t)ms_long);
+        break;
+      }
 #endif /* LWIP_SO_RCVTIMEO */
 #if LWIP_SO_RCVBUF
     case SO_RCVBUF:
@@ -2896,9 +2914,9 @@ lwip_setsockopt_impl(int s, int level, int optname, const void *optval, socklen_
       }
 #endif /* LWIP_UDPLITE */
       if (*(const int*)optval) {
-        udp_setflags(sock->conn->pcb.udp, udp_flags(sock->conn->pcb.udp) | UDP_FLAGS_NOCHKSUM);
+        udp_set_flags(sock->conn->pcb.udp, UDP_FLAGS_NOCHKSUM);
       } else {
-        udp_setflags(sock->conn->pcb.udp, udp_flags(sock->conn->pcb.udp) & ~UDP_FLAGS_NOCHKSUM);
+        udp_clear_flags(sock->conn->pcb.udp, UDP_FLAGS_NOCHKSUM);
       }
       break;
 #endif /* LWIP_UDP */
@@ -2990,9 +3008,9 @@ lwip_setsockopt_impl(int s, int level, int optname, const void *optval, socklen_
     case IP_MULTICAST_LOOP:
       LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, u8_t, NETCONN_UDP);
       if (*(const u8_t*)optval) {
-        udp_setflags(sock->conn->pcb.udp, udp_flags(sock->conn->pcb.udp) | UDP_FLAGS_MULTICAST_LOOP);
+        udp_set_flags(sock->conn->pcb.udp, UDP_FLAGS_MULTICAST_LOOP);
       } else {
-        udp_setflags(sock->conn->pcb.udp, udp_flags(sock->conn->pcb.udp) & ~UDP_FLAGS_MULTICAST_LOOP);
+        udp_clear_flags(sock->conn->pcb.udp, UDP_FLAGS_MULTICAST_LOOP);
       }
       break;
 #endif /* LWIP_IPV4 && LWIP_MULTICAST_TX_OPTIONS && LWIP_UDP */
@@ -3359,10 +3377,15 @@ const char *
 lwip_inet_ntop(int af, const void *src, char *dst, socklen_t size)
 {
   const char *ret = NULL;
+  int size_int = (int)size;
+  if (size_int < 0) {
+    set_errno(ENOSPC);
+    return NULL;
+  }
   switch (af) {
 #if LWIP_IPV4
     case AF_INET:
-      ret = ip4addr_ntoa_r((const ip4_addr_t*)src, dst, size);
+      ret = ip4addr_ntoa_r((const ip4_addr_t*)src, dst, size_int);
       if (ret == NULL) {
         set_errno(ENOSPC);
       }
@@ -3370,7 +3393,7 @@ lwip_inet_ntop(int af, const void *src, char *dst, socklen_t size)
 #endif
 #if LWIP_IPV6
     case AF_INET6:
-      ret = ip6addr_ntoa_r((const ip6_addr_t*)src, dst, size);
+      ret = ip6addr_ntoa_r((const ip6_addr_t*)src, dst, size_int);
       if (ret == NULL) {
         set_errno(ENOSPC);
       }

src/apps/altcp_tls/altcp_tls_mbedtls.c

@@ -388,7 +388,7 @@ altcp_mbedtls_handle_rx_appldata(struct altcp_pcb *conn, altcp_mbedtls_state_t *
       if (ret) {
         LWIP_ASSERT("bogus receive length", ret <= PBUF_POOL_BUFSIZE);
         /* trim pool pbuf to actually decoded length */
-        pbuf_realloc(buf, (uint16_t)ret);
+        pbuf_realloc(buf, (u16_t)ret);
 
         state->bio_bytes_appl += ret;
         if (mbedtls_ssl_get_bytes_avail(&state->ssl_context) == 0) {

src/apps/mqtt/mqtt.c

@@ -683,8 +683,8 @@ mqtt_message_received(mqtt_client_t *client, u8_t fixed_hdr_idx, u16_t length, u
 
     if (client->msg_idx <= MQTT_VAR_HEADER_BUFFER_LEN) {
       /* Should have topic and pkt id*/
-      uint8_t *topic;
+      u8_t *topic;
-      uint16_t after_topic;
+      u16_t after_topic;
       u8_t bkp;
       u16_t topic_len = var_hdr_payload[0];
       topic_len = (topic_len << 8) + (u16_t)(var_hdr_payload[1]);

src/core/ipv4/dhcp.c

@@ -666,7 +666,7 @@ dhcp_handle_ack(struct netif *netif)
   /* DNS servers */
   for (n = 0; (n < LWIP_DHCP_PROVIDE_DNS_SERVERS) && dhcp_option_given(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n); n++) {
     ip_addr_t dns_addr;
-    ip_addr_set_ip4_u32(&dns_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n)));
+    ip_addr_set_ip4_u32_val(dns_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n)));
     dns_setserver(n, &dns_addr);
   }
 #endif /* LWIP_DHCP_PROVIDE_DNS_SERVERS */

src/core/tcp.c

@@ -824,7 +824,7 @@ tcp_update_rcv_ann_wnd(struct tcp_pcb *pcb)
 void
 tcp_recved(struct tcp_pcb *pcb, u16_t len)
 {
-  uint32_t wnd_inflation;
+  u32_t wnd_inflation;
 
   /* pcb->state LISTEN not allowed here */
   LWIP_ASSERT("don't call tcp_recved for listen-pcbs",

src/include/lwip/api.h

@@ -247,7 +247,7 @@ struct netconn {
 #if LWIP_SO_RCVTIMEO
   /** timeout in milliseconds to wait for new data to be received
       (or connections to arrive for listening netconns) */
-  int recv_timeout;
+  u32_t recv_timeout;
 #endif /* LWIP_SO_RCVTIMEO */
 #if LWIP_SO_RCVBUF
   /** maximum amount of bytes queued in recvmbox
@@ -355,11 +355,15 @@ err_t   netconn_gethostbyname(const char *name, ip_addr_t *addr);
 err_t   netconn_err(struct netconn *conn);
 #define netconn_recv_bufsize(conn)      ((conn)->recv_bufsize)
 
+#define netconn_set_flags(conn, set_flags)     do { (conn)->flags = (u8_t)((conn)->flags |  (set_flags)); } while(0)
+#define netconn_clear_flags(conn, clr_flags)   do { (conn)->flags = (u8_t)((conn)->flags & ~(clr_flags)); } while(0)
+#define netconn_is_flag_set(conn, flag)        (((conn)->flags & (flag)) != 0)
+
 /** Set the blocking status of netconn calls (@todo: write/send is missing) */
 #define netconn_set_nonblocking(conn, val)  do { if(val) { \
-  (conn)->flags |= NETCONN_FLAG_NON_BLOCKING; \
+  netconn_set_flags(conn, NETCONN_FLAG_NON_BLOCKING); \
 } else { \
-  (conn)->flags &= ~ NETCONN_FLAG_NON_BLOCKING; }} while(0)
+  netconn_clear_flags(conn, NETCONN_FLAG_NON_BLOCKING); }} while(0)
 /** Get the blocking status of netconn calls (@todo: write/send is missing) */
 #define netconn_is_nonblocking(conn)        (((conn)->flags & NETCONN_FLAG_NON_BLOCKING) != 0)
 
@@ -368,9 +372,9 @@ err_t   netconn_err(struct netconn *conn);
  * TCP: Set the IPv6 ONLY status of netconn calls (see NETCONN_FLAG_IPV6_V6ONLY)
  */
 #define netconn_set_ipv6only(conn, val)  do { if(val) { \
-  (conn)->flags |= NETCONN_FLAG_IPV6_V6ONLY; \
+  netconn_set_flags(conn, NETCONN_FLAG_IPV6_V6ONLY); \
 } else { \
-  (conn)->flags &= ~ NETCONN_FLAG_IPV6_V6ONLY; }} while(0)
+  netconn_clear_flags(conn, NETCONN_FLAG_IPV6_V6ONLY); }} while(0)
 /** @ingroup netconn_common
  * TCP: Get the IPv6 ONLY status of netconn calls (see NETCONN_FLAG_IPV6_V6ONLY)
  */

src/include/lwip/ip.h

@@ -216,9 +216,9 @@ extern struct ip_globals ip_data;
 /** Gets an IP pcb option (SOF_* flags) */
 #define ip_get_option(pcb, opt)   ((pcb)->so_options & (opt))
 /** Sets an IP pcb option (SOF_* flags) */
-#define ip_set_option(pcb, opt)   ((pcb)->so_options |= (opt))
+#define ip_set_option(pcb, opt)   ((pcb)->so_options = (u8_t)((pcb)->so_options | (opt)))
 /** Resets an IP pcb option (SOF_* flags) */
-#define ip_reset_option(pcb, opt) ((pcb)->so_options &= ~(opt))
+#define ip_reset_option(pcb, opt) ((pcb)->so_options = (u8_t)((pcb)->so_options & ~(opt)))
 
 #if LWIP_IPV4 && LWIP_IPV6
 /**

src/include/lwip/sockets.h

@@ -455,8 +455,8 @@ struct in_pktinfo {
   code; }} while(0)
 #define FDSETSAFEGET(n, code) (((n) - LWIP_SOCKET_OFFSET < MEMP_NUM_NETCONN) && (((int)(n) - LWIP_SOCKET_OFFSET) >= 0) ?\
   (code) : 0)
-#define FD_SET(n, p)  FDSETSAFESET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] |=  (1 << (((n)-LWIP_SOCKET_OFFSET) & 7)))
+#define FD_SET(n, p)  FDSETSAFESET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] = (u8_t)((p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] |  (1 << (((n)-LWIP_SOCKET_OFFSET) & 7))))
-#define FD_CLR(n, p)  FDSETSAFESET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] &= ~(1 << (((n)-LWIP_SOCKET_OFFSET) & 7)))
+#define FD_CLR(n, p)  FDSETSAFESET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] = (u8_t)((p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] & ~(1 << (((n)-LWIP_SOCKET_OFFSET) & 7))))
 #define FD_ISSET(n,p) FDSETSAFEGET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] &   (1 << (((n)-LWIP_SOCKET_OFFSET) & 7)))
 #define FD_ZERO(p)    memset((void*)(p), 0, sizeof(*(p)))
 

src/netif/bridgeif.c

@@ -227,7 +227,7 @@ bridgeif_fdb_get_dst_ports(void *fdb_ptr, struct eth_addr *dst_addr)
     bridgeif_dfdb_entry_t *e = &fdb->fdb[i];
     if (e->used && e->ts) {
       if (!memcmp(&e->addr, dst_addr, sizeof(struct eth_addr))) {
-        bridgeif_portmask_t ret = 1 << e->port;
+        bridgeif_portmask_t ret = (bridgeif_portmask_t)(1 << e->port);
         BRIDGEIF_READ_UNPROTECT(lev);
         return ret;
       }
@@ -242,7 +242,9 @@ static void*
 bridgeif_fdb_init(u16_t max_fdb_entries)
 {
   bridgeif_dfdb_t *fdb;
-  mem_size_t alloc_len = sizeof(bridgeif_dfdb_t) + (max_fdb_entries*sizeof(bridgeif_dfdb_entry_t));
+  size_t alloc_len_sizet = sizeof(bridgeif_dfdb_t) + (max_fdb_entries*sizeof(bridgeif_dfdb_entry_t));
+  mem_size_t alloc_len = (mem_size_t)alloc_len_sizet;
+  LWIP_ASSERT("alloc_len == alloc_len_sizet", alloc_len == alloc_len_sizet);
   LWIP_DEBUGF(BRIDGEIF_DEBUG, ("bridgeif_fdb_init: allocating %d bytes for private FDB data\n", (int)alloc_len));
   fdb = (bridgeif_dfdb_t*)mem_calloc(1, alloc_len);
   if (fdb == NULL) {
@@ -455,7 +457,7 @@ bridgeif_send_to_ports(bridgeif_private_t *br, struct pbuf *p, bridgeif_portmask
   bridgeif_portmask_t mask = 1;
   BRIDGEIF_DECL_PROTECT(lev);
   BRIDGEIF_READ_PROTECT(lev);
-  for (i = 0; i < BRIDGEIF_MAX_PORTS; i++, mask <<= 1) {
+  for (i = 0; i < BRIDGEIF_MAX_PORTS; i++, mask = (bridgeif_portmask_t)(mask << 1)) {
     if (dstports & mask) {
       err = bridgeif_send_to_port(br, p, i);
       if (err != ERR_OK) {
@@ -591,6 +593,7 @@ bridgeif_init(struct netif *netif)
 {
   bridgeif_initdata_t *init_data;
   bridgeif_private_t *br;
+  size_t alloc_len_sizet;
   mem_size_t alloc_len;
 
   LWIP_ASSERT("netif != NULL", (netif != NULL));
@@ -609,7 +612,9 @@ bridgeif_init(struct netif *netif)
   LWIP_ASSERT("init_data->max_ports <= BRIDGEIF_MAX_PORTS",
     init_data->max_ports <= BRIDGEIF_MAX_PORTS);
 
-  alloc_len = sizeof(bridgeif_private_t) + (init_data->max_ports*sizeof(bridgeif_port_t) + (init_data->max_fdb_static_entries*sizeof(bridgeif_fdb_static_entry_t)));
+  alloc_len_sizet = sizeof(bridgeif_private_t) + (init_data->max_ports*sizeof(bridgeif_port_t) + (init_data->max_fdb_static_entries*sizeof(bridgeif_fdb_static_entry_t)));
+  alloc_len = (mem_size_t)alloc_len_sizet;
+  LWIP_ASSERT("alloc_len == alloc_len_sizet", alloc_len == alloc_len_sizet);
   LWIP_DEBUGF(BRIDGEIF_DEBUG, ("bridgeif_init: allocating %d bytes for private data\n", (int)alloc_len));
   br = (bridgeif_private_t*)mem_calloc(1, alloc_len);
   if (br == NULL) {
@@ -730,7 +735,7 @@ bridgeif_add_port(struct netif *bridgeif, struct netif *portif)
   /* store pointer to bridge in netif */
   netif_set_client_data(portif, bridgeif_netif_client_id, port);
   /* remove ETHARP flag to prevent sending report events on netif-up */
-  portif->flags &= ~NETIF_FLAG_ETHARP;
+  netif_clear_flags(portif, NETIF_FLAG_ETHARP);
 
   return ERR_OK;
 }