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         { /* sentinel */ }
  57 };
  58
  59 struct board_info *find_board(const char *model)
  60 {
  61         struct board_info *ret = NULL;
  62         struct board_info *board;
  63
  64         for (board = boards; board->model != NULL; board++) {
  65                 if (strcmp(model, board->model) == 0) {
  66                         ret = board;
  67                         break;
  68                 }
  69         }
  70
  71         return ret;
  72 }
  73
  74 uint32_t make_checksum(struct fw_header *header, uint8_t *payload, int size)
  75 {
  76         cyg_uint32 checksum;
  77
  78         /* get CRC of header */
  79         checksum = cyg_crc32_accumulate(~0L, header, sizeof(*header));
  80
  81         /* get CRC of payload buffer with header CRC as initial value */
  82         return (uint32_t)cyg_crc32_accumulate(checksum, payload, size);
  83 }
  84
  85 void make_header(struct board_info *board, uint8_t *buffer, size_t img_size)
  86 {
  87         struct fw_header *header = (struct fw_header *)buffer;
  88         uint32_t checksum;
  89
  90         strncpy((char *)header->model, board->model, sizeof(header->model)-1);
  91         strncpy((char *)header->version, FW_VERSION, sizeof(header->version)-1);
  92         header->size = HOST_TO_LE32(img_size);
  93         checksum = make_checksum(header, buffer + board->payload_offset, img_size);
  94         header->checksum = HOST_TO_LE32(checksum);
  95 }
  96
  97 int main(int argc, const char *argv[])
  98 {
  99         const char *model_name, *img_in, *img_out;
 100         struct board_info *board;
 101         int file_in, file_out;
 102         struct stat stat_in;
 103         size_t size_in, size_out;
 104         uint8_t *buffer;
 105
 106         if (argc != 4) {
 107                 fprintf(stderr, "Usage: %s <model> <input> <output>\n", argv[0]);
 108                 return EXIT_FAILURE;
 109         }
 110         model_name = argv[1];
 111         img_in = argv[2];
 112         img_out = argv[3];
 113
 114         board = find_board(model_name);
 115         if (board == NULL) {
 116                 fprintf(stderr, "%s: Not supported model\n", model_name);
 117                 return EXIT_FAILURE;
 118         }
 119
 120         if ((file_in = open(img_in, O_RDONLY)) == -1)
 121                 err(EXIT_FAILURE, "%s", img_in);
 122
 123         if (fstat(file_in, &stat_in) == -1)
 124                 err(EXIT_FAILURE, "%s", img_in);
 125
 126         size_in = stat_in.st_size;
 127         size_out = board->payload_offset + size_in;
 128
 129         if ((buffer = malloc(size_out)) == NULL)
 130                 err(EXIT_FAILURE, "malloc");
 131
 132         read(file_in, buffer + board->payload_offset, size_in);
 133         close(file_in);
 134
 135         memset(buffer, 0, board->payload_offset);
 136
 137         make_header(board, buffer, size_in);
 138
 139         if ((file_out = creat(img_out, 0644)) == -1)
 140                 err(EXIT_FAILURE, "%s", img_out);
 141         write(file_out, buffer, size_out);
 142         close(file_out);
 143
 144         free(buffer);
 145
 146         return EXIT_SUCCESS;
 147 }