]>
Commit | Line | Data |
---|---|---|
a6337e6f DW |
1 | /* |
2 | * (C) Copyright 2011 Free Electrons | |
3 | * David Wagner <david.wagner@free-electrons.com> | |
4 | * | |
5 | * Inspired from envcrc.c: | |
6 | * (C) Copyright 2001 | |
7 | * Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), arsenio@tin.it | |
8 | * | |
9 | * See file CREDITS for list of people who contributed to this | |
10 | * project. | |
11 | * | |
12 | * This program is free software; you can redistribute it and/or | |
13 | * modify it under the terms of the GNU General Public License as | |
14 | * published by the Free Software Foundation; either version 2 of | |
15 | * the License, or (at your option) any later version. | |
16 | * | |
17 | * This program is distributed in the hope that it will be useful, | |
18 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
20 | * GNU General Public License for more details. | |
21 | * | |
22 | * You should have received a copy of the GNU General Public License | |
23 | * along with this program; if not, write to the Free Software | |
24 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
25 | * MA 02111-1307 USA | |
26 | */ | |
27 | ||
af44f4b2 HK |
28 | /* We want the GNU version of basename() */ |
29 | #define _GNU_SOURCE | |
30 | ||
a6337e6f DW |
31 | #include <errno.h> |
32 | #include <fcntl.h> | |
33 | #include <stdio.h> | |
d1acdae9 | 34 | #include <stdlib.h> |
a6337e6f DW |
35 | #include <stdint.h> |
36 | #include <string.h> | |
37 | #include <unistd.h> | |
a6337e6f DW |
38 | #include <sys/types.h> |
39 | #include <sys/stat.h> | |
40 | ||
d1acdae9 | 41 | #include "compiler.h" |
a6337e6f | 42 | #include <u-boot/crc.h> |
1895420b | 43 | #include <version.h> |
a6337e6f DW |
44 | |
45 | #define CRC_SIZE sizeof(uint32_t) | |
46 | ||
47 | static void usage(const char *exec_name) | |
48 | { | |
8a1b8fc7 | 49 | fprintf(stderr, "%s [-h] [-r] [-b] [-p <byte>] -s <environment partition size> -o <output> <input file>\n" |
a6337e6f | 50 | "\n" |
8a1b8fc7 | 51 | "This tool takes a key=value input file (same as would a `printenv' show) and generates the corresponding environment image, ready to be flashed.\n" |
a6337e6f DW |
52 | "\n" |
53 | "\tThe input file is in format:\n" | |
54 | "\t\tkey1=value1\n" | |
55 | "\t\tkey2=value2\n" | |
56 | "\t\t...\n" | |
57 | "\t-r : the environment has multiple copies in flash\n" | |
58 | "\t-b : the target is big endian (default is little endian)\n" | |
8a1b8fc7 | 59 | "\t-p <byte> : fill the image with <byte> bytes instead of 0xff bytes\n" |
1895420b | 60 | "\t-V : print version information and exit\n" |
a6337e6f DW |
61 | "\n" |
62 | "If the input file is \"-\", data is read from standard input\n", | |
63 | exec_name); | |
64 | } | |
65 | ||
3d0f9bd0 DW |
66 | long int xstrtol(const char *s) |
67 | { | |
68 | long int tmp; | |
69 | ||
70 | errno = 0; | |
71 | tmp = strtol(s, NULL, 0); | |
72 | if (!errno) | |
73 | return tmp; | |
74 | ||
75 | if (errno == ERANGE) | |
76 | fprintf(stderr, "Bad integer format: %s\n", s); | |
77 | else | |
78 | fprintf(stderr, "Error while parsing %s: %s\n", s, | |
79 | strerror(errno)); | |
80 | ||
81 | exit(EXIT_FAILURE); | |
82 | } | |
83 | ||
a6337e6f DW |
84 | int main(int argc, char **argv) |
85 | { | |
86 | uint32_t crc, targetendian_crc; | |
87 | const char *txt_filename = NULL, *bin_filename = NULL; | |
88 | int txt_fd, bin_fd; | |
89 | unsigned char *dataptr, *envptr; | |
90 | unsigned char *filebuf = NULL; | |
91 | unsigned int filesize = 0, envsize = 0, datasize = 0; | |
92 | int bigendian = 0; | |
93 | int redundant = 0; | |
94 | unsigned char padbyte = 0xff; | |
95 | ||
96 | int option; | |
97 | int ret = EXIT_SUCCESS; | |
98 | ||
99 | struct stat txt_file_stat; | |
100 | ||
101 | int fp, ep; | |
af44f4b2 HK |
102 | const char *prg; |
103 | ||
104 | prg = basename(argv[0]); | |
a6337e6f | 105 | |
5e0c63e2 HK |
106 | /* Turn off getopt()'s internal error message */ |
107 | opterr = 0; | |
108 | ||
a6337e6f | 109 | /* Parse the cmdline */ |
1895420b | 110 | while ((option = getopt(argc, argv, ":s:o:rbp:hV")) != -1) { |
a6337e6f DW |
111 | switch (option) { |
112 | case 's': | |
3d0f9bd0 | 113 | datasize = xstrtol(optarg); |
a6337e6f DW |
114 | break; |
115 | case 'o': | |
116 | bin_filename = strdup(optarg); | |
117 | if (!bin_filename) { | |
8a1b8fc7 | 118 | fprintf(stderr, "Can't strdup() the output filename\n"); |
a6337e6f DW |
119 | return EXIT_FAILURE; |
120 | } | |
121 | break; | |
122 | case 'r': | |
123 | redundant = 1; | |
124 | break; | |
125 | case 'b': | |
126 | bigendian = 1; | |
127 | break; | |
128 | case 'p': | |
3d0f9bd0 | 129 | padbyte = xstrtol(optarg); |
a6337e6f DW |
130 | break; |
131 | case 'h': | |
af44f4b2 | 132 | usage(prg); |
a6337e6f | 133 | return EXIT_SUCCESS; |
1895420b HK |
134 | case 'V': |
135 | printf("%s version %s\n", prg, PLAIN_VERSION); | |
136 | return EXIT_SUCCESS; | |
5e0c63e2 HK |
137 | case ':': |
138 | fprintf(stderr, "Missing argument for option -%c\n", | |
72ebafbe | 139 | optopt); |
e758a5c4 | 140 | usage(prg); |
5e0c63e2 | 141 | return EXIT_FAILURE; |
a6337e6f | 142 | default: |
72ebafbe | 143 | fprintf(stderr, "Wrong option -%c\n", optopt); |
af44f4b2 | 144 | usage(prg); |
a6337e6f DW |
145 | return EXIT_FAILURE; |
146 | } | |
147 | } | |
148 | ||
149 | /* Check datasize and allocate the data */ | |
150 | if (datasize == 0) { | |
8a1b8fc7 | 151 | fprintf(stderr, "Please specify the size of the environment partition.\n"); |
af44f4b2 | 152 | usage(prg); |
a6337e6f DW |
153 | return EXIT_FAILURE; |
154 | } | |
155 | ||
156 | dataptr = malloc(datasize * sizeof(*dataptr)); | |
157 | if (!dataptr) { | |
8a1b8fc7 DW |
158 | fprintf(stderr, "Can't alloc %d bytes for dataptr.\n", |
159 | datasize); | |
a6337e6f DW |
160 | return EXIT_FAILURE; |
161 | } | |
162 | ||
163 | /* | |
164 | * envptr points to the beginning of the actual environment (after the | |
8a1b8fc7 | 165 | * crc and possible `redundant' byte |
a6337e6f DW |
166 | */ |
167 | envsize = datasize - (CRC_SIZE + redundant); | |
168 | envptr = dataptr + CRC_SIZE + redundant; | |
169 | ||
170 | /* Pad the environment with the padding byte */ | |
171 | memset(envptr, padbyte, envsize); | |
172 | ||
173 | /* Open the input file ... */ | |
48995b5a | 174 | if (optind >= argc || strcmp(argv[optind], "-") == 0) { |
a6337e6f | 175 | int readbytes = 0; |
48995b5a | 176 | int readlen = sizeof(*envptr) * 4096; |
a6337e6f DW |
177 | txt_fd = STDIN_FILENO; |
178 | ||
179 | do { | |
180 | filebuf = realloc(filebuf, readlen); | |
3d0f9bd0 DW |
181 | if (!filebuf) { |
182 | fprintf(stderr, "Can't realloc memory for the input file buffer\n"); | |
183 | return EXIT_FAILURE; | |
184 | } | |
a6337e6f | 185 | readbytes = read(txt_fd, filebuf + filesize, readlen); |
3d0f9bd0 DW |
186 | if (errno) { |
187 | fprintf(stderr, "Error while reading stdin: %s\n", | |
188 | strerror(errno)); | |
189 | return EXIT_FAILURE; | |
190 | } | |
a6337e6f DW |
191 | filesize += readbytes; |
192 | } while (readbytes == readlen); | |
193 | ||
194 | } else { | |
48995b5a | 195 | txt_filename = argv[optind]; |
a6337e6f DW |
196 | txt_fd = open(txt_filename, O_RDONLY); |
197 | if (txt_fd == -1) { | |
198 | fprintf(stderr, "Can't open \"%s\": %s\n", | |
199 | txt_filename, strerror(errno)); | |
200 | return EXIT_FAILURE; | |
201 | } | |
202 | /* ... and check it */ | |
203 | ret = fstat(txt_fd, &txt_file_stat); | |
204 | if (ret == -1) { | |
8a1b8fc7 DW |
205 | fprintf(stderr, "Can't stat() on \"%s\": %s\n", |
206 | txt_filename, strerror(errno)); | |
a6337e6f DW |
207 | return EXIT_FAILURE; |
208 | } | |
209 | ||
210 | filesize = txt_file_stat.st_size; | |
211 | /* Read the raw input file and transform it */ | |
212 | filebuf = malloc(sizeof(*envptr) * filesize); | |
213 | ret = read(txt_fd, filebuf, sizeof(*envptr) * filesize); | |
214 | if (ret != sizeof(*envptr) * filesize) { | |
215 | fprintf(stderr, "Can't read the whole input file\n"); | |
216 | return EXIT_FAILURE; | |
217 | } | |
218 | ret = close(txt_fd); | |
219 | } | |
8a1b8fc7 DW |
220 | /* The +1 is for the additionnal ending \0. See below. */ |
221 | if (filesize + 1 > envsize) { | |
222 | fprintf(stderr, "The input file is larger than the environment partition size\n"); | |
a6337e6f DW |
223 | return EXIT_FAILURE; |
224 | } | |
225 | ||
226 | /* Replace newlines separating variables with \0 */ | |
227 | for (fp = 0, ep = 0 ; fp < filesize ; fp++) { | |
228 | if (filebuf[fp] == '\n') { | |
dbee61db | 229 | if (ep == 0) { |
a6337e6f | 230 | /* |
dbee61db DW |
231 | * Newlines at the beginning of the file ? |
232 | * Ignore them. | |
a6337e6f DW |
233 | */ |
234 | continue; | |
235 | } else if (filebuf[fp-1] == '\\') { | |
236 | /* | |
237 | * Embedded newline in a variable. | |
238 | * | |
dbee61db DW |
239 | * The backslash was added to the envptr; rewind |
240 | * and replace it with a newline | |
a6337e6f DW |
241 | */ |
242 | ep--; | |
243 | envptr[ep++] = '\n'; | |
244 | } else { | |
245 | /* End of a variable */ | |
246 | envptr[ep++] = '\0'; | |
247 | } | |
248 | } else if (filebuf[fp] == '#') { | |
249 | if (fp != 0 && filebuf[fp-1] == '\n') { | |
250 | /* This line is a comment, let's skip it */ | |
251 | while (fp < txt_file_stat.st_size && fp++ && | |
252 | filebuf[fp] != '\n'); | |
253 | } else { | |
254 | envptr[ep++] = filebuf[fp]; | |
255 | } | |
256 | } else { | |
257 | envptr[ep++] = filebuf[fp]; | |
258 | } | |
259 | } | |
260 | /* | |
261 | * Make sure there is a final '\0' | |
262 | * And do it again on the next byte to mark the end of the environment. | |
263 | */ | |
264 | if (envptr[ep-1] != '\0') { | |
265 | envptr[ep++] = '\0'; | |
266 | /* | |
267 | * The text file doesn't have an ending newline. We need to | |
268 | * check the env size again to make sure we have room for two \0 | |
269 | */ | |
270 | if (ep >= envsize) { | |
8a1b8fc7 | 271 | fprintf(stderr, "The environment file is too large for the target environment storage\n"); |
a6337e6f DW |
272 | return EXIT_FAILURE; |
273 | } | |
274 | envptr[ep] = '\0'; | |
275 | } else { | |
276 | envptr[ep] = '\0'; | |
277 | } | |
278 | ||
279 | /* Computes the CRC and put it at the beginning of the data */ | |
280 | crc = crc32(0, envptr, envsize); | |
281 | targetendian_crc = bigendian ? cpu_to_be32(crc) : cpu_to_le32(crc); | |
282 | ||
283 | memcpy(dataptr, &targetendian_crc, sizeof(uint32_t)); | |
284 | ||
48995b5a DW |
285 | if (!bin_filename || strcmp(bin_filename, "-") == 0) { |
286 | bin_fd = STDOUT_FILENO; | |
287 | } else { | |
288 | bin_fd = creat(bin_filename, S_IRUSR | S_IWUSR | S_IRGRP | | |
289 | S_IWGRP); | |
290 | if (bin_fd == -1) { | |
291 | fprintf(stderr, "Can't open output file \"%s\": %s\n", | |
292 | bin_filename, strerror(errno)); | |
293 | return EXIT_FAILURE; | |
294 | } | |
a6337e6f DW |
295 | } |
296 | ||
297 | if (write(bin_fd, dataptr, sizeof(*dataptr) * datasize) != | |
298 | sizeof(*dataptr) * datasize) { | |
299 | fprintf(stderr, "write() failed: %s\n", strerror(errno)); | |
300 | return EXIT_FAILURE; | |
301 | } | |
302 | ||
303 | ret = close(bin_fd); | |
304 | ||
305 | return ret; | |
306 | } |