src/iptime-crc32.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2021 Sungbo Eo <mans0n@gorani.run>
   4  *
   5  * This code is based on mkdhpimg.c and mkzcfw.c
   6  * Copyright (C) 2010 Gabor Juhos <juhosg@openwrt.org>
   7  * Copyright (c) 2016 FUKAUMI Naoki <naobsd@gmail.com>
   8  *
   9  * Checksum algorithm is derived from add_iptime_fw_header.c
  10  * Copyright (C) 2020 Jaehoon You <teslamint@gmail.com>
  11  */
  12
  13 #include <byteswap.h>
  14 #include <endian.h>
  15 #include <err.h>
  16 #include <errno.h>
  17 #include <fcntl.h>
  18 #include <stdint.h>
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <sys/stat.h>
  23 #include <unistd.h>
  24
  25 #include "cyg_crc.h"
  26
  27 #if !defined(__BYTE_ORDER)
  28 #error "Unknown byte order"
  29 #endif
  30
  31 #if (__BYTE_ORDER == __BIG_ENDIAN)
  32 #define HOST_TO_LE32(x) bswap_32(x)
  33 #elif (__BYTE_ORDER == __LITTLE_ENDIAN)
  34 #define HOST_TO_LE32(x) (x)
  35 #else
  36 #error "Unsupported endianness"
  37 #endif
  38
  39 #define FW_VERSION      "00_000"
  40
  41 struct fw_header {
  42         uint8_t model[8];
  43         uint8_t version[8];
  44         uint8_t reserved[32];
  45         uint32_t size;
  46         uint32_t checksum;
  47 } __attribute__ ((packed));
  48
  49 struct board_info {
  50         const char *model;
  51         size_t payload_offset;
  52 };
  53
  54 struct board_info boards[] = {
  55         { .model = "ax2004m", .payload_offset = 0x38 },
  56         { .model = "ax8004m", .payload_offset = 0x38 },
  57         { /* sentinel */ }
  58 };
  59
  60 struct board_info *find_board(const char *model)
  61 {
  62         struct board_info *ret = NULL;
  63         struct board_info *board;
  64
  65         for (board = boards; board->model != NULL; board++) {
  66                 if (strcmp(model, board->model) == 0) {
  67                         ret = board;
  68                         break;
  69                 }
  70         }
  71
  72         return ret;
  73 }
  74
  75 uint32_t make_checksum(struct fw_header *header, uint8_t *payload, int size)
  76 {
  77         cyg_uint32 checksum;
  78
  79         /* get CRC of header */
  80         checksum = cyg_crc32_accumulate(~0L, header, sizeof(*header));
  81
  82         /* get CRC of payload buffer with header CRC as initial value */
  83         return (uint32_t)cyg_crc32_accumulate(checksum, payload, size);
  84 }
  85
  86 void make_header(struct board_info *board, uint8_t *buffer, size_t img_size)
  87 {
  88         struct fw_header *header = (struct fw_header *)buffer;
  89         uint32_t checksum;
  90
  91         strncpy((char *)header->model, board->model, sizeof(header->model)-1);
  92         strncpy((char *)header->version, FW_VERSION, sizeof(header->version)-1);
  93         header->size = HOST_TO_LE32(img_size);
  94         checksum = make_checksum(header, buffer + board->payload_offset, img_size);
  95         header->checksum = HOST_TO_LE32(checksum);
  96 }
  97
  98 int main(int argc, const char *argv[])
  99 {
 100         const char *model_name, *img_in, *img_out;
 101         struct board_info *board;
 102         int file_in, file_out;
 103         struct stat stat_in;
 104         size_t size_in, size_out;
 105         uint8_t *buffer;
 106
 107         if (argc != 4) {
 108                 fprintf(stderr, "Usage: %s <model> <input> <output>\n", argv[0]);
 109                 return EXIT_FAILURE;
 110         }
 111         model_name = argv[1];
 112         img_in = argv[2];
 113         img_out = argv[3];
 114
 115         board = find_board(model_name);
 116         if (board == NULL) {
 117                 fprintf(stderr, "%s: Not supported model\n", model_name);
 118                 return EXIT_FAILURE;
 119         }
 120
 121         if ((file_in = open(img_in, O_RDONLY)) == -1)
 122                 err(EXIT_FAILURE, "%s", img_in);
 123
 124         if (fstat(file_in, &stat_in) == -1)
 125                 err(EXIT_FAILURE, "%s", img_in);
 126
 127         size_in = stat_in.st_size;
 128         size_out = board->payload_offset + size_in;
 129
 130         if ((buffer = malloc(size_out)) == NULL)
 131                 err(EXIT_FAILURE, "malloc");
 132
 133         read(file_in, buffer + board->payload_offset, size_in);
 134         close(file_in);
 135
 136         memset(buffer, 0, board->payload_offset);
 137
 138         make_header(board, buffer, size_in);
 139
 140         if ((file_out = creat(img_out, 0644)) == -1)
 141                 err(EXIT_FAILURE, "%s", img_out);
 142         write(file_out, buffer, size_out);
 143         close(file_out);
 144
 145         free(buffer);
 146
 147         return EXIT_SUCCESS;
 148 }