Update main.odin

Author: michal92299

source-code/backend/main.odin

@@ -53,7 +53,6 @@ State :: struct {
 
 deinit_state :: proc(self: ^State, allocator: mem.Allocator) {
     for key, value in self.packages {
-        delete(key, allocator)
         delete(value.version, allocator)
         delete(value.checksum, allocator)
     }
@@ -78,7 +77,6 @@ main :: proc() {
     defer delete(backing)
     allocator := mem.arena_allocator(&arena)
     context.allocator = allocator
-
     args := os.args[1:]
     if len(args) < 3 {
         output_error(allocator, .InvalidArgs, "Usage: backend [install|remove|verify] <package> <path> [checksum]")
@@ -91,27 +89,26 @@ main :: proc() {
     if len(args) > 3 {
         checksum = args[3]
     }
-
     switch command {
-    case "install":
-        install(allocator, package_name, path, checksum)
-    case "remove":
-        remove(allocator, package_name, path)
-    case "verify":
-        if checksum == nil {
-            output_error(allocator, .InvalidArgs, "Checksum required for verify")
-            return
-        }
-        verify(allocator, path, checksum.?)
-        payload := struct { success: bool }{true}
-        output, merr := json.marshal(payload)
-        if merr != nil {
-            panic("JSON marshal failed")
-        }
-        defer delete(output)
-        os.write(os.stdout, output)
-    case:
-        output_error(allocator, .UnknownCommand, "Unknown command")
+        case "install":
+            install(allocator, package_name, path, checksum)
+        case "remove":
+            remove(allocator, package_name, path)
+        case "verify":
+            if checksum == nil {
+                output_error(allocator, .InvalidArgs, "Checksum required for verify")
+                return
+            }
+            verify(allocator, path, checksum.?)
+            payload := struct { success: bool }{true}
+            output, merr := json.marshal(payload)
+            if merr != nil {
+                panic("JSON marshal failed")
+            }
+            defer delete(output)
+            os.write(os.stdout, output)
+        case:
+            output_error(allocator, .UnknownCommand, "Unknown command")
     }
 }
 
@@ -140,7 +137,7 @@ load_manifest :: proc(allocator: mem.Allocator, path: string) -> Manifest {
     }
     defer delete(data)
     manifest: Manifest
-    err := json.unmarshal(data, &manifest, {allocator = allocator})
+    err := json.unmarshal(data, &manifest, allocator = allocator)
     if err != nil {
         panic("Failed to parse manifest")
     }
@@ -151,37 +148,33 @@ install :: proc(allocator: mem.Allocator, package_name: string, path: string, ch
     tmp_path := fmt.aprintf("{}.tmp", path)
     defer delete(tmp_path)
     merr := os.make_directory(tmp_path)
-    if merr != os.Errno(0) && merr != os.Errno(linux.EEXIST) {
-        panic("Failed to create tmp directory")
+    if merr != nil {
+        ge, ok := merr.(os.General_Error)
+        if !(ok && ge == .Exist) {
+            panic("Failed to create tmp directory")
+        }
     }
-
     manifest := load_manifest(allocator, tmp_path)
     defer deinit_manifest(&manifest, allocator)
-
     if manifest.deps != nil && len(manifest.deps) > 0 {
         for dep in manifest.deps {
             // TODO: Full DAG, cycle detection
             fmt.eprintf("Installing dep: {}\n", dep)
         }
     }
-
     setup_sandbox(allocator, package_name, tmp_path, &manifest)
-
     if chk, ok := checksum.?; ok {
         verify(allocator, tmp_path, chk)
     }
-
     rerr := os.rename(tmp_path, path)
-    if rerr != os.Errno(0) {
+    if rerr != nil {
         panic("Rename failed")
     }
-
     checksum_str := "none"
     if c, ok := checksum.?; ok {
         checksum_str = c
     }
     update_state(allocator, package_name, manifest.version, checksum_str)
-
     payload := struct { success: bool, package_name: string }{true, package_name}
     output, merr2 := json.marshal(payload)
     if merr2 != nil {
@@ -194,19 +187,16 @@ install :: proc(allocator: mem.Allocator, package_name: string, path: string, ch
 remove :: proc(allocator: mem.Allocator, package_name: string, path: string) {
     manifest := load_manifest(allocator, path)
     defer deinit_manifest(&manifest, allocator)
-
     if manifest.bins != nil && len(manifest.bins) > 0 {
         for bin in manifest.bins {
             bin_path := fmt.aprintf("/usr/bin/{}", bin)
             defer delete(bin_path)
             _ = os.remove(bin_path)
         }
     }
-
-    if err := delete_tree(path); err != os.Errno(0) {
+    if err := delete_tree(path); err != nil {
         panic("Delete tree failed")
     }
-
     state := load_state(allocator)
     defer deinit_state(&state, allocator)
     if pi, found := state.packages[package_name]; found {
@@ -215,7 +205,6 @@ remove :: proc(allocator: mem.Allocator, package_name: string, path: string) {
         delete_key(&state.packages, package_name)
     }
     save_state(&state)
-
     payload := struct { success: bool, package_name: string }{true, package_name}
     output, merr := json.marshal(payload)
     if merr != nil {
@@ -233,21 +222,18 @@ verify :: proc(allocator: mem.Allocator, path: string, checksum: string) {
         panic("Failed to read manifest for verify")
     }
     defer delete(data)
-
     ctx: sha2.Context_256
     sha2.init_256(&ctx)
     sha2.update(&ctx, data)
     hash: [sha2.DIGEST_SIZE_256]u8
     sha2.final(&ctx, hash[:])
-
     computed_builder: strings.Builder
     strings.builder_init(&computed_builder, allocator)
     defer strings.builder_destroy(&computed_builder)
     for b in hash {
         fmt.sbprintf(&computed_builder, "{:02x}", b)
     }
     computed := strings.to_string(computed_builder)
-
     if computed != checksum {
         output_error(allocator, .VerificationFailed, "Checksum mismatch")
     }
@@ -265,7 +251,6 @@ setup_sandbox :: proc(allocator: mem.Allocator, package_name: string, path: stri
     append(&args, "--bind", path, "/app")
     append(&args, "--chdir", "/app")
     append(&args, "--unshare-all")
-
     if !manifest.sandbox.network {
         append(&args, "--unshare-net")
     } else {
@@ -277,23 +262,20 @@ setup_sandbox :: proc(allocator: mem.Allocator, package_name: string, path: stri
         }
     }
     append(&args, "--", "sh", "-c", "echo Isolated install complete") // Replace with actual
-
     code := run_command(args[:])
     delete(args)
-
     if code != 0 {
         output_error(allocator, .InstallFailed, "Sandbox failed")
     }
 }
 
 run_command :: proc(argv: []string) -> i32 {
-    pid := linux.fork()
-    if pid < 0 {
+    pid, ferr := linux.fork()
+    if ferr != .NONE {
         panic("Fork failed")
     }
     if pid == 0 {
-        c_argv := make([]cstring, len(argv) + 1)
-        defer delete(c_argv)
+        c_argv := make([]cstring, len(argv) + 1, context.temp_allocator)
         for arg, i in argv {
             c_argv[i] = strings.clone_to_cstring(arg, context.temp_allocator)
         }
@@ -304,7 +286,7 @@ run_command :: proc(argv: []string) -> i32 {
     }
     status: u32
     _, werr := linux.waitpid(pid, &status, {}, nil)
-    if werr != os.Errno(0) {
+    if werr != .NONE {
         return -1
     }
     if linux.WIFEXITED(status) {
@@ -313,15 +295,14 @@ run_command :: proc(argv: []string) -> i32 {
     return -1
 }
 
-delete_tree :: proc(path: string) -> os.Errno {
+delete_tree :: proc(path: string) -> os.Error {
     dir, open_err := os.open(path, os.O_RDONLY)
-    if open_err != os.Errno(0) {
+    if open_err != nil {
         return open_err
     }
     defer os.close(dir)
-
     entries, read_err := os.read_dir(dir, -1)
-    if read_err != os.Errno(0) {
+    if read_err != nil {
         return read_err
     }
     defer {
@@ -330,21 +311,19 @@ delete_tree :: proc(path: string) -> os.Errno {
         }
         delete(entries)
     }
-
     for entry in entries {
         full_path := fmt.tprintf("%s/%s", path, entry.name)
         defer delete(full_path)
         if entry.is_dir {
-            if del_err := delete_tree(full_path); del_err != os.Errno(0) {
+            if del_err := delete_tree(full_path); del_err != nil {
                 return del_err
             }
         } else {
-            if rem_err := os.remove(full_path); rem_err != os.Errno(0) {
+            if rem_err := os.remove(full_path); rem_err != nil {
                 return rem_err
             }
         }
     }
-
     return os.remove_directory(path)
 }
 
@@ -357,7 +336,7 @@ load_state :: proc(allocator: mem.Allocator) -> State {
     }
     defer delete(data)
     state: State
-    err := json.unmarshal(data, &state, {allocator = allocator})
+    err := json.unmarshal(data, &state, allocator = allocator)
     if err != nil {
         panic("Failed to parse state")
     }
@@ -366,7 +345,7 @@ load_state :: proc(allocator: mem.Allocator) -> State {
 
 save_state :: proc(state: ^State) {
     file, open_err := os.open(STATE_PATH, os.O_CREATE | os.O_WRONLY | os.O_TRUNC)
-    if open_err != os.Errno(0) {
+    if open_err != nil {
         panic("Failed to open state file")
     }
     defer os.close(file)
@@ -376,7 +355,7 @@ save_state :: proc(state: ^State) {
     }
     defer delete(data)
     _, write_err := os.write(file, data)
-    if write_err != os.Errno(0) {
+    if write_err != nil {
         panic("Failed to write state file")
     }
 }