[all] Covered Env with a test

kernel/kernel/tasking/tasking.c

···
 
     // Inlined part of kmem_bring_to_kernel_ptrarr
     for (int i = start_with; i < *kargc; i++) {
-        res[i] = kmem_bring_to_kernel(argv[i - 1], strlen(argv[i - 1]) + 1);
+        res[i] = kmem_bring_to_kernel(argv[i - start_with], strlen(argv[i - start_with]) + 1);
     }
 
     *kargv = res;

libs/libc/stdlib/env.c

···
             continue;
         }
         size_t curlen = (size_t)(eqpos - envv);
-        if (curlen == len && strncmp(name, envv, len)) {
+        if (curlen == len && strncmp(name, envv, len) == 0) {
             return (char*)&envv[len + 1];
         }
     }
···
     }
 
     char** new_environ = (char**)malloc(sizeof(char*) * (env_i + 2));
-    for (int i = 0; environ[i]; i++) {
+    for (int i = 0; i < env_i; i++) {
         new_environ[i] = environ[i];
     }
     new_environ[env_i] = string;
-    new_environ[env_i] = NULL;
+    new_environ[env_i + 1] = NULL;
 
     extern int __environ_malloced;
     if (__environ_malloced) {

test/kernel/BUILD.gn

···
 
 group("test_kernel") {
   deps = [
+    "//test/kernel/env:env",
     "//test/kernel/fs:fs",
     "//test/kernel/signal:signal",
   ]

test/kernel/env/BUILD.gn

···
+import("//build/test/TEMPLATE.gni")
+
+opuntiaOS_test("env") {
+  test_bundle = "kernel/env"
+  sources = [ "main.c" ]
+  configs = [ "//build/userland:userland_flags" ]
+  deplibs = [ "libc" ]
+}

test/kernel/env/main.c

···
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+int main(int argc, char** argv)
+{
+    if (getenv("OSTEST")) {
+        char* res = getenv("GO");
+        if (!res) {
+            TestErr("Empty GO env var.");
+        }
+        if (strncmp(res, "go", 2)) {
+            TestErr("Different value in GO env var.");
+        }
+        return 0;
+    }
+
+    if (argc > 1) {
+        TestErr("Loop while executing test.");
+    }
+
+    char* argvs[] = {
+        "loop"
+    };
+
+    setenv("OSTEST", "1", 1);
+    setenv("GO", "go", 1);
+    execve(argv[0], argvs, environ);
+    return 1;
+}

userland/shell/onesh/main.c

···
 enum internal_cmd_code {
     CMD_NONE = 0,
     CMD_CD,
+    CMD_SET,
+    CMD_UNSET,
+    CMD_ENV,
 };
 
 uint32_t _is_cmd_internal()
···
     if (memcmp(_cmd_buffer, "cd", 2) == 0) {
         return CMD_CD;
     }
+    if (memcmp(_cmd_buffer, "set", 3) == 0) {
+        return CMD_SET;
+    }
+    if (memcmp(_cmd_buffer, "env", 3) == 0) {
+        return CMD_ENV;
+    }
+    if (memcmp(_cmd_buffer, "unset", 5) == 0) {
+        return CMD_UNSET;
+    }
     return CMD_NONE;
 }
 
···
 {
     if (code == CMD_CD) {
         return chdir(_cmd_parsed_buffer[1]);
+    }
+    if (code == CMD_SET) {
+        char* eqpos = strchr(_cmd_parsed_buffer[1], '=');
+        if (!eqpos) {
+            return 0;
+        }
+        *eqpos = '\0';
+        return setenv(_cmd_parsed_buffer[1], (char*)(eqpos + 1), 1);
+    }
+    if (code == CMD_UNSET) {
+        return unsetenv(_cmd_parsed_buffer[1]);
+    }
+    if (code == CMD_ENV) {
+        for (int i = 0; environ[i]; i++) {
+            const char* envv = environ[i];
+            char* eqpos = strchr(envv, '=');
+            if (!eqpos) {
+                continue;
+            }
+            size_t len = strlen(envv);
+            write(STDOUT, envv, len);
+            write(STDOUT, "\n", 1);
+        }
     }
     return 0;
 }
···
         int res = fork();
         if (!res) {
             // We don't pass an app name to args.
-            execve(_cmd_app, &_cmd_parsed_buffer[1], 0);
+            execve(_cmd_app, &_cmd_parsed_buffer[1], environ);
             exit(-1);
         } else {
             running_job = res;