reduce warnings, fix some 32 bit overflow concerns + handle 32bit array capa

Author: boazsegev

fio-stl.h

@@ -7069,7 +7069,7 @@ Returns the current, temporary, array capacity (it's dynamic).
 #### `ARY_reserve`
 
 ```c
-uint32_t ARY_reserve(ARY_s * ary, int32_t capa);
+uint32_t ARY_reserve(ARY_s * ary, int64_t capa);
 ```
 
 Reserves capacity for new members to be added to the array.
@@ -7094,7 +7094,7 @@ Always returns the destination array (`dest`).
 
 ```c
 FIO_ARRAY_TYPE * ARY_set(ARY_s * ary,
-                       int32_t index,
+                       int64_t index,
                        FIO_ARRAY_TYPE data,
                        FIO_ARRAY_TYPE *old);
 ```
@@ -7110,7 +7110,7 @@ Returns a pointer to the new object, or NULL on error.
 #### `ARY_get`
 
 ```c
-FIO_ARRAY_TYPE ARY_get(ARY_s * ary, int32_t index);
+FIO_ARRAY_TYPE ARY_get(ARY_s * ary, int64_t index);
 ```
 
 Returns the value located at `index` (no copying is performed).
@@ -7122,16 +7122,18 @@ If `index` is negative, it will be counted from the end of the Array (-1 == last
 #### `ARY_find`
 
 ```c
-int32_t ARY_find(ARY_s * ary, FIO_ARRAY_TYPE data, int32_t start_at);
+uint32_t ARY_find(ARY_s * ary, FIO_ARRAY_TYPE data, int64_t start_at);
+/* When an object can't be founds, this is the returned value. */
+#define FIO_ARRAY_NOT_FOUND ((uint32_t)-1)
 ```
 
-Returns the index of the object or -1 if the object wasn't found.
+Returns the index of the object or `FIO_ARRAY_NOT_FOUND` (`(uint32_t)-1`) if the object wasn't found.
 
 If `start_at` is negative (i.e., -1), than seeking will be performed in reverse, where -1 == last index (-2 == second to last, etc').
 
 #### `ARY_remove`
 ```c
-int ARY_remove(ARY_s * ary, int32_t index, FIO_ARRAY_TYPE *old);
+int ARY_remove(ARY_s * ary, int64_t index, FIO_ARRAY_TYPE *old);
 ```
 
 Removes an object from the array, MOVING all the other objects to prevent "holes" in the data.
@@ -7217,7 +7219,7 @@ Returns -1 on error (Array is empty) and 0 on success.
 uint32_t ARY_each(ARY_s * ary,
                   int (*task)(ARY_each_s * info),
                   void *arg,
-                  int32_t start_at);
+                  int64_t start_at);
 ```
 
 Iteration using a callback for each entry in the array.
@@ -8526,7 +8528,7 @@ typedef struct {
   /** Connection protocol (once connection established). */
   fio_protocol_s *protocol;
   /** Called in case of a failed connection, use for cleanup. */
-  void (*on_failed)(void *udata);
+  void (*on_failed)(fio_protocol_s *protocol, void *udata);
   /** Opaque user data (set only once connection was established). */
   void *udata;
   /** TLS builder object for TLS connections. */
@@ -8541,7 +8543,7 @@ SFUNC fio_s *fio_srv_connect(fio_srv_connect_args_s args);
 
 Connects to a remote URL (accepting TLS hints in the URL query and scheme). The protocol is only attached if the connection was established.
 
-**Note**: use the `on_failed` callback if cleanup is required after a failed connection. The `on_close` callback is only called if connection was successful.
+**Note**: use the `on_failed` callback if cleanup is required after a failed connection. The protocol's `on_close` callback is only called if connection was successful.
 
 `fio_srv_connect` adds some overhead in parsing the URL for TLS hints and for wrapping the connection protocol for timeout and connection validation before calling the `on_attached`. If these aren't required, it's possible to simply open a socket and attach it like so:
 

fio-stl.md

@@ -1263,15 +1263,15 @@ UTF-8 Support (basic)
 #endif
 
 /* Returns the number of bytes required to UTF-8 encoded a code point `u` */
-FIO_IFUNC size_t fio_utf8_code_len(uint32_t u) {
+FIO_IFUNC unsigned fio_utf8_code_len(uint32_t u) {
   uint32_t len = (1U + ((uint32_t)(u) > 127) + ((uint32_t)(u) > 2047) +
                   ((uint32_t)(u) > 65535));
   len &= (uint32_t)((uint32_t)(u) > ((1U << 21) - 1)) - 1;
   return len;
 }
 
 /** Returns 1-4 (UTF-8 char length), 8 (middle of a char) or 0 (invalid). */
-FIO_IFUNC size_t fio_utf8_char_len_unsafe(uint8_t c) {
+FIO_IFUNC unsigned fio_utf8_char_len_unsafe(uint8_t c) {
   /* Ruby script for map:
   map = [];
   32.times { | i |
@@ -1290,8 +1290,8 @@ FIO_IFUNC size_t fio_utf8_char_len_unsafe(uint8_t c) {
 }
 
 /** Returns the number of valid UTF-8 bytes used by first char at `str`. */
-FIO_IFUNC size_t fio_utf8_char_len(const void *str_) {
-  size_t r, tst;
+FIO_IFUNC unsigned fio_utf8_char_len(const void *str_) {
+  unsigned r, tst;
   const uint8_t *s = (uint8_t *)str_;
   r = fio_utf8_char_len_unsafe(*s) & 7;
 #if FIO_UTF8_ALLOW_IF
@@ -1315,7 +1315,7 @@ FIO_IFUNC size_t fio_utf8_char_len(const void *str_) {
 }
 
 /** Writes code point to `dest` using UFT-8. Returns number of bytes written. */
-FIO_IFUNC size_t fio_utf8_write(void *dest_, uint32_t u) {
+FIO_IFUNC unsigned fio_utf8_write(void *dest_, uint32_t u) {
   const uint8_t len = fio_utf8_code_len(u);
   uint8_t *dest = (uint8_t *)dest_;
 #if FIO_UTF8_ALLOW_IF
@@ -1892,8 +1892,8 @@ typedef struct fio_index8_node_s {
     register const size_t n__ = (i);                                           \
     (root)[n__].node_name.prev = (root)[(head)].node_name.prev;                \
     (root)[n__].node_name.next = (head);                                       \
-    (root)[(root)[(head)].node_name.prev].node_name.next = n__;                \
-    (root)[(head)].node_name.prev = n__;                                       \
+    (root)[(root)[(head)].node_name.prev].node_name.next = (n__);              \
+    (root)[(head)].node_name.prev = (n__);                                     \
   } while (0)
 
 /** UNSAFE macro for adding a node to the begging of the list. */
@@ -1902,9 +1902,9 @@ typedef struct fio_index8_node_s {
     register const size_t n__ = (i);                                           \
     (root)[n__].node_name.next = (root)[(head)].node_name.next;                \
     (root)[n__].node_name.prev = (head);                                       \
-    (root)[(root)[(head)].node_name.next].node_name.prev = n__;                \
-    (root)[(head)].node_name.next = n__;                                       \
-    (head) = n__;                                                              \
+    (root)[(root)[(head)].node_name.next].node_name.prev = (n__);              \
+    (root)[(head)].node_name.next = (n__);                                     \
+    (head) = (n__);                                                            \
   } while (0)
 
 /** UNSAFE macro for removing a node from a list. */
@@ -1925,7 +1925,7 @@ typedef struct fio_index8_node_s {
         (root)[n__].node_name.next;                                            \
     (root)[(root)[n__].node_name.next].node_name.prev =                        \
         (root)[n__].node_name.prev;                                            \
-    (root)[n__].node_name.next = (root)[n__].node_name.prev = n__;             \
+    (root)[n__].node_name.next = (root)[n__].node_name.prev = (n__);           \
   } while (0)
 
 /** Loops through every index in the indexed list, assuming `head` is valid. */

fio-stl/000 core.h

@@ -90,13 +90,15 @@ FIO_IFUNC int fio_sock_dup(int original) {
 #define FIO_SOCK_FD_ISVALID(fd) ((int)fd != (int)-1)
 #endif
 /** Acts as POSIX write. Use this macro for portability with WinSock2. */
-#define fio_sock_write(fd, data, len) write((fd), (data), (len))
+#define fio_sock_write(fd, data, len)      write((fd), (data), (len))
 /** Acts as POSIX read. Use this macro for portability with WinSock2. */
-#define fio_sock_read(fd, buf, len)   read((fd), (buf), (len))
+#define fio_sock_read(fd, buf, len)        read((fd), (buf), (len))
 /** Acts as POSIX dup. Use this macro for portability with WinSock2. */
-#define fio_sock_dup(fd)              dup(fd)
+#define fio_sock_dup(fd)                   dup(fd)
 /** Acts as POSIX close. Use this macro for portability with WinSock2. */
-#define fio_sock_close(fd)            close(fd)
+#define fio_sock_close(fd)                 close(fd)
+/** Acts as POSIX accept. Use this macro for portability with WinSock2. */
+#define fio_sock_accept(fd, addr, addrlen) accept(fd, addr, addrlen)
 #else
 #error FIO_SOCK requires a supported OS (Windows / POSIX).
 #endif

fio-stl/004 sock.h

@@ -300,18 +300,19 @@ FIO_SFUNC uint32_t fio___cli_ary_new_index(fio___cli_ary_s *a) {
     if (!a->ary)
       FIO_LEAK_COUNTER_ON_ALLOC(fio_cli_ary);
     size_t new_capa = a->capa + 8;
+    FIO_ASSERT(new_capa < 0xFFFFFFFFU, "fio_cli data overflow");
     fio_cli_str_s *tmp =
         (fio_cli_str_s *)FIO_MEM_REALLOC_(a->ary,
                                           sizeof(*a->ary) * a->capa,
                                           sizeof(*a->ary) * new_capa,
                                           a->capa);
     FIO_ASSERT_ALLOC(tmp);
     a->ary = tmp;
-    a->capa = new_capa;
+    a->capa = (uint32_t)new_capa;
     if (!(FIO_MEM_REALLOC_IS_SAFE_))
       FIO_MEMSET(a->ary + a->w, 0, sizeof(*a->ary) * (new_capa - a->w));
   }
-  FIO_ASSERT_DEBUG(a->w < a->capa, "CLI array index error!");
+  FIO_ASSERT_DEBUG(a->w < (uint32_t)a->capa, "CLI array index error!");
   return a->w++;
 }
 

fio-stl/005 cli.h

@@ -325,7 +325,7 @@ SFUNC fio_stream_packet_s *fio_stream_pack_data(void *buf,
       tmp->next = p;
       em = (fio_stream_packet_embd_s *)(tmp + 1);
       em->type = FIO_PACKET_TYPE_EMBEDDED;
-      em->length = slice;
+      em->length = (uint32_t)slice;
       FIO_MEMCPY(em->buf, (char *)buf + offset + (len - slice), slice);
       p = tmp;
       len -= slice;

fio-stl/102 stream.h

@@ -1062,7 +1062,7 @@ FIO_SFUNC fio_keystr_s fio_keystr_init(fio_str_info_s str,
   return r;
 no_mem:
   FIO_LOG_FATAL("fio_keystr_init allocation failed - results undefined!!!");
-  r = fio_keystr_tmp(str.buf, str.len);
+  r = fio_keystr_tmp(str.buf, (uint32_t)str.len);
   return r;
 }
 /** Destroys a copy of `fio_keystr_s` - used internally by the hash map. */
@@ -1389,7 +1389,7 @@ fio_string_is_greater
  * Note: returns 0 if data in b is bigger than or equal(!).
  */
 SFUNC int fio_string_is_greater_buf(fio_buf_info_s a, fio_buf_info_s b) {
-  const size_t a_len_is_bigger = a.len > b.len;
+  const int a_len_is_bigger = a.len > b.len;
   size_t len = a_len_is_bigger ? b.len : a.len; /* shared length */
   if (a.buf == b.buf)
     return a_len_is_bigger;
@@ -2509,7 +2509,7 @@ SFUNC int fio_string_write_html_unescape(fio_str_info_s *dest,
           continue;
         del += (*del == ';');
         reduced -= (del - tmp);
-        reduced += fio_utf8_code_len(num);
+        reduced += fio_utf8_code_len((uint32_t)num);
         continue;
       }
       union {
@@ -2561,7 +2561,8 @@ SFUNC int fio_string_write_html_unescape(fio_str_info_s *dest,
             (del[-1] == 'x' ? fio_atol16u : fio_atol10u)((char **)&del);
         if (*del != ';' || num > 65535)
           goto untrusted_no_encode;
-        dest->len += fio_utf8_write((uint8_t *)dest->buf + dest->len, num);
+        dest->len +=
+            fio_utf8_write((uint8_t *)dest->buf + dest->len, (uint32_t)num);
         del += (del < end && del[0] == ';');
         continue;
       }
@@ -2743,7 +2744,7 @@ SFUNC int fio_bstr_reallocate(fio_str_info_s *dest, size_t len) {
   fio___bstr_meta_s *bstr_m = NULL;
   size_t new_capa = fio_string_capa4len(len + sizeof(bstr_m[0]));
   if (FIO_UNLIKELY(new_capa > (size_t)0xFFFFFFFFULL))
-    new_capa = (size_t)0xFFFFFFFFULL + sizeof(bstr_m[0]);
+    new_capa = (size_t)0x0FFFFFFFFULL + sizeof(bstr_m[0]);
   if (dest->capa < fio_string_capa4len(sizeof(bstr_m[0])) - 1)
     goto copy_the_string;
   bstr_m = (fio___bstr_meta_s *)FIO_MEM_REALLOC_(
@@ -2755,7 +2756,8 @@ SFUNC int fio_bstr_reallocate(fio_str_info_s *dest, size_t len) {
     return -1;
 update_metadata:
   dest->buf = (char *)(bstr_m + 1);
-  bstr_m->capa = dest->capa = new_capa - sizeof(bstr_m[0]);
+  dest->capa = new_capa - sizeof(bstr_m[0]);
+  bstr_m->capa = (uint32_t)dest->capa;
   return 0;
 
 copy_the_string:
@@ -2767,7 +2769,7 @@ SFUNC int fio_bstr_reallocate(fio_str_info_s *dest, size_t len) {
   FIO_LEAK_COUNTER_ON_ALLOC(fio_bstr_s);
   if (dest->len) {
     FIO_MEMCPY((bstr_m + 1), dest->buf, dest->len + 1);
-    bstr_m->len = dest->len;
+    bstr_m->len = (uint32_t)dest->len;
   }
   if (dest->capa)
     fio_bstr_free(dest->buf);

fio-stl/102 string core.h

@@ -711,7 +711,7 @@ FIO_IFUNC int fio___mustache_parse_section_end(fio___mustache_parser_s *p,
   if (!FIO_BUF_INFO_IS_EQ(old_var_name, var))
     goto value_name_mismatch;
 
-  fio_u2buf32u(prev + 3, fio_bstr_len(p->root) + 1);
+  fio_u2buf32u(prev + 3, (uint32_t)(fio_bstr_len(p->root) + 1));
   fio___mustache_stand_alone_skip_eol(p);
 
 #if FIO_MUSTACHE_LAMBDA_SUPPORT
@@ -838,7 +838,7 @@ FIO_IFUNC int fio___mustache_parse_partial(fio___mustache_parser_s *p,
   int r = fio___mustache_parse_template_file(&new_section);
   buf.u8[0] = FIO___MUSTACHE_I_STACK_POP;
   p->root = fio_bstr_write(new_section.root, buf.u8, 1);
-  fio_u2buf32u(p->root + ipos, fio_bstr_len(p->root));
+  fio_u2buf32u(p->root + ipos, (uint32_t)fio_bstr_len(p->root));
   fio___mustache_free_template(p, file_content);
   return r;
 }