1 // SPDX-License-Identifier: GPL-2.0-only
4 * Copyright (C) 2007 OpenWrt.org
5 * Copyright (C) 2007 Gabor Juhos <juhosg at openwrt.org>
12 #include <unistd.h> /* for unlink() */
14 #include <getopt.h> /* for getopt() */
18 #include <endian.h> /* for __BYTE_ORDER */
21 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
22 # define HOST_TO_LE16(x) (x)
23 # define HOST_TO_LE32(x) (x)
24 # define LE16_TO_HOST(x) (x)
25 # define LE32_TO_HOST(x) (x)
27 # define HOST_TO_LE16(x) bswap_16(x)
28 # define HOST_TO_LE32(x) bswap_32(x)
29 # define LE16_TO_HOST(x) bswap_16(x)
30 # define LE32_TO_HOST(x) bswap_32(x)
33 #define MAX_NUM_BLOCKS 2
34 #define MAX_ARG_COUNT 32
35 #define MAX_ARG_LEN 1024
36 #define FILE_BUF_LEN (16*1024)
37 #define DEFAULT_PADC 0xFF
39 #define DEFAULT_BLOCK_ALIGN 0x10000U
41 #define CSUM_TYPE_NONE 0
43 #define CSUM_TYPE_16 2
44 #define CSUM_TYPE_32 3
55 char *file_name
; /* name of the file */
56 uint32_t file_size
; /* length of the file */
72 } __attribute__ ((packed
));
83 } __attribute__ ((packed
));
95 uint32_t max_kernel_size
;
99 #define HEADER_TYPE_NFS 0
100 #define HEADER_TYPE_CAS 1
102 #define KERNEL_SIZE_CAS (61*64*1024)
103 #define KERNEL_SIZE_NFS (52*64*1024)
104 #define FS_SIZE_NFS (9*64*1024)
106 #define CAS_MAGIC1 0x5241AA55
107 #define CAS_MAGIC2 0x524F4741
108 #define CAS_MAGIC3 0xD3F22D4E
110 /* Cellvision/SparkLAN products */
111 #define MODEL_CAS_630 0x01000000
112 #define MODEL_CAS_630W 0x01000000
113 #define MODEL_CAS_670 0x01000000
114 #define MODEL_CAS_670W 0x01000000
115 #define MODEL_NFS_101U 0x01000000
116 #define MODEL_NFS_101WU 0x01000003
117 #define MODEL_NFS_202U 0x01000001
118 #define MODEL_NFS_202WU 0x01000002
120 /* Corega products */
121 #define MODEL_CG_NSADP 0x01000020 /* NFS-101U */
122 #define MODEL_CG_NSADPCR 0x01000021 /* NFS-202U */
124 /* D-Link products */
125 #define MODEL_DCS_950 0x01010102 /* CAS-630 */
126 #define MODEL_DCS_950G 0x01020102 /* CAS-630W */
127 #define MODEL_DNS_120 0x01000030 /* NFS-101U */
128 #define MODEL_DNS_G120 0x01000032 /* NFS-101WU */
130 /* Digitus products */
131 #define MODEL_DN_16021 MODEL_CAS_630
132 #define MODEL_DN_16022 MODEL_CAS_630W
133 #define MODEL_DN_16030 MODEL_CAS_670
134 #define MODEL_DN_16031 MODEL_CAS_670W
135 #define MODEL_DN_7013 MODEL_NFS_101U
138 #define MODEL_LB_SS01TXU 0x00000000
140 /* Neu-Fusion products */
142 /* Ovislink products */
143 #define MODEL_MU_5000FS 0x01000040 /* NFS-101U */
144 #define MODEL_WL_5420CAM 0x020B0101 /* CAS-630W? */
145 #define MODEL_WL_5460CAM 0x020B0001 /* CAS-670W */
147 /* Repotec products */
149 /* Sitecom products */
150 #define MODEL_LN_350 /* unknown */
151 #define MODEL_LN_403 0x01020402
152 #define MODEL_WL_401 0x01010402
154 /* Surecom products */
155 #define MODEL_EP_4001_MM 0x01030A02 /* CAS-630 */
156 #define MODEL_EP_4002_MM 0x01020A02 /* CAS-630W */
157 #define MODEL_EP_4011_MM 0x01010A02 /* CAS-670 */
158 #define MODEL_EP_4012_MM 0x01000A02 /* CAS-670W */
159 #define MODEL_EP_9812_U /* unknown */
161 /* Trendnet products */
162 #define MODEL_TN_U100 0x01000081 /* NFS-101U */
163 #define MODEL_TN_U200 0x01000082 /* NFS-202U */
171 int keep_invalid_images
;
172 int invalid_causes_error
= 1;
173 union file_hdr header
;
175 struct image_desc kernel_image
;
176 struct image_desc fs_image
;
178 struct board_info
*board
= NULL
;
180 #define BOARD(m, n, i, ks, fs, h) { \
184 .max_kernel_size = (ks), \
185 .max_fs_size = (fs), \
189 #define BOARD_CAS(m,n,i) \
190 BOARD(m, n, i, KERNEL_SIZE_CAS, 0, HEADER_TYPE_CAS)
191 #define BOARD_NFS(m,n,i) \
192 BOARD(m, n, i, KERNEL_SIZE_NFS, FS_SIZE_NFS, HEADER_TYPE_NFS)
194 static struct board_info boards
[] = {
195 /* Cellvision/Sparklan products */
196 BOARD_CAS("CAS-630", "Cellvision CAS-630", MODEL_CAS_630
),
197 BOARD_CAS("CAS-630W", "Cellvision CAS-630W", MODEL_CAS_630W
),
198 BOARD_CAS("CAS-670", "Cellvision CAS-670", MODEL_CAS_670
),
199 BOARD_CAS("CAS-670W", "Cellvision CAS-670W", MODEL_CAS_670W
),
200 BOARD_NFS("NFS-101U", "Cellvision NFS-101U", MODEL_NFS_101U
),
201 BOARD_NFS("NFS-101WU", "Cellvision NFS-101WU", MODEL_NFS_101WU
),
202 BOARD_NFS("NFS-202U", "Cellvision NFS-202U", MODEL_NFS_202U
),
203 BOARD_NFS("NFS-202WU", "Cellvision NFS-202WU", MODEL_NFS_202WU
),
205 /* Corega products */
206 BOARD_NFS("CG-NSADP", "Corega CG-NSADP", MODEL_CG_NSADP
),
207 BOARD_NFS("CG-NSADPCR", "Corega CG-NSADPCR", MODEL_CG_NSADPCR
),
209 /* D-Link products */
210 BOARD_CAS("DCS-950", "D-Link DCS-950", MODEL_DCS_950
),
211 BOARD_CAS("DCS-950G", "D-Link DCS-950G", MODEL_DCS_950G
),
212 BOARD_NFS("DNS-120", "D-Link DNS-120", MODEL_DNS_120
),
213 BOARD_NFS("DNS-G120", "D-Link DNS-G120", MODEL_DNS_G120
),
215 /* Digitus products */
216 BOARD_NFS("DN-7013", "Digitus DN-7013", MODEL_DN_7013
),
219 BOARD_NFS("LB-SS01TXU", "Lobos LB-SS01TXU", MODEL_LB_SS01TXU
),
221 /* Ovislink products */
222 BOARD_NFS("MU-5000FS", "Ovislink MU-5000FS", MODEL_MU_5000FS
),
223 BOARD_CAS("WL-5420CAM", "Ovislink WL-5420 CAM", MODEL_WL_5420CAM
),
224 BOARD_CAS("WL-5460CAM", "Ovislink WL-5460 CAM", MODEL_WL_5460CAM
),
226 /* Sitecom products */
227 BOARD_CAS("LN-403", "Sitecom LN-403", MODEL_LN_403
),
228 BOARD_CAS("WL-401", "Sitecom WL-401", MODEL_WL_401
),
230 /* Surecom products */
231 BOARD_CAS("EP-4001-MM", "Surecom EP-4001-MM", MODEL_EP_4001_MM
),
232 BOARD_CAS("EP-4002-MM", "Surecom EP-4002-MM", MODEL_EP_4002_MM
),
233 BOARD_CAS("EP-4011-MM", "Surecom EP-4011-MM", MODEL_EP_4011_MM
),
234 BOARD_CAS("EP-4012-MM", "Surecom EP-4012-MM", MODEL_EP_4012_MM
),
236 /* TrendNET products */
237 BOARD_NFS("TN-U100", "TrendNET TN-U100", MODEL_TN_U100
),
238 BOARD_NFS("TN-U200", "TrendNET TN-U200", MODEL_TN_U200
),
246 #define ERR(fmt, ...) do { \
248 fprintf(stderr, "[%s] *** error: " fmt "\n", \
249 progname, ## __VA_ARGS__ ); \
252 #define ERRS(fmt, ...) do { \
255 fprintf(stderr, "[%s] *** error: " fmt ": %s\n", \
256 progname, ## __VA_ARGS__, strerror(save)); \
259 #define WARN(fmt, ...) do { \
260 fprintf(stderr, "[%s] *** warning: " fmt "\n", \
261 progname, ## __VA_ARGS__ ); \
264 #define DBG(lev, fmt, ...) do { \
265 if (verblevel < lev) \
267 fprintf(stderr, "[%s] " fmt "\n", progname, ## __VA_ARGS__ ); \
271 #define ERR_INVALID_IMAGE -2
276 FILE *stream
= (status
!= EXIT_SUCCESS
) ? stderr
: stdout
;
277 struct board_info
*board
;
279 fprintf(stream
, "Usage: %s [OPTIONS...] <file>\n", progname
);
283 " -B <board> create image for the board specified with <board>.\n"
284 " valid <board> values:\n"
286 for (board
= boards
; board
->model
!= NULL
; board
++){
289 board
->model
, board
->name
);
292 " -d don't throw error on invalid images\n"
293 " -k keep invalid images\n"
294 " -K <file> add kernel to the image\n"
295 " -C <file> add custom filesystem to the image\n"
296 " -h show this screen\n"
298 " <file> write output to the file <file>\n"
304 static inline uint32_t align(uint32_t base
, uint32_t alignment
)
309 ret
= (base
+ alignment
- 1);
310 ret
&= ~(alignment
-1);
322 str2u32(char *arg
, uint32_t *val
)
328 t
= strtoul(arg
, &err
, 0);
329 if (errno
|| (err
==arg
) || ((err
!= NULL
) && *err
)) {
339 str2u16(char *arg
, uint16_t *val
)
345 t
= strtoul(arg
, &err
, 0);
346 if (errno
|| (err
==arg
) || ((err
!= NULL
) && *err
) || (t
>= 0x10000)) {
355 str2u8(char *arg
, uint8_t *val
)
361 t
= strtoul(arg
, &err
, 0);
362 if (errno
|| (err
==arg
) || ((err
!= NULL
) && *err
) || (t
>= 0x100)) {
371 parse_arg(char *arg
, char *buf
, char *argv
[])
379 memset(argv
, 0, MAX_ARG_COUNT
* sizeof(void *));
392 if (argl
>= MAX_ARG_LEN
) {
393 /* argument is too long */
394 argl
= MAX_ARG_LEN
-1;
397 memcpy(buf
, arg
, argl
);
400 for (i
= 0; i
< MAX_ARG_COUNT
; i
++) {
401 tok
= strsep(ap
, ":");
406 else if (tok
[0] == '\0') {
419 required_arg(char c
, char *arg
)
421 if (arg
== NULL
|| *arg
!= '-')
424 ERR("option -%c requires an argument\n", c
);
430 is_empty_arg(char *arg
)
441 csum8_update(uint8_t *p
, uint32_t len
, struct csum_state
*css
)
443 for ( ; len
> 0; len
--) {
450 csum8_get(struct csum_state
*css
)
460 csum16_update(void *data
, uint32_t len
, struct csum_state
*css
)
466 t
= css
->tmp
+ (p
[0]<<8);
467 css
->val
+= LE16_TO_HOST(t
);
473 for ( ; len
> 1; len
-= 2, p
+=2 ) {
474 t
= p
[0] + (p
[1] << 8);
475 css
->val
+= LE16_TO_HOST(t
);
486 csum16_get(struct csum_state
*css
)
490 csum16_update(&pad
, 1, css
);
491 return ~css
->val
+ 1;
495 csum32_update(uint8_t *p
, uint32_t len
, struct csum_state
*css
)
499 for ( ; len
> 3; len
-= 4, p
+= 4 ) {
500 t
= p
[0] + (p
[1] << 8) + (p
[2] << 16) + (p
[3] << 24);
506 csum32_get(struct csum_state
*css
)
513 csum_init(struct csum_state
*css
, int size
)
522 csum_update(void *data
, uint32_t len
, struct csum_state
*css
)
528 csum8_update(p
,len
,css
);
531 csum16_update(p
,len
,css
);
534 csum32_update(p
,len
,css
);
541 csum_get(struct csum_state
*css
)
547 ret
= csum8_get(css
);
550 ret
= csum16_get(css
);
553 ret
= csum32_get(css
);
556 ERR("invalid checksum size\n");
565 * routines to write data to the output file
568 write_out_data(FILE *outfile
, void *data
, size_t len
,
569 struct csum_state
*css
)
575 fwrite(ptr
, len
, 1, outfile
);
577 ERRS("unable to write output file");
582 csum_update(ptr
, len
, css
);
590 write_out_padding(FILE *outfile
, size_t len
, uint8_t padc
,
591 struct csum_state
*css
)
594 size_t buflen
= sizeof(buf
);
597 memset(buf
, padc
, buflen
);
602 err
= write_out_data(outfile
, buf
, buflen
, css
);
614 image_stat_file(struct image_desc
*desc
)
619 if (desc
->file_name
== NULL
)
622 err
= stat(desc
->file_name
, &st
);
624 ERRS("stat failed on %s", desc
->file_name
);
628 if (st
.st_size
> desc
->out_size
) {
629 WARN("file %s is too big, will be truncated to %d bytes\n",
630 desc
->file_name
, desc
->out_size
);
631 desc
->file_size
= desc
->out_size
;
632 return ERR_INVALID_IMAGE
;
636 desc
->file_size
= st
.st_size
;
637 desc
->out_size
= align(desc
->file_size
,1);
643 image_writeout_file(FILE *outfile
, struct image_desc
*desc
,
644 struct csum_state
*css
)
646 char buf
[FILE_BUF_LEN
];
647 size_t buflen
= sizeof(buf
);
652 if (desc
->file_name
== NULL
)
655 if (desc
->file_size
== 0)
659 f
= fopen(desc
->file_name
,"r");
661 ERRS("unable to open file: %s", desc
->file_name
);
665 len
= desc
->file_size
;
670 /* read data from source file */
672 fread(buf
, buflen
, 1, f
);
674 ERRS("unable to read from file: %s", desc
->file_name
);
679 res
= write_out_data(outfile
, buf
, buflen
, css
);
692 image_writeout(FILE *outfile
, struct image_desc
*desc
)
695 struct csum_state css
;
700 if (!desc
->file_size
)
703 DBG(2, "writing image, file=%s, file_size=%d\n",
704 desc
->file_name
, desc
->file_size
);
706 csum_init(&css
, CSUM_TYPE_32
);
708 res
= image_writeout_file(outfile
, desc
, &css
);
712 /* write padding data if neccesary */
713 padlen
= desc
->out_size
- desc
->file_size
;
714 DBG(1,"padding desc, length=%zu", padlen
);
715 res
= write_out_padding(outfile
, padlen
, desc
->padc
, &css
);
717 desc
->csum
= csum_get(&css
);
724 write_out_header(FILE *outfile
)
730 if (fseek(outfile
, 0, SEEK_SET
) != 0) {
731 ERRS("fseek failed on output file");
735 switch (board
->header_type
) {
736 case HEADER_TYPE_CAS
:
737 tmp
.cas
.type
= HOST_TO_LE32(header
.cas
.type
);
738 tmp
.cas
.id
= HOST_TO_LE32(header
.cas
.id
);
739 tmp
.cas
.kernel_offs
= HOST_TO_LE32(sizeof(tmp
.cas
));
740 tmp
.cas
.kernel_size
= HOST_TO_LE32(kernel_image
.out_size
);
741 tmp
.cas
.kernel_csum
= HOST_TO_LE32(kernel_image
.csum
);
742 tmp
.cas
.magic1
= HOST_TO_LE32(CAS_MAGIC1
);
743 tmp
.cas
.magic2
= HOST_TO_LE32(CAS_MAGIC2
);
744 tmp
.cas
.magic3
= HOST_TO_LE32(CAS_MAGIC3
);
745 res
= write_out_data(outfile
, (uint8_t *)&tmp
.cas
,
746 sizeof(tmp
.cas
), NULL
);
748 case HEADER_TYPE_NFS
:
749 tmp
.nfs
.type
= HOST_TO_LE32(header
.nfs
.type
);
750 tmp
.nfs
.id
= HOST_TO_LE32(header
.nfs
.id
);
751 tmp
.nfs
.kernel_offs
= HOST_TO_LE32(sizeof(tmp
.nfs
));
752 tmp
.nfs
.kernel_size
= HOST_TO_LE32(kernel_image
.out_size
);
753 tmp
.nfs
.kernel_csum
= HOST_TO_LE32(kernel_image
.csum
);
754 tmp
.nfs
.fs_offs
= HOST_TO_LE32(sizeof(tmp
.nfs
)
755 + kernel_image
.out_size
);
756 tmp
.nfs
.fs_size
= HOST_TO_LE32(fs_image
.out_size
);
757 tmp
.nfs
.fs_csum
= HOST_TO_LE32(fs_image
.csum
);
758 res
= write_out_data(outfile
, (uint8_t *)&tmp
.nfs
,
759 sizeof(tmp
.nfs
), NULL
);
762 ERR("invalid header type\n");
770 write_out_images(FILE *outfile
)
774 res
= image_writeout(outfile
, &kernel_image
);
778 res
= image_writeout(outfile
, &fs_image
);
787 find_board(char *model
)
789 struct board_info
*ret
;
790 struct board_info
*board
;
793 for (board
= boards
; board
->model
!= NULL
; board
++){
794 if (strcasecmp(model
, board
->model
) == 0) {
805 parse_opt_board(char ch
, char *arg
)
808 DBG(1,"parsing board option: -%c %s", ch
, arg
);
811 ERR("only one board option allowed");
815 if (required_arg(ch
, arg
))
818 board
= find_board(arg
);
820 ERR("invalid/unknown board specified: %s", arg
);
824 switch (board
->header_type
) {
825 case HEADER_TYPE_CAS
:
826 header
.cas
.type
= HEADER_TYPE_CAS
;
827 header
.cas
.id
= board
->id
;
829 case HEADER_TYPE_NFS
:
830 header
.nfs
.type
= HEADER_TYPE_NFS
;
831 header
.nfs
.id
= board
->id
;
834 ERR("internal error, unknown header type\n");
843 parse_opt_image(char ch
, char *arg
)
845 char buf
[MAX_ARG_LEN
];
846 char *argv
[MAX_ARG_COUNT
];
848 struct image_desc
*desc
= NULL
;
853 if (kernel_image
.file_name
) {
854 WARN("only one kernel option allowed");
857 desc
= &kernel_image
;
860 if (fs_image
.file_name
) {
861 WARN("only one fs option allowed");
871 parse_arg(arg
, buf
, argv
);
875 if (!is_empty_arg(p
)) {
876 desc
->file_name
= strdup(p
);
877 if (desc
->file_name
== NULL
) {
878 ERR("not enough memory");
882 ERR("no file specified for option %c", ch
);
895 kernel_image
.out_size
= board
->max_kernel_size
;
896 kernel_image
.padc
= DEFAULT_PADC
;
897 res
= image_stat_file(&kernel_image
);
901 if (!fs_image
.file_name
)
904 fs_image
.out_size
= board
->max_fs_size
;
905 fs_image
.padc
= DEFAULT_PADC
;
906 res
= image_stat_file(&fs_image
);
915 main(int argc
, char *argv
[])
917 int optinvalid
= 0; /* flag for invalid option */
923 progname
=basename(argv
[0]);
925 opterr
= 0; /* could not print standard getopt error messages */
929 c
= getopt(argc
, argv
, "B:C:dhK:r:vw:x:");
935 optinvalid
= parse_opt_board(c
,optarg
);
938 invalid_causes_error
= 0;
942 optinvalid
= parse_opt_image(c
,optarg
);
945 keep_invalid_images
= 1;
957 if (optinvalid
!= 0 ){
958 ERR("invalid option: -%c", optopt
);
964 ERR("no board specified");
968 if (optind
== argc
) {
969 ERR("no output file specified");
973 ofname
= argv
[optind
++];
976 ERR("invalid option: %s", argv
[optind
]);
980 res
= process_images();
981 if (res
== ERR_FATAL
)
984 if (res
== ERR_INVALID_IMAGE
) {
985 if (invalid_causes_error
)
988 if (keep_invalid_images
== 0) {
989 WARN("generation of invalid images \"%s\" disabled", ofname
);
993 WARN("generating invalid image: \"%s\"", ofname
);
996 outfile
= fopen(ofname
, "w");
997 if (outfile
== NULL
) {
998 ERRS("could not open \"%s\" for writing", ofname
);
1003 if (write_out_header(outfile
) != 0) {
1008 if (write_out_images(outfile
) != 0) {
1013 if (write_out_header(outfile
) != 0) {
1018 DBG(1,"Image file %s completed.", ofname
);
1023 if (res
== ERR_FATAL
) {
1027 if (res
== ERR_FATAL
)
1028 return EXIT_FAILURE
;
1030 return EXIT_SUCCESS
;