firmware-utils/mksercommfw: fix build with clang/macOS
[openwrt/openwrt.git] / tools / firmware-utils / src / mksercommfw.c
1 #include <stdio.h>
2 #include <string.h>
3 #include <stdlib.h>
4 #include <sys/types.h>
5
6 /* #define DEBUG 1 */
7
8 /*
9 * Fw Header Layout for Netgear / Sercomm devices
10 * */
11 static const char *magic = "sErCoMm"; /* 7 */
12 /* 7-11: version control/download control ? */
13 unsigned char version[4] = {0x00, 0x01, 0x00, 0x00};
14 char *hwID = ""; /* 11-43 , ASCII/HEX */
15 char *hwVer = ""; /* 44-57 , ASCII/HEX */
16 char *swVer = ""; /* 58-62 , ASCII/HEX */
17 /* magic again. */
18
19 #define HEADER_SIZE 71
20
21 /* null bytes until 511 */
22 u_int32_t checksum = 0xFF; /* checksum */
23 /* 512 onwards -> ZIP containing rootfs with the same Header */
24
25
26 /* appended on rootfs for the Header. */
27 const int footer_size = 128;
28
29 struct file_info {
30 char *file_name; /* name of the file */
31 char *file_data; /* data of the file in memory */
32 u_int32_t file_size; /* length of the file */
33 };
34
35 u_int8_t getCheckSum(char *data, int len)
36 {
37
38 int32_t previous = 0;
39 u_int32_t new = 0;
40
41 for (u_int32_t i = 0; i < len; i++) {
42 new = (data[i] + previous) % 256;
43 previous = new | previous & -256;
44 }
45 return (u_int8_t) new;
46 }
47
48 void *bufferFile(struct file_info *finfo, int dontload)
49 {
50 int fs = 0;
51 FILE *f = NULL;
52
53 #ifdef DEBUG
54 printf("Opening file: %s\n", finfo->file_name);
55 #endif
56 f = fopen(finfo->file_name, "rb");
57 if (f == NULL) {
58 perror("Error");
59 exit(1);
60 }
61
62 fseek(f, 0L, SEEK_END);
63 fs = ftell(f);
64 rewind(f);
65
66 #ifdef DEBUG
67 printf("Filesize: %i .\n", fs);
68 #endif
69
70 finfo->file_size = fs;
71
72 if (dontload) {
73 return 0;
74 }
75
76 char *data = malloc(fs);
77 finfo->file_data = data;
78
79 int read = fread(data, fs, 1, f);
80
81 if (read != 1) {
82 printf("Error reading file %s.", finfo->file_name);
83 exit(1);
84 }
85
86 #ifdef DEBUG
87 printf("File: read successfully %i bytes.\n", read*fs);
88 #endif
89 fclose(f);
90 }
91
92 void *writeFile(struct file_info *finfo)
93 {
94
95 #ifdef DEBUG
96 printf("Writing file: %s.\n", finfo->file_name);
97 #endif
98
99 FILE *fout = fopen(finfo->file_name, "w");
100
101 if (!fwrite(finfo->file_data, finfo->file_size, 1, fout)) {
102 printf("Wanted to write, but something went wrong.\n");
103 fclose(fout);
104 exit(1);
105 }
106 fclose(fout);
107 }
108
109 void *rmFile(struct file_info *finfo)
110 {
111 remove(finfo->file_name);
112 free(finfo->file_data);
113 finfo->file_size = 0;
114 }
115
116 void *usage(char *argv[])
117 {
118 printf("Usage: %s <sysupgradefile> <kernel_offset> <HWID> <HWVER> <SWID>\n"
119 "All are positional arguments ... \n"
120 " sysupgradefile: File with the kernel uimage at 0\n"
121 " kernel_offset: Offset in Hex where the kernel is located\n"
122 " HWID: Hardware ID, ASCII\n"
123 " HWVER: Hardware Version, ASCII\n"
124 " SWID: Software Version, Hex\n"
125 " \n"
126 " ", argv[0]);
127 }
128
129 int main(int argc, char *argv[])
130 {
131 printf("Building fw image for sercomm devices.\n");
132
133 if (argc == 2) {
134 struct file_info myfile = {argv[1], 0, 0};
135 bufferFile(&myfile, 0);
136 char chksum = getCheckSum(myfile.file_data, myfile.file_size);
137 printf("Checksum for File: %X.\n", chksum);
138 return 0;
139 }
140
141 if (argc != 6) {
142 usage(argv);
143 return 1;
144 }
145
146 /* Args */
147
148 struct file_info sysupgrade = {argv[1], 0, 0};
149 bufferFile(&sysupgrade, 0);
150
151 int kernel_offset = 0x90000; /* offset for the kernel inside the rootfs, default val */
152 sscanf(argv[2], "%X", &kernel_offset);
153 #ifdef DEBUG
154 printf("Kernel_offset: at %X/%i bytes.\n", kernel_offset, kernel_offset);
155 #endif
156 char *hwID = argv[3];
157 char *hwVer = argv[4];
158 u_int32_t swVer = 0;
159 sscanf(argv[5],"%4X",&swVer);
160 swVer = bswap_32(swVer);
161
162 char *rootfsname = malloc(2*strlen(sysupgrade.file_name) + 8);
163 sprintf(rootfsname, "%s.rootfs", sysupgrade.file_name);
164
165 char *zipfsname = malloc(2*strlen(rootfsname) + 5);
166 sprintf(zipfsname, "%s.zip", rootfsname);
167 /* / Args */
168
169 #ifdef DEBUG
170 printf("Building header: %s %s %2X %s.\n", hwID , hwVer, swVer, magic);
171 #endif
172 /* Construct the firmware header/magic */
173 struct file_info header = {0, 0, 0};
174 header.file_size = HEADER_SIZE;
175 header.file_data = malloc(HEADER_SIZE);
176 bzero(header.file_data, header.file_size);
177
178 char *tg = header.file_data;
179 strcpy(tg, magic);
180 memcpy(tg+7, version, 4*sizeof(char));
181 strcpy(tg+11, hwID);
182 strcpy(tg+45, hwVer);
183 memcpy(tg+55, &swVer,sizeof(u_int32_t));
184 strcpy(tg+63, magic);
185
186 #ifdef DEBUG
187 printf("Header done, now creating rootfs.");
188 #endif
189 /* Construct a rootfs */
190 struct file_info rootfs = {0, 0, 0};
191 rootfs.file_size = sysupgrade.file_size + kernel_offset + footer_size;
192 rootfs.file_data = malloc(rootfs.file_size);
193 bzero(rootfs.file_data, rootfs.file_size);
194 rootfs.file_name = rootfsname;
195
196 /* copy Owrt image to Kernel location */
197 memcpy(rootfs.file_data+kernel_offset, sysupgrade.file_data, sysupgrade.file_size);
198
199 /* 22 added to get away from sysup image, no other reason.
200 * updater searches for magic anyway */
201 tg = rootfs.file_data + kernel_offset + sysupgrade.file_size+22;
202
203 memcpy(tg, header.file_data, header.file_size);
204 writeFile(&rootfs);
205
206 #ifdef DEBUG
207 printf("Preparing to zip.\n");
208 #endif
209 /* now that we got the rootfs, repeat the whole thing again(sorta):
210 * 1. zip the rootfs */
211 char *zipper = malloc(5 + 2*strlen(rootfs.file_name) + 4);
212 sprintf(zipper, "%s %s %s", "zip ", zipfsname, rootfs.file_name);
213 int ret = system(zipper);
214
215 /* clear rootfs file */
216 rmFile(&rootfs);
217
218 /* and load zipped fs */
219 struct file_info zippedfs = {zipfsname, 0, 0};
220 bufferFile(&zippedfs, 0);
221
222 #ifdef DEBUG
223 printf("Creating Image.\n");
224 #endif
225
226 /* 2. create new file 512+rootfs size */
227 struct file_info image = {argv[1], 0, 0};
228 image.file_data = malloc(zippedfs.file_size + 512);
229 image.file_size = zippedfs.file_size + 512;
230
231 /* 3. copy zipfile at loc 512 */
232 memcpy(image.file_data+512, zippedfs.file_data, zippedfs.file_size);
233 rmFile(&zippedfs);
234
235 /* 4. add header to file */
236 memcpy(image.file_data, header.file_data, header.file_size);
237
238 /* 5. do a checksum run, and compute checksum */
239 char chksum = getCheckSum(image.file_data, image.file_size);
240 #ifdef DEBUG
241 printf("Checksum for Image: %X.\n", chksum);
242 #endif
243
244 /* 6. write the checksum invert into byte 511 to bring it to 0 */
245 chksum = (chksum ^ 0xFF) + 1;
246 memcpy(image.file_data+511, &chksum, 1);
247
248 chksum = getCheckSum(image.file_data, image.file_size);
249 #ifdef DEBUG
250 printf("Checksum for after fix: %X.\n", chksum);
251 #endif
252 /* 7. pray that the updater will accept the file */
253 writeFile(&image);
254 return 0;
255 }