ported to golang

.gitignore

@@ -1,2 +1,4 @@
 *.vscode
-*pacextractor
+*pacextractor
+*.tar.gz
+*ports

Makefile

@@ -1,16 +1,41 @@
-# Define compiler and flags
-CC = gcc
+# Variables
+BINARY_NAME = pacextractor
+SRC_FILES = pacextractor.go
 
-# Target executable
-TARGET = pacextractor
+# Default target
+all: build
 
-# Source files
-SRC = pacextractor.c
+# Build the binary
+build:
+	go build -o $(BINARY_NAME) $(SRC_FILES)
 
-# Rule to build the target
-$(TARGET): $(SRC)
-	$(CC) $(SRC) -o $(TARGET)
+# Format the code
+fmt:
+	go fmt $(SRC_FILES)
 
-# Clean up build artifacts
+# Run go vet for static analysis
+vet:
+	go vet $(SRC_FILES)
+
+# Run the program with default arguments (modify as needed)
+run: build
+	./$(BINARY_NAME) firmware.pac output_directory
+
+# Clean the build
 clean:
-	rm -f $(TARGET)
+	rm -f $(BINARY_NAME)
+
+# Help message
+help:
+	@echo "Makefile for building and managing the Go project"
+	@echo ""
+	@echo "Usage:"
+	@echo "  make           - Build the project"
+	@echo "  make build     - Build the binary"
+	@echo "  make fmt       - Format the source files"
+	@echo "  make vet       - Run go vet for static analysis"
+	@echo "  make run       - Run the program with default arguments"
+	@echo "  make clean     - Remove the binary"
+	@echo "  make help      - Show this help message"
+
+.PHONY: all build fmt vet run clean help

pacextractor.c

@@ -1,267 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <stdint.h>
-#include <sys/stat.h>
-
-#define VERSION "1.0.0"
-
-typedef struct {
-    int16_t someField[24];
-    int32_t someInt;
-    int16_t productName[256];
-    int16_t firmwareName[256];
-    int32_t partitionCount;
-    int32_t partitionsListStart;
-    int32_t someIntFields1[5];
-    int16_t productName2[50];
-    int16_t someIntFields2[6];
-    int16_t someIntFields3[2];
-} PacHeader;
-
-typedef struct {
-    uint32_t length;
-    int16_t partitionName[256];
-    int16_t fileName[512];
-    uint32_t partitionSize;
-    int32_t someFields1[2];
-    uint32_t partitionAddrInPac;
-    int32_t someFields2[3];
-    int32_t dataArray[];
-} PartitionHeader;
-
-static void getString(const int16_t* baseString, char* resString) {
-    if (baseString == NULL || resString == NULL) {
-        *resString = '\0';
-        return;
-    }
-
-    while (*baseString) {
-        *resString++ = (char)(*baseString & 0xFF);
-        baseString++;
-        if (resString - resString > 255) { // Prevent buffer overflow
-            break;
-        }
-    }
-    *resString = '\0'; // Null-terminate the result string
-}
-
-static void printUsage(void) {
-    printf("Usage: pacextractor <firmware name>.pac <output path>\n");
-    printf("Options:\n");
-    printf("  -h               Show this help message and exit\n");
-    printf("  -v               Show version information and exit\n");
-}
-
-static void printUsageAndExit(void) {
-    printUsage();
-    exit(EXIT_FAILURE);
-}
-
-static void handleOpenFileError(const char* fileName) {
-    perror(fileName);
-    exit(EXIT_FAILURE);
-}
-
-static int openFirmwareFile(const char* filePath) {
-    int fd = open(filePath, O_RDONLY);
-    if (fd == -1) {
-        handleOpenFileError(filePath);
-    }
-    return fd;
-}
-
-static void createOutputDirectory(const char* path) {
-    if (access(path, F_OK) == -1) {
-        if (mkdir(path, 0777) == -1) {
-            perror("Failed to create output directory");
-            exit(EXIT_FAILURE);
-        }
-        printf("Created output directory: %s\n", path);
-    }
-}
-
-static PacHeader readPacHeader(int fd) {
-    PacHeader header;
-    if (read(fd, &header, sizeof(PacHeader)) != sizeof(PacHeader)) {
-        perror("Error while reading PAC header");
-        exit(EXIT_FAILURE);
-    }
-    return header;
-}
-
-static PartitionHeader* readPartitionHeader(int fd, uint32_t* curPos) {
-    lseek(fd, *curPos, SEEK_SET);
-    uint32_t length;
-    if (read(fd, &length, sizeof(length)) != sizeof(length)) {
-        perror("Error while reading partition header length");
-        exit(EXIT_FAILURE);
-    }
-    
-    PartitionHeader* header = malloc(length);
-    if (header == NULL) {
-        perror("Memory allocation failed");
-        exit(EXIT_FAILURE);
-    }
-    
-    lseek(fd, *curPos, SEEK_SET);
-    if (read(fd, header, length) != length) {
-        perror("Error while reading partition header");
-        free(header);
-        exit(EXIT_FAILURE);
-    }
-    
-    *curPos += length;
-    return header;
-}
-
-static void printProgressBar(uint32_t completed, uint32_t total) {
-    const int barWidth = 50;
-    float progress = (float)completed / total;
-    int pos = barWidth * progress;
-
-    printf("\r[");
-    for (int i = 0; i < barWidth; ++i) {
-        if (i < pos) printf("=");
-        else if (i == pos) printf(">");
-        else printf(" ");
-    }
-    printf("] %.2f%%", progress * 100.0);
-    fflush(stdout);
-}
-
-static void extractPartition(int fd, const PartitionHeader* partHeader, const char* outputPath) {
-    if (partHeader->partitionSize == 0) {
-        return;
-    }
-
-    lseek(fd, partHeader->partitionAddrInPac, SEEK_SET);
-
-    // Increase buffer size for faster I/O operations
-    const size_t BUFFER_SIZE = 256 * 1024; // 256 KB
-    char* buffer = malloc(BUFFER_SIZE);
-    if (buffer == NULL) {
-        perror("Memory allocation failed");
-        exit(EXIT_FAILURE);
-    }
-
-    char outputFilePath[768];
-    char fileName[512];
-    getString(partHeader->fileName, fileName);
-    snprintf(outputFilePath, sizeof(outputFilePath), "%s/%s", outputPath, fileName);
-
-    if (remove(outputFilePath) == -1 && errno != ENOENT) {
-        perror("Error removing existing output file");
-        free(buffer);
-        exit(EXIT_FAILURE);
-    }
-
-    int fd_new = open(outputFilePath, O_WRONLY | O_CREAT | O_TRUNC, 0666);
-    if (fd_new == -1) {
-        perror("Error creating output file");
-        free(buffer);
-        exit(EXIT_FAILURE);
-    }
-
-    printf("Extracting to %s\n", outputFilePath);
-
-    uint32_t dataSizeLeft = partHeader->partitionSize;
-    uint32_t dataSizeRead = 0;
-
-    while (dataSizeLeft > 0) {
-        uint32_t copyLength = (dataSizeLeft > BUFFER_SIZE) ? BUFFER_SIZE : dataSizeLeft;
-        ssize_t rb = read(fd, buffer, copyLength);
-        if (rb != copyLength) {
-            perror("Error while reading partition data");
-            close(fd_new);
-            free(buffer);
-            exit(EXIT_FAILURE);
-        }
-        ssize_t wb = write(fd_new, buffer, copyLength);
-        if (wb != copyLength) {
-            perror("Error while writing partition data");
-            close(fd_new);
-            free(buffer);
-            exit(EXIT_FAILURE);
-        }
-        dataSizeLeft -= copyLength;
-        dataSizeRead += copyLength;
-        printProgressBar(dataSizeRead, partHeader->partitionSize);
-    }
-    printf("\n");
-    close(fd_new);
-    free(buffer);
-}
-
-int main(int argc, char** argv) {
-    if (argc < 2) {
-        printUsageAndExit();
-    }
-
-    if (strcmp(argv[1], "-h") == 0) {
-        printUsage();
-        exit(EXIT_SUCCESS);
-    } else if (strcmp(argv[1], "-v") == 0) {
-        printf("pacextractor version %s\n", VERSION);
-        exit(EXIT_SUCCESS);
-    }
-
-    if (argc < 3) {
-        printUsageAndExit();
-    }
-
-    int fd = openFirmwareFile(argv[1]);
-    
-    struct stat st;
-    if (fstat(fd, &st) == -1) {
-        perror("Error getting file stats");
-        exit(EXIT_FAILURE);
-    }
-    int firmwareSize = st.st_size;
-    if (firmwareSize < sizeof(PacHeader)) {
-        fprintf(stderr, "file %s is not a valid firmware\n", argv[1]);
-        close(fd);
-        exit(EXIT_FAILURE);
-    }
-
-    char* outputPath = argv[2];
-    createOutputDirectory(outputPath);
-
-    PacHeader pacHeader = readPacHeader(fd);
-    
-    char firmwareName[256];
-    getString(pacHeader.firmwareName, firmwareName);
-    printf("Firmware name: %s\n", firmwareName);
-
-    uint32_t curPos = pacHeader.partitionsListStart;
-    PartitionHeader** partHeaders = malloc(pacHeader.partitionCount * sizeof(PartitionHeader*));
-    if (partHeaders == NULL) {
-        perror("Memory allocation failed for partition headers");
-        close(fd);
-        exit(EXIT_FAILURE);
-    }
-
-    for (int i = 0; i < pacHeader.partitionCount; i++) {
-        partHeaders[i] = readPartitionHeader(fd, &curPos);
-        
-        char partitionName[256];
-        char fileName[512];
-        getString(partHeaders[i]->partitionName, partitionName);
-        getString(partHeaders[i]->fileName, fileName);
-        printf("Partition name: %s\n\twith file name: %s\n\twith size %u\n",
-               partitionName, fileName, partHeaders[i]->partitionSize);
-    }
-
-    for (int i = 0; i < pacHeader.partitionCount; i++) {
-        extractPartition(fd, partHeaders[i], outputPath);
-        free(partHeaders[i]);
-    }
-    free(partHeaders);
-    close(fd);
-    
-    return EXIT_SUCCESS;
-}

pacextractor.go

@@ -0,0 +1,271 @@
+package main
+
+import (
+	"encoding/binary"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+)
+
+// Version of the extractor
+const Version = "1.0.0"
+
+// PacHeader is the structure for the PAC file header
+type PacHeader struct {
+	SomeField           [24]int16
+	SomeInt             int32
+	ProductName         [256]int16
+	FirmwareName        [256]int16
+	PartitionCount      int32
+	PartitionsListStart int32
+	SomeIntFields1      [5]int32
+	ProductName2        [50]int16
+	SomeIntFields2      [6]int16
+	SomeIntFields3      [2]int16
+}
+
+// PartitionHeader is the structure for each partition in the PAC file
+type PartitionHeader struct {
+	Length             uint32
+	PartitionName      [256]int16
+	FileName           [512]int16
+	PartitionSize      uint32
+	SomeFields1        [2]int32
+	PartitionAddrInPac uint32
+	SomeFields2        [3]int32
+}
+
+// getString converts an int16 array to a UTF-8 string
+func getString(baseString []int16) string {
+	var resString string
+	for _, ch := range baseString {
+		if ch == 0 {
+			break
+		}
+		resString += string(rune(ch))
+	}
+	return resString
+}
+
+// printUsage prints the usage information
+func printUsage() {
+	fmt.Println("Usage: pacextractor <firmware name>.pac <output path>")
+	fmt.Println("Options:")
+	fmt.Println("  -h               Show this help message and exit")
+	fmt.Println("  -v               Show version information and exit")
+}
+
+// openFirmwareFile opens the firmware file
+func openFirmwareFile(filePath string) (*os.File, error) {
+	fd, err := os.Open(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("Error opening file %s: %w", filePath, err)
+	}
+	return fd, nil
+}
+
+// createOutputDirectory creates the output directory if it doesn't exist
+func createOutputDirectory(path string) error {
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		err = os.MkdirAll(path, 0777)
+		if err != nil {
+			return fmt.Errorf("Failed to create output directory: %w", err)
+		}
+		fmt.Printf("Created output directory: %s\n", path)
+	}
+	return nil
+}
+
+// readPacHeader reads the PAC file header
+func readPacHeader(fd *os.File) (PacHeader, error) {
+	var header PacHeader
+	err := binary.Read(fd, binary.LittleEndian, &header)
+	if err != nil {
+		return header, fmt.Errorf("Error while reading PAC header: %w", err)
+	}
+	return header, nil
+}
+
+// readPartitionHeader reads the partition header at the current file offset
+func readPartitionHeader(fd *os.File) (PartitionHeader, error) {
+	var header PartitionHeader
+	err := binary.Read(fd, binary.LittleEndian, &header)
+	if err != nil {
+		return header, fmt.Errorf("Error while reading partition header: %w", err)
+	}
+	return header, nil
+}
+
+// printProgressBar prints a progress bar
+func printProgressBar(completed, total uint32) {
+	const barWidth = 50
+	progress := float64(completed) / float64(total)
+	pos := int(barWidth * progress)
+
+	fmt.Print("\r[")
+	for i := 0; i < barWidth; i++ {
+		if i < pos {
+			fmt.Print("=")
+		} else if i == pos {
+			fmt.Print(">")
+		} else {
+			fmt.Print(" ")
+		}
+	}
+	fmt.Printf("] %.2f%%", progress*100)
+}
+
+// extractPartition extracts a partition to a file
+func extractPartition(fd *os.File, partHeader PartitionHeader, outputPath string) error {
+	if partHeader.PartitionSize == 0 {
+		return nil
+	}
+
+	_, err := fd.Seek(int64(partHeader.PartitionAddrInPac), io.SeekStart)
+	if err != nil {
+		return fmt.Errorf("Error seeking partition data: %w", err)
+	}
+
+	// Increase buffer size for faster I/O operations
+	const bufferSize = 256 * 1024 // 256 KB
+	buffer := make([]byte, bufferSize)
+
+	fileName := getString(partHeader.FileName[:])
+	outputFilePath := filepath.Join(outputPath, fileName)
+
+	// Remove existing file if it exists
+	err = os.Remove(outputFilePath)
+	if err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("Error removing existing output file: %w", err)
+	}
+
+	fdNew, err := os.OpenFile(outputFilePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
+	if err != nil {
+		return fmt.Errorf("Error creating output file: %w", err)
+	}
+	defer fdNew.Close()
+
+	fmt.Printf("Extracting to %s\n", outputFilePath)
+
+	dataSizeLeft := partHeader.PartitionSize
+	var dataSizeRead uint32
+
+	for dataSizeLeft > 0 {
+		copyLength := bufferSize
+		if int(dataSizeLeft) < bufferSize {
+			copyLength = int(dataSizeLeft)
+		}
+
+		n, err := io.ReadFull(fd, buffer[:copyLength])
+		if err != nil {
+			return fmt.Errorf("Error while reading partition data: %w", err)
+		}
+
+		_, err = fdNew.Write(buffer[:n])
+		if err != nil {
+			return fmt.Errorf("Error while writing partition data: %w", err)
+		}
+
+		dataSizeLeft -= uint32(n)
+		dataSizeRead += uint32(n)
+		printProgressBar(dataSizeRead, partHeader.PartitionSize)
+	}
+
+	fmt.Println()
+	return nil
+}
+
+func main() {
+	flag.Usage = printUsage
+	flagVersion := flag.Bool("v", false, "Show version information and exit")
+	flagHelp := flag.Bool("h", false, "Show help message and exit")
+	flag.Parse()
+
+	if *flagHelp {
+		printUsage()
+		os.Exit(0)
+	}
+
+	if *flagVersion {
+		fmt.Printf("pacextractor version %s\n", Version)
+		os.Exit(0)
+	}
+
+	args := flag.Args()
+	if len(args) < 2 {
+		printUsage()
+		os.Exit(1)
+	}
+
+	firmwarePath := args[0]
+	outputPath := args[1]
+
+	fd, err := openFirmwareFile(firmwarePath)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	defer fd.Close()
+
+	fileInfo, err := fd.Stat()
+	if err != nil {
+		fmt.Printf("Error getting file stats: %v\n", err)
+		os.Exit(1)
+	}
+
+	firmwareSize := fileInfo.Size()
+	if firmwareSize < int64(binary.Size(PacHeader{})) {
+		fmt.Printf("file %s is not a valid firmware\n", firmwarePath)
+		os.Exit(1)
+	}
+
+	err = createOutputDirectory(outputPath)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	pacHeader, err := readPacHeader(fd)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	firmwareName := getString(pacHeader.FirmwareName[:])
+	fmt.Printf("Firmware name: %s\n", firmwareName)
+
+	curPos := int64(pacHeader.PartitionsListStart)
+	partHeaders := make([]PartitionHeader, pacHeader.PartitionCount)
+
+	for i := 0; i < int(pacHeader.PartitionCount); i++ {
+		_, err := fd.Seek(curPos, io.SeekStart)
+		if err != nil {
+			fmt.Printf("Error seeking to partition %d: %v\n", i, err)
+			os.Exit(1)
+		}
+
+		partHeader, err := readPartitionHeader(fd)
+		if err != nil {
+			fmt.Printf("Error reading partition %d: %v\n", i, err)
+			os.Exit(1)
+		}
+
+		partHeaders[i] = partHeader
+
+		partitionName := getString(partHeader.PartitionName[:])
+		fileName := getString(partHeader.FileName[:])
+		fmt.Printf("Partition name: %s\n\twith file name: %s\n\twith size %d\n", partitionName, fileName, partHeader.PartitionSize)
+
+		curPos += int64(partHeader.Length)
+	}
+
+	for i := 0; i < int(pacHeader.PartitionCount); i++ {
+		err = extractPartition(fd, partHeaders[i], outputPath)
+		if err != nil {
+			fmt.Printf("Error extracting partition %d: %v\n", i, err)
+			os.Exit(1)
+		}
+	}
+}