Kernel: Switch to strlcpy() as well

Surprisingly, most uses of strncpy() are in places where strncpy() is actually a better choice.
For example, copying to a fixed-length char array in a structure.

kernel/include/std/string.h

@@ -8,6 +8,7 @@ __attribute__((deprecated)) int strcmp(const char* a, const char* b);
 __attribute__((deprecated)) char* strcat(char* dest, const char* src);
 
 char* strncpy(char* dest, const char* src, size_t n);
+size_t strlcpy(char* dest, const char* src, size_t size);
 int strncmp(const char* a, const char* b, size_t n);
 char* strncat(char* dest, const char* src, size_t n);
 

kernel/include/trace/Resolve.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <stddef.h>
 #include <stdint.h>
 
-void get_symbol_name(uintptr_t address, char* buffer);
+void get_symbol_name(uintptr_t address, char* buffer, size_t size);

kernel/src/std/string.cpp

@@ -17,11 +17,29 @@ char* strcpy(char* dest, const char* src)
 
 char* strncpy(char* dest, const char* src, size_t n)
 {
-    size_t src_len = strlen(src) + 1; // NULL byte
-    memcpy(dest, src, src_len > n ? n : src_len);
+    size_t i;
+    for (i = 0; i < n && src[i] != 0; i++) dest[i] = src[i];
+    for (; i < n; i++) dest[i] = 0;
     return dest;
 }
 
+size_t strlcpy(char* dest, const char* src, size_t size)
+{
+    size_t len = strlen(src);
+    if (size == 0) return len;
+    if (len < (size - 1))
+    {
+        memcpy(dest, src, len);
+        dest[len] = 0;
+    }
+    else
+    {
+        memcpy(dest, src, size - 1);
+        dest[size - 1] = 0;
+    }
+    return len;
+}
+
 int strcmp(const char* a, const char* b)
 {
     while (*a && (*a == *b))

kernel/src/trace/Resolve.cpp

@@ -17,10 +17,10 @@ static size_t symbol_strlen(const char* symbol)
     return (i - symbol);
 }
 
-void get_symbol_name(uintptr_t address, char* buffer)
+void get_symbol_name(uintptr_t address, char* buffer, size_t max)
 {
     if (symbol_map.addr == (void*)-1) { symbol_map = InitRD::open("sys/moon.sym"); }
-    if (!symbol_map.addr) { strncpy(buffer, "(no symbols loaded)", 20); }
+    if (!symbol_map.addr) { strlcpy(buffer, "(no symbols loaded)", max); }
     while (address >= (uintptr_t)&kernel_start && address <= (uintptr_t)&kernel_end)
     {
         char addr_as_str[60];
@@ -30,11 +30,12 @@ void get_symbol_name(uintptr_t address, char* buffer)
         {
             symbol += 19;
             size_t symlen = symbol_strlen(symbol);
-            memcpy(buffer, symbol, symlen);
-            buffer[symlen] = 0;
+            size_t copylen = (max - 1) < symlen ? (max - 1) : symlen;
+            memcpy(buffer, symbol, copylen);
+            buffer[copylen] = 0;
             return;
         }
         address--;
     }
-    strncpy(buffer, "(no symbol)", 12);
+    strlcpy(buffer, "(no symbol)", max);
 }

kernel/src/trace/StackTracer.cpp

@@ -24,7 +24,7 @@ void StackTracer::trace()
     while (frame)
     {
         char symbol_name[512];
-        get_symbol_name(frame->instruction, symbol_name);
+        get_symbol_name(frame->instruction, symbol_name, sizeof(symbol_name));
         printf("%lx: %s\n", frame->instruction, symbol_name);
         frame = frame->next;
     }
@@ -33,7 +33,7 @@ void StackTracer::trace()
 void StackTracer::trace_with_ip(uintptr_t ip)
 {
     char symbol_name[512];
-    get_symbol_name(ip, symbol_name);
+    get_symbol_name(ip, symbol_name, sizeof(symbol_name));
     printf("%lx: %s\n", ip, symbol_name);
     trace();
 }