xref: /openbmc/u-boot/tools/env/fw_env.c (revision 53193a4f)
1 /*
2  * (C) Copyright 2000-2010
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * (C) Copyright 2008
6  * Guennadi Liakhovetski, DENX Software Engineering, lg@denx.de.
7  *
8  * SPDX-License-Identifier:	GPL-2.0+
9  */
10 
11 #define _GNU_SOURCE
12 
13 #include <compiler.h>
14 #include <errno.h>
15 #include <env_flags.h>
16 #include <fcntl.h>
17 #include <linux/fs.h>
18 #include <linux/stringify.h>
19 #include <ctype.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <stddef.h>
23 #include <string.h>
24 #include <sys/types.h>
25 #include <sys/ioctl.h>
26 #include <sys/stat.h>
27 #include <unistd.h>
28 
29 #ifdef MTD_OLD
30 # include <stdint.h>
31 # include <linux/mtd/mtd.h>
32 #else
33 # define  __user	/* nothing */
34 # include <mtd/mtd-user.h>
35 #endif
36 
37 #include "fw_env_private.h"
38 #include "fw_env.h"
39 
40 struct env_opts default_opts = {
41 #ifdef CONFIG_FILE
42 	.config_file = CONFIG_FILE
43 #endif
44 };
45 
46 #define DIV_ROUND_UP(n, d)	(((n) + (d) - 1) / (d))
47 
48 #define min(x, y) ({				\
49 	typeof(x) _min1 = (x);			\
50 	typeof(y) _min2 = (y);			\
51 	(void) (&_min1 == &_min2);		\
52 	_min1 < _min2 ? _min1 : _min2; })
53 
54 struct envdev_s {
55 	const char *devname;		/* Device name */
56 	long long devoff;		/* Device offset */
57 	ulong env_size;			/* environment size */
58 	ulong erase_size;		/* device erase size */
59 	ulong env_sectors;		/* number of environment sectors */
60 	uint8_t mtd_type;		/* type of the MTD device */
61 };
62 
63 static struct envdev_s envdevices[2] =
64 {
65 	{
66 		.mtd_type = MTD_ABSENT,
67 	}, {
68 		.mtd_type = MTD_ABSENT,
69 	},
70 };
71 static int dev_current;
72 
73 #define DEVNAME(i)    envdevices[(i)].devname
74 #define DEVOFFSET(i)  envdevices[(i)].devoff
75 #define ENVSIZE(i)    envdevices[(i)].env_size
76 #define DEVESIZE(i)   envdevices[(i)].erase_size
77 #define ENVSECTORS(i) envdevices[(i)].env_sectors
78 #define DEVTYPE(i)    envdevices[(i)].mtd_type
79 
80 #define CUR_ENVSIZE ENVSIZE(dev_current)
81 
82 static unsigned long usable_envsize;
83 #define ENV_SIZE      usable_envsize
84 
85 struct env_image_single {
86 	uint32_t	crc;	/* CRC32 over data bytes    */
87 	char		data[];
88 };
89 
90 struct env_image_redundant {
91 	uint32_t	crc;	/* CRC32 over data bytes    */
92 	unsigned char	flags;	/* active or obsolete */
93 	char		data[];
94 };
95 
96 enum flag_scheme {
97 	FLAG_NONE,
98 	FLAG_BOOLEAN,
99 	FLAG_INCREMENTAL,
100 };
101 
102 struct environment {
103 	void			*image;
104 	uint32_t		*crc;
105 	unsigned char		*flags;
106 	char			*data;
107 	enum flag_scheme	flag_scheme;
108 };
109 
110 static struct environment environment = {
111 	.flag_scheme = FLAG_NONE,
112 };
113 
114 static int env_aes_cbc_crypt(char *data, const int enc, uint8_t *key);
115 
116 static int HaveRedundEnv = 0;
117 
118 static unsigned char active_flag = 1;
119 /* obsolete_flag must be 0 to efficiently set it on NOR flash without erasing */
120 static unsigned char obsolete_flag = 0;
121 
122 #define DEFAULT_ENV_INSTANCE_STATIC
123 #include <env_default.h>
124 
125 static int flash_io (int mode);
126 static int parse_config(struct env_opts *opts);
127 
128 #if defined(CONFIG_FILE)
129 static int get_config (char *);
130 #endif
131 
132 static char *skip_chars(char *s)
133 {
134 	for (; *s != '\0'; s++) {
135 		if (isblank(*s))
136 			return s;
137 	}
138 	return NULL;
139 }
140 
141 static char *skip_blanks(char *s)
142 {
143 	for (; *s != '\0'; s++) {
144 		if (!isblank(*s))
145 			return s;
146 	}
147 	return NULL;
148 }
149 
150 /*
151  * s1 is either a simple 'name', or a 'name=value' pair.
152  * s2 is a 'name=value' pair.
153  * If the names match, return the value of s2, else NULL.
154  */
155 static char *envmatch(char *s1, char *s2)
156 {
157 	if (s1 == NULL || s2 == NULL)
158 		return NULL;
159 
160 	while (*s1 == *s2++)
161 		if (*s1++ == '=')
162 			return s2;
163 	if (*s1 == '\0' && *(s2 - 1) == '=')
164 		return s2;
165 	return NULL;
166 }
167 
168 /**
169  * Search the environment for a variable.
170  * Return the value, if found, or NULL, if not found.
171  */
172 char *fw_getenv (char *name)
173 {
174 	char *env, *nxt;
175 
176 	for (env = environment.data; *env; env = nxt + 1) {
177 		char *val;
178 
179 		for (nxt = env; *nxt; ++nxt) {
180 			if (nxt >= &environment.data[ENV_SIZE]) {
181 				fprintf (stderr, "## Error: "
182 					"environment not terminated\n");
183 				return NULL;
184 			}
185 		}
186 		val = envmatch (name, env);
187 		if (!val)
188 			continue;
189 		return val;
190 	}
191 	return NULL;
192 }
193 
194 /*
195  * Search the default environment for a variable.
196  * Return the value, if found, or NULL, if not found.
197  */
198 char *fw_getdefenv(char *name)
199 {
200 	char *env, *nxt;
201 
202 	for (env = default_environment; *env; env = nxt + 1) {
203 		char *val;
204 
205 		for (nxt = env; *nxt; ++nxt) {
206 			if (nxt >= &default_environment[ENV_SIZE]) {
207 				fprintf(stderr, "## Error: "
208 					"default environment not terminated\n");
209 				return NULL;
210 			}
211 		}
212 		val = envmatch(name, env);
213 		if (!val)
214 			continue;
215 		return val;
216 	}
217 	return NULL;
218 }
219 
220 int parse_aes_key(char *key, uint8_t *bin_key)
221 {
222 	char tmp[5] = { '0', 'x', 0, 0, 0 };
223 	unsigned long ul;
224 	int i;
225 
226 	if (strnlen(key, 64) != 32) {
227 		fprintf(stderr,
228 			"## Error: '-a' option requires 16-byte AES key\n");
229 		return -1;
230 	}
231 
232 	for (i = 0; i < 16; i++) {
233 		tmp[2] = key[0];
234 		tmp[3] = key[1];
235 		errno = 0;
236 		ul = strtoul(tmp, NULL, 16);
237 		if (errno) {
238 			fprintf(stderr,
239 				"## Error: '-a' option requires valid AES key\n");
240 			return -1;
241 		}
242 		bin_key[i] = ul & 0xff;
243 		key += 2;
244 	}
245 	return 0;
246 }
247 
248 /*
249  * Print the current definition of one, or more, or all
250  * environment variables
251  */
252 int fw_printenv(int argc, char *argv[], int value_only, struct env_opts *opts)
253 {
254 	int i, rc = 0;
255 
256 	if (value_only && argc != 1) {
257 		fprintf(stderr,
258 			"## Error: `-n' option requires exactly one argument\n");
259 		return -1;
260 	}
261 
262 	if (!opts)
263 		opts = &default_opts;
264 
265 	if (fw_env_open(opts))
266 		return -1;
267 
268 	if (argc == 0) {		/* Print all env variables  */
269 		char *env, *nxt;
270 		for (env = environment.data; *env; env = nxt + 1) {
271 			for (nxt = env; *nxt; ++nxt) {
272 				if (nxt >= &environment.data[ENV_SIZE]) {
273 					fprintf (stderr, "## Error: "
274 						"environment not terminated\n");
275 					return -1;
276 				}
277 			}
278 
279 			printf ("%s\n", env);
280 		}
281 		fw_env_close(opts);
282 		return 0;
283 	}
284 
285 	for (i = 0; i < argc; ++i) {	/* print a subset of env variables */
286 		char *name = argv[i];
287 		char *val = NULL;
288 
289 		val = fw_getenv(name);
290 		if (!val) {
291 			fprintf (stderr, "## Error: \"%s\" not defined\n", name);
292 			rc = -1;
293 			continue;
294 		}
295 
296 		if (value_only) {
297 			puts(val);
298 			break;
299 		}
300 
301 		printf("%s=%s\n", name, val);
302 	}
303 
304 	fw_env_close(opts);
305 
306 	return rc;
307 }
308 
309 int fw_env_flush(struct env_opts *opts)
310 {
311 	int ret;
312 
313 	if (!opts)
314 		opts = &default_opts;
315 
316 	if (opts->aes_flag) {
317 		ret = env_aes_cbc_crypt(environment.data, 1,
318 					opts->aes_key);
319 		if (ret) {
320 			fprintf(stderr,
321 				"Error: can't encrypt env for flash\n");
322 			return ret;
323 		}
324 	}
325 
326 	/*
327 	 * Update CRC
328 	 */
329 	*environment.crc = crc32(0, (uint8_t *) environment.data, ENV_SIZE);
330 
331 	/* write environment back to flash */
332 	if (flash_io(O_RDWR)) {
333 		fprintf(stderr,
334 			"Error: can't write fw_env to flash\n");
335 			return -1;
336 	}
337 
338 	return 0;
339 }
340 
341 
342 /*
343  * Set/Clear a single variable in the environment.
344  * This is called in sequence to update the environment
345  * in RAM without updating the copy in flash after each set
346  */
347 int fw_env_write(char *name, char *value)
348 {
349 	int len;
350 	char *env, *nxt;
351 	char *oldval = NULL;
352 	int deleting, creating, overwriting;
353 
354 	/*
355 	 * search if variable with this name already exists
356 	 */
357 	for (nxt = env = environment.data; *env; env = nxt + 1) {
358 		for (nxt = env; *nxt; ++nxt) {
359 			if (nxt >= &environment.data[ENV_SIZE]) {
360 				fprintf(stderr, "## Error: "
361 					"environment not terminated\n");
362 				errno = EINVAL;
363 				return -1;
364 			}
365 		}
366 		if ((oldval = envmatch (name, env)) != NULL)
367 			break;
368 	}
369 
370 	deleting = (oldval && !(value && strlen(value)));
371 	creating = (!oldval && (value && strlen(value)));
372 	overwriting = (oldval && (value && strlen(value)));
373 
374 	/* check for permission */
375 	if (deleting) {
376 		if (env_flags_validate_varaccess(name,
377 		    ENV_FLAGS_VARACCESS_PREVENT_DELETE)) {
378 			printf("Can't delete \"%s\"\n", name);
379 			errno = EROFS;
380 			return -1;
381 		}
382 	} else if (overwriting) {
383 		if (env_flags_validate_varaccess(name,
384 		    ENV_FLAGS_VARACCESS_PREVENT_OVERWR)) {
385 			printf("Can't overwrite \"%s\"\n", name);
386 			errno = EROFS;
387 			return -1;
388 		} else if (env_flags_validate_varaccess(name,
389 		    ENV_FLAGS_VARACCESS_PREVENT_NONDEF_OVERWR)) {
390 			const char *defval = fw_getdefenv(name);
391 
392 			if (defval == NULL)
393 				defval = "";
394 			if (strcmp(oldval, defval)
395 			    != 0) {
396 				printf("Can't overwrite \"%s\"\n", name);
397 				errno = EROFS;
398 				return -1;
399 			}
400 		}
401 	} else if (creating) {
402 		if (env_flags_validate_varaccess(name,
403 		    ENV_FLAGS_VARACCESS_PREVENT_CREATE)) {
404 			printf("Can't create \"%s\"\n", name);
405 			errno = EROFS;
406 			return -1;
407 		}
408 	} else
409 		/* Nothing to do */
410 		return 0;
411 
412 	if (deleting || overwriting) {
413 		if (*++nxt == '\0') {
414 			*env = '\0';
415 		} else {
416 			for (;;) {
417 				*env = *nxt++;
418 				if ((*env == '\0') && (*nxt == '\0'))
419 					break;
420 				++env;
421 			}
422 		}
423 		*++env = '\0';
424 	}
425 
426 	/* Delete only ? */
427 	if (!value || !strlen(value))
428 		return 0;
429 
430 	/*
431 	 * Append new definition at the end
432 	 */
433 	for (env = environment.data; *env || *(env + 1); ++env);
434 	if (env > environment.data)
435 		++env;
436 	/*
437 	 * Overflow when:
438 	 * "name" + "=" + "val" +"\0\0"  > CUR_ENVSIZE - (env-environment)
439 	 */
440 	len = strlen (name) + 2;
441 	/* add '=' for first arg, ' ' for all others */
442 	len += strlen(value) + 1;
443 
444 	if (len > (&environment.data[ENV_SIZE] - env)) {
445 		fprintf (stderr,
446 			"Error: environment overflow, \"%s\" deleted\n",
447 			name);
448 		return -1;
449 	}
450 
451 	while ((*env = *name++) != '\0')
452 		env++;
453 	*env = '=';
454 	while ((*++env = *value++) != '\0')
455 		;
456 
457 	/* end is marked with double '\0' */
458 	*++env = '\0';
459 
460 	return 0;
461 }
462 
463 /*
464  * Deletes or sets environment variables. Returns -1 and sets errno error codes:
465  * 0	  - OK
466  * EINVAL - need at least 1 argument
467  * EROFS  - certain variables ("ethaddr", "serial#") cannot be
468  *	    modified or deleted
469  *
470  */
471 int fw_setenv(int argc, char *argv[], struct env_opts *opts)
472 {
473 	int i;
474 	size_t len;
475 	char *name, **valv;
476 	char *oldval;
477 	char *value = NULL;
478 	int valc;
479 	int ret;
480 
481 	if (!opts)
482 		opts = &default_opts;
483 
484 	if (argc < 1) {
485 		fprintf(stderr, "## Error: variable name missing\n");
486 		errno = EINVAL;
487 		return -1;
488 	}
489 
490 	if (fw_env_open(opts)) {
491 		fprintf(stderr, "Error: environment not initialized\n");
492 		return -1;
493 	}
494 
495 	name = argv[0];
496 	valv = argv + 1;
497 	valc = argc - 1;
498 
499 	if (env_flags_validate_env_set_params(name, valv, valc) < 0) {
500 		fw_env_close(opts);
501 		return -1;
502 	}
503 
504 	len = 0;
505 	for (i = 0; i < valc; ++i) {
506 		char *val = valv[i];
507 		size_t val_len = strlen(val);
508 
509 		if (value)
510 			value[len - 1] = ' ';
511 		oldval = value;
512 		value = realloc(value, len + val_len + 1);
513 		if (!value) {
514 			fprintf(stderr,
515 				"Cannot malloc %zu bytes: %s\n",
516 				len, strerror(errno));
517 			free(oldval);
518 			return -1;
519 		}
520 
521 		memcpy(value + len, val, val_len);
522 		len += val_len;
523 		value[len++] = '\0';
524 	}
525 
526 	fw_env_write(name, value);
527 
528 	free(value);
529 
530 	ret = fw_env_flush(opts);
531 	fw_env_close(opts);
532 
533 	return ret;
534 }
535 
536 /*
537  * Parse  a file  and configure the u-boot variables.
538  * The script file has a very simple format, as follows:
539  *
540  * Each line has a couple with name, value:
541  * <white spaces>variable_name<white spaces>variable_value
542  *
543  * Both variable_name and variable_value are interpreted as strings.
544  * Any character after <white spaces> and before ending \r\n is interpreted
545  * as variable's value (no comment allowed on these lines !)
546  *
547  * Comments are allowed if the first character in the line is #
548  *
549  * Returns -1 and sets errno error codes:
550  * 0	  - OK
551  * -1     - Error
552  */
553 int fw_parse_script(char *fname, struct env_opts *opts)
554 {
555 	FILE *fp;
556 	char dump[1024];	/* Maximum line length in the file */
557 	char *name;
558 	char *val;
559 	int lineno = 0;
560 	int len;
561 	int ret = 0;
562 
563 	if (!opts)
564 		opts = &default_opts;
565 
566 	if (fw_env_open(opts)) {
567 		fprintf(stderr, "Error: environment not initialized\n");
568 		return -1;
569 	}
570 
571 	if (strcmp(fname, "-") == 0)
572 		fp = stdin;
573 	else {
574 		fp = fopen(fname, "r");
575 		if (fp == NULL) {
576 			fprintf(stderr, "I cannot open %s for reading\n",
577 				 fname);
578 			return -1;
579 		}
580 	}
581 
582 	while (fgets(dump, sizeof(dump), fp)) {
583 		lineno++;
584 		len = strlen(dump);
585 
586 		/*
587 		 * Read a whole line from the file. If the line is too long
588 		 * or is not terminated, reports an error and exit.
589 		 */
590 		if (dump[len - 1] != '\n') {
591 			fprintf(stderr,
592 			"Line %d not corrected terminated or too long\n",
593 				lineno);
594 			ret = -1;
595 			break;
596 		}
597 
598 		/* Drop ending line feed / carriage return */
599 		dump[--len] = '\0';
600 		if (len && dump[len - 1] == '\r')
601 			dump[--len] = '\0';
602 
603 		/* Skip comment or empty lines */
604 		if (len == 0 || dump[0] == '#')
605 			continue;
606 
607 		/*
608 		 * Search for variable's name,
609 		 * remove leading whitespaces
610 		 */
611 		name = skip_blanks(dump);
612 		if (!name)
613 			continue;
614 
615 		/* The first white space is the end of variable name */
616 		val = skip_chars(name);
617 		len = strlen(name);
618 		if (val) {
619 			*val++ = '\0';
620 			if ((val - name) < len)
621 				val = skip_blanks(val);
622 			else
623 				val = NULL;
624 		}
625 
626 #ifdef DEBUG
627 		fprintf(stderr, "Setting %s : %s\n",
628 			name, val ? val : " removed");
629 #endif
630 
631 		if (env_flags_validate_type(name, val) < 0) {
632 			ret = -1;
633 			break;
634 		}
635 
636 		/*
637 		 * If there is an error setting a variable,
638 		 * try to save the environment and returns an error
639 		 */
640 		if (fw_env_write(name, val)) {
641 			fprintf(stderr,
642 			"fw_env_write returns with error : %s\n",
643 				strerror(errno));
644 			ret = -1;
645 			break;
646 		}
647 
648 	}
649 
650 	/* Close file if not stdin */
651 	if (strcmp(fname, "-") != 0)
652 		fclose(fp);
653 
654 	ret |= fw_env_flush(opts);
655 
656 	fw_env_close(opts);
657 
658 	return ret;
659 }
660 
661 /**
662  * environment_end() - compute offset of first byte right after environemnt
663  * @dev - index of enviroment buffer
664  * Return:
665  *  device offset of first byte right after environemnt
666  */
667 off_t environment_end(int dev)
668 {
669 	/* environment is block aligned */
670 	return DEVOFFSET(dev) + ENVSECTORS(dev) * DEVESIZE(dev);
671 }
672 
673 /*
674  * Test for bad block on NAND, just returns 0 on NOR, on NAND:
675  * 0	- block is good
676  * > 0	- block is bad
677  * < 0	- failed to test
678  */
679 static int flash_bad_block(int fd, uint8_t mtd_type, loff_t blockstart)
680 {
681 	if (mtd_type == MTD_NANDFLASH) {
682 		int badblock = ioctl(fd, MEMGETBADBLOCK, &blockstart);
683 
684 		if (badblock < 0) {
685 			perror ("Cannot read bad block mark");
686 			return badblock;
687 		}
688 
689 		if (badblock) {
690 #ifdef DEBUG
691 			fprintf (stderr, "Bad block at 0x%llx, skipping\n",
692 				(unsigned long long)blockstart);
693 #endif
694 			return badblock;
695 		}
696 	}
697 
698 	return 0;
699 }
700 
701 /*
702  * Read data from flash at an offset into a provided buffer. On NAND it skips
703  * bad blocks but makes sure it stays within ENVSECTORS (dev) starting from
704  * the DEVOFFSET (dev) block. On NOR the loop is only run once.
705  */
706 static int flash_read_buf (int dev, int fd, void *buf, size_t count,
707 			   off_t offset)
708 {
709 	size_t blocklen;	/* erase / write length - one block on NAND,
710 				   0 on NOR */
711 	size_t processed = 0;	/* progress counter */
712 	size_t readlen = count;	/* current read length */
713 	off_t block_seek;	/* offset inside the current block to the start
714 				   of the data */
715 	loff_t blockstart;	/* running start of the current block -
716 				   MEMGETBADBLOCK needs 64 bits */
717 	int rc;
718 
719 	blockstart = (offset / DEVESIZE (dev)) * DEVESIZE (dev);
720 
721 	/* Offset inside a block */
722 	block_seek = offset - blockstart;
723 
724 	if (DEVTYPE(dev) == MTD_NANDFLASH) {
725 		/*
726 		 * NAND: calculate which blocks we are reading. We have
727 		 * to read one block at a time to skip bad blocks.
728 		 */
729 		blocklen = DEVESIZE (dev);
730 
731 		/* Limit to one block for the first read */
732 		if (readlen > blocklen - block_seek)
733 			readlen = blocklen - block_seek;
734 	} else {
735 		blocklen = 0;
736 	}
737 
738 	/* This only runs once on NOR flash */
739 	while (processed < count) {
740 		rc = flash_bad_block(fd, DEVTYPE(dev), blockstart);
741 		if (rc < 0)		/* block test failed */
742 			return -1;
743 
744 		if (blockstart + block_seek + readlen > environment_end(dev)) {
745 			/* End of range is reached */
746 			fprintf (stderr,
747 				 "Too few good blocks within range\n");
748 			return -1;
749 		}
750 
751 		if (rc) {		/* block is bad */
752 			blockstart += blocklen;
753 			continue;
754 		}
755 
756 		/*
757 		 * If a block is bad, we retry in the next block at the same
758 		 * offset - see common/env_nand.c::writeenv()
759 		 */
760 		lseek (fd, blockstart + block_seek, SEEK_SET);
761 
762 		rc = read (fd, buf + processed, readlen);
763 		if (rc != readlen) {
764 			fprintf (stderr, "Read error on %s: %s\n",
765 				 DEVNAME (dev), strerror (errno));
766 			return -1;
767 		}
768 #ifdef DEBUG
769 		fprintf(stderr, "Read 0x%x bytes at 0x%llx on %s\n",
770 			rc, (unsigned long long) blockstart + block_seek,
771 			DEVNAME(dev));
772 #endif
773 		processed += readlen;
774 		readlen = min (blocklen, count - processed);
775 		block_seek = 0;
776 		blockstart += blocklen;
777 	}
778 
779 	return processed;
780 }
781 
782 /*
783  * Write count bytes from begin of environment, but stay within
784  * ENVSECTORS(dev) sectors of
785  * DEVOFFSET (dev). Similar to the read case above, on NOR and dataflash we
786  * erase and write the whole data at once.
787  */
788 static int flash_write_buf(int dev, int fd, void *buf, size_t count)
789 {
790 	void *data;
791 	struct erase_info_user erase;
792 	size_t blocklen;	/* length of NAND block / NOR erase sector */
793 	size_t erase_len;	/* whole area that can be erased - may include
794 				   bad blocks */
795 	size_t erasesize;	/* erase / write length - one block on NAND,
796 				   whole area on NOR */
797 	size_t processed = 0;	/* progress counter */
798 	size_t write_total;	/* total size to actually write - excluding
799 				   bad blocks */
800 	off_t erase_offset;	/* offset to the first erase block (aligned)
801 				   below offset */
802 	off_t block_seek;	/* offset inside the erase block to the start
803 				   of the data */
804 	loff_t blockstart;	/* running start of the current block -
805 				   MEMGETBADBLOCK needs 64 bits */
806 	int rc;
807 
808 	/*
809 	 * For mtd devices only offset and size of the environment do matter
810 	 */
811 	if (DEVTYPE(dev) == MTD_ABSENT) {
812 		blocklen = count;
813 		erase_len = blocklen;
814 		blockstart = DEVOFFSET(dev);
815 		block_seek = 0;
816 		write_total = blocklen;
817 	} else {
818 		blocklen = DEVESIZE(dev);
819 
820 		erase_offset = DEVOFFSET(dev);
821 
822 		/* Maximum area we may use */
823 		erase_len = environment_end(dev) - erase_offset;
824 
825 		blockstart = erase_offset;
826 
827 		/* Offset inside a block */
828 		block_seek = DEVOFFSET(dev) - erase_offset;
829 
830 		/*
831 		 * Data size we actually write: from the start of the block
832 		 * to the start of the data, then count bytes of data, and
833 		 * to the end of the block
834 		 */
835 		write_total = ((block_seek + count + blocklen - 1) /
836 							blocklen) * blocklen;
837 	}
838 
839 	/*
840 	 * Support data anywhere within erase sectors: read out the complete
841 	 * area to be erased, replace the environment image, write the whole
842 	 * block back again.
843 	 */
844 	if (write_total > count) {
845 		data = malloc (erase_len);
846 		if (!data) {
847 			fprintf (stderr,
848 				 "Cannot malloc %zu bytes: %s\n",
849 				 erase_len, strerror (errno));
850 			return -1;
851 		}
852 
853 		rc = flash_read_buf(dev, fd, data, write_total, erase_offset);
854 		if (write_total != rc)
855 			return -1;
856 
857 #ifdef DEBUG
858 		fprintf(stderr, "Preserving data ");
859 		if (block_seek != 0)
860 			fprintf(stderr, "0x%x - 0x%lx", 0, block_seek - 1);
861 		if (block_seek + count != write_total) {
862 			if (block_seek != 0)
863 				fprintf(stderr, " and ");
864 			fprintf(stderr, "0x%lx - 0x%lx",
865 				(unsigned long) block_seek + count,
866 				(unsigned long) write_total - 1);
867 		}
868 		fprintf(stderr, "\n");
869 #endif
870 		/* Overwrite the old environment */
871 		memcpy (data + block_seek, buf, count);
872 	} else {
873 		/*
874 		 * We get here, iff offset is block-aligned and count is a
875 		 * multiple of blocklen - see write_total calculation above
876 		 */
877 		data = buf;
878 	}
879 
880 	if (DEVTYPE(dev) == MTD_NANDFLASH) {
881 		/*
882 		 * NAND: calculate which blocks we are writing. We have
883 		 * to write one block at a time to skip bad blocks.
884 		 */
885 		erasesize = blocklen;
886 	} else {
887 		erasesize = erase_len;
888 	}
889 
890 	erase.length = erasesize;
891 
892 	/* This only runs once on NOR flash and SPI-dataflash */
893 	while (processed < write_total) {
894 		rc = flash_bad_block(fd, DEVTYPE(dev), blockstart);
895 		if (rc < 0)		/* block test failed */
896 			return rc;
897 
898 		if (blockstart + erasesize > environment_end(dev)) {
899 			fprintf (stderr, "End of range reached, aborting\n");
900 			return -1;
901 		}
902 
903 		if (rc) {		/* block is bad */
904 			blockstart += blocklen;
905 			continue;
906 		}
907 
908 		if (DEVTYPE(dev) != MTD_ABSENT) {
909 			erase.start = blockstart;
910 			ioctl(fd, MEMUNLOCK, &erase);
911 			/* These do not need an explicit erase cycle */
912 			if (DEVTYPE(dev) != MTD_DATAFLASH)
913 				if (ioctl(fd, MEMERASE, &erase) != 0) {
914 					fprintf(stderr,
915 						"MTD erase error on %s: %s\n",
916 						DEVNAME(dev), strerror(errno));
917 					return -1;
918 				}
919 		}
920 
921 		if (lseek (fd, blockstart, SEEK_SET) == -1) {
922 			fprintf (stderr,
923 				 "Seek error on %s: %s\n",
924 				 DEVNAME (dev), strerror (errno));
925 			return -1;
926 		}
927 
928 #ifdef DEBUG
929 		fprintf(stderr, "Write 0x%llx bytes at 0x%llx\n",
930 			(unsigned long long) erasesize,
931 			(unsigned long long) blockstart);
932 #endif
933 		if (write (fd, data + processed, erasesize) != erasesize) {
934 			fprintf (stderr, "Write error on %s: %s\n",
935 				 DEVNAME (dev), strerror (errno));
936 			return -1;
937 		}
938 
939 		if (DEVTYPE(dev) != MTD_ABSENT)
940 			ioctl(fd, MEMLOCK, &erase);
941 
942 		processed  += erasesize;
943 		block_seek = 0;
944 		blockstart += erasesize;
945 	}
946 
947 	if (write_total > count)
948 		free (data);
949 
950 	return processed;
951 }
952 
953 /*
954  * Set obsolete flag at offset - NOR flash only
955  */
956 static int flash_flag_obsolete (int dev, int fd, off_t offset)
957 {
958 	int rc;
959 	struct erase_info_user erase;
960 
961 	erase.start  = DEVOFFSET (dev);
962 	erase.length = DEVESIZE (dev);
963 	/* This relies on the fact, that obsolete_flag == 0 */
964 	rc = lseek (fd, offset, SEEK_SET);
965 	if (rc < 0) {
966 		fprintf (stderr, "Cannot seek to set the flag on %s \n",
967 			 DEVNAME (dev));
968 		return rc;
969 	}
970 	ioctl (fd, MEMUNLOCK, &erase);
971 	rc = write (fd, &obsolete_flag, sizeof (obsolete_flag));
972 	ioctl (fd, MEMLOCK, &erase);
973 	if (rc < 0)
974 		perror ("Could not set obsolete flag");
975 
976 	return rc;
977 }
978 
979 /* Encrypt or decrypt the environment before writing or reading it. */
980 static int env_aes_cbc_crypt(char *payload, const int enc, uint8_t *key)
981 {
982 	uint8_t *data = (uint8_t *)payload;
983 	const int len = usable_envsize;
984 	uint8_t key_exp[AES_EXPAND_KEY_LENGTH];
985 	uint32_t aes_blocks;
986 
987 	/* First we expand the key. */
988 	aes_expand_key(key, key_exp);
989 
990 	/* Calculate the number of AES blocks to encrypt. */
991 	aes_blocks = DIV_ROUND_UP(len, AES_KEY_LENGTH);
992 
993 	if (enc)
994 		aes_cbc_encrypt_blocks(key_exp, data, data, aes_blocks);
995 	else
996 		aes_cbc_decrypt_blocks(key_exp, data, data, aes_blocks);
997 
998 	return 0;
999 }
1000 
1001 static int flash_write (int fd_current, int fd_target, int dev_target)
1002 {
1003 	int rc;
1004 
1005 	switch (environment.flag_scheme) {
1006 	case FLAG_NONE:
1007 		break;
1008 	case FLAG_INCREMENTAL:
1009 		(*environment.flags)++;
1010 		break;
1011 	case FLAG_BOOLEAN:
1012 		*environment.flags = active_flag;
1013 		break;
1014 	default:
1015 		fprintf (stderr, "Unimplemented flash scheme %u \n",
1016 			 environment.flag_scheme);
1017 		return -1;
1018 	}
1019 
1020 #ifdef DEBUG
1021 	fprintf(stderr, "Writing new environment at 0x%llx on %s\n",
1022 		DEVOFFSET (dev_target), DEVNAME (dev_target));
1023 #endif
1024 
1025 	rc = flash_write_buf(dev_target, fd_target, environment.image,
1026 			     CUR_ENVSIZE);
1027 	if (rc < 0)
1028 		return rc;
1029 
1030 	if (environment.flag_scheme == FLAG_BOOLEAN) {
1031 		/* Have to set obsolete flag */
1032 		off_t offset = DEVOFFSET (dev_current) +
1033 			offsetof (struct env_image_redundant, flags);
1034 #ifdef DEBUG
1035 		fprintf(stderr,
1036 			"Setting obsolete flag in environment at 0x%llx on %s\n",
1037 			DEVOFFSET (dev_current), DEVNAME (dev_current));
1038 #endif
1039 		flash_flag_obsolete (dev_current, fd_current, offset);
1040 	}
1041 
1042 	return 0;
1043 }
1044 
1045 static int flash_read (int fd)
1046 {
1047 	int rc;
1048 
1049 	rc = flash_read_buf(dev_current, fd, environment.image, CUR_ENVSIZE,
1050 			    DEVOFFSET(dev_current));
1051 	if (rc != CUR_ENVSIZE)
1052 		return -1;
1053 
1054 	return 0;
1055 }
1056 
1057 static int flash_io (int mode)
1058 {
1059 	int fd_current, fd_target, rc, dev_target;
1060 
1061 	/* dev_current: fd_current, erase_current */
1062 	fd_current = open (DEVNAME (dev_current), mode);
1063 	if (fd_current < 0) {
1064 		fprintf (stderr,
1065 			 "Can't open %s: %s\n",
1066 			 DEVNAME (dev_current), strerror (errno));
1067 		return -1;
1068 	}
1069 
1070 	if (mode == O_RDWR) {
1071 		if (HaveRedundEnv) {
1072 			/* switch to next partition for writing */
1073 			dev_target = !dev_current;
1074 			/* dev_target: fd_target, erase_target */
1075 			fd_target = open (DEVNAME (dev_target), mode);
1076 			if (fd_target < 0) {
1077 				fprintf (stderr,
1078 					 "Can't open %s: %s\n",
1079 					 DEVNAME (dev_target),
1080 					 strerror (errno));
1081 				rc = -1;
1082 				goto exit;
1083 			}
1084 		} else {
1085 			dev_target = dev_current;
1086 			fd_target = fd_current;
1087 		}
1088 
1089 		rc = flash_write (fd_current, fd_target, dev_target);
1090 
1091 		if (HaveRedundEnv) {
1092 			if (close (fd_target)) {
1093 				fprintf (stderr,
1094 					"I/O error on %s: %s\n",
1095 					DEVNAME (dev_target),
1096 					strerror (errno));
1097 				rc = -1;
1098 			}
1099 		}
1100 	} else {
1101 		rc = flash_read (fd_current);
1102 	}
1103 
1104 exit:
1105 	if (close (fd_current)) {
1106 		fprintf (stderr,
1107 			 "I/O error on %s: %s\n",
1108 			 DEVNAME (dev_current), strerror (errno));
1109 		return -1;
1110 	}
1111 
1112 	return rc;
1113 }
1114 
1115 /*
1116  * Prevent confusion if running from erased flash memory
1117  */
1118 int fw_env_open(struct env_opts *opts)
1119 {
1120 	int crc0, crc0_ok;
1121 	unsigned char flag0;
1122 	void *addr0 = NULL;
1123 
1124 	int crc1, crc1_ok;
1125 	unsigned char flag1;
1126 	void *addr1 = NULL;
1127 
1128 	int ret;
1129 
1130 	struct env_image_single *single;
1131 	struct env_image_redundant *redundant;
1132 
1133 	if (!opts)
1134 		opts = &default_opts;
1135 
1136 	if (parse_config(opts))		/* should fill envdevices */
1137 		return -EINVAL;
1138 
1139 	addr0 = calloc(1, CUR_ENVSIZE);
1140 	if (addr0 == NULL) {
1141 		fprintf(stderr,
1142 			"Not enough memory for environment (%ld bytes)\n",
1143 			CUR_ENVSIZE);
1144 		ret = -ENOMEM;
1145 		goto open_cleanup;
1146 	}
1147 
1148 	/* read environment from FLASH to local buffer */
1149 	environment.image = addr0;
1150 
1151 	if (HaveRedundEnv) {
1152 		redundant = addr0;
1153 		environment.crc		= &redundant->crc;
1154 		environment.flags	= &redundant->flags;
1155 		environment.data	= redundant->data;
1156 	} else {
1157 		single = addr0;
1158 		environment.crc		= &single->crc;
1159 		environment.flags	= NULL;
1160 		environment.data	= single->data;
1161 	}
1162 
1163 	dev_current = 0;
1164 	if (flash_io(O_RDONLY)) {
1165 		ret = -EIO;
1166 		goto open_cleanup;
1167 	}
1168 
1169 	crc0 = crc32 (0, (uint8_t *) environment.data, ENV_SIZE);
1170 
1171 	if (opts->aes_flag) {
1172 		ret = env_aes_cbc_crypt(environment.data, 0,
1173 					opts->aes_key);
1174 		if (ret)
1175 			goto open_cleanup;
1176 	}
1177 
1178 	crc0_ok = (crc0 == *environment.crc);
1179 	if (!HaveRedundEnv) {
1180 		if (!crc0_ok) {
1181 			fprintf (stderr,
1182 				"Warning: Bad CRC, using default environment\n");
1183 			memcpy(environment.data, default_environment, sizeof default_environment);
1184 		}
1185 	} else {
1186 		flag0 = *environment.flags;
1187 
1188 		dev_current = 1;
1189 		addr1 = calloc(1, CUR_ENVSIZE);
1190 		if (addr1 == NULL) {
1191 			fprintf(stderr,
1192 				"Not enough memory for environment (%ld bytes)\n",
1193 				CUR_ENVSIZE);
1194 			ret = -ENOMEM;
1195 			goto open_cleanup;
1196 		}
1197 		redundant = addr1;
1198 
1199 		/*
1200 		 * have to set environment.image for flash_read(), careful -
1201 		 * other pointers in environment still point inside addr0
1202 		 */
1203 		environment.image = addr1;
1204 		if (flash_io(O_RDONLY)) {
1205 			ret = -EIO;
1206 			goto open_cleanup;
1207 		}
1208 
1209 		/* Check flag scheme compatibility */
1210 		if (DEVTYPE(dev_current) == MTD_NORFLASH &&
1211 		    DEVTYPE(!dev_current) == MTD_NORFLASH) {
1212 			environment.flag_scheme = FLAG_BOOLEAN;
1213 		} else if (DEVTYPE(dev_current) == MTD_NANDFLASH &&
1214 			   DEVTYPE(!dev_current) == MTD_NANDFLASH) {
1215 			environment.flag_scheme = FLAG_INCREMENTAL;
1216 		} else if (DEVTYPE(dev_current) == MTD_DATAFLASH &&
1217 			   DEVTYPE(!dev_current) == MTD_DATAFLASH) {
1218 			environment.flag_scheme = FLAG_BOOLEAN;
1219 		} else if (DEVTYPE(dev_current) == MTD_UBIVOLUME &&
1220 			   DEVTYPE(!dev_current) == MTD_UBIVOLUME) {
1221 			environment.flag_scheme = FLAG_INCREMENTAL;
1222 		} else if (DEVTYPE(dev_current) == MTD_ABSENT &&
1223 			   DEVTYPE(!dev_current) == MTD_ABSENT) {
1224 			environment.flag_scheme = FLAG_INCREMENTAL;
1225 		} else {
1226 			fprintf (stderr, "Incompatible flash types!\n");
1227 			ret = -EINVAL;
1228 			goto open_cleanup;
1229 		}
1230 
1231 		crc1 = crc32 (0, (uint8_t *) redundant->data, ENV_SIZE);
1232 
1233 		if (opts->aes_flag) {
1234 			ret = env_aes_cbc_crypt(redundant->data, 0,
1235 						opts->aes_key);
1236 			if (ret)
1237 				goto open_cleanup;
1238 		}
1239 
1240 		crc1_ok = (crc1 == redundant->crc);
1241 		flag1 = redundant->flags;
1242 
1243 		if (crc0_ok && !crc1_ok) {
1244 			dev_current = 0;
1245 		} else if (!crc0_ok && crc1_ok) {
1246 			dev_current = 1;
1247 		} else if (!crc0_ok && !crc1_ok) {
1248 			fprintf (stderr,
1249 				"Warning: Bad CRC, using default environment\n");
1250 			memcpy (environment.data, default_environment,
1251 				sizeof default_environment);
1252 			dev_current = 0;
1253 		} else {
1254 			switch (environment.flag_scheme) {
1255 			case FLAG_BOOLEAN:
1256 				if (flag0 == active_flag &&
1257 				    flag1 == obsolete_flag) {
1258 					dev_current = 0;
1259 				} else if (flag0 == obsolete_flag &&
1260 					   flag1 == active_flag) {
1261 					dev_current = 1;
1262 				} else if (flag0 == flag1) {
1263 					dev_current = 0;
1264 				} else if (flag0 == 0xFF) {
1265 					dev_current = 0;
1266 				} else if (flag1 == 0xFF) {
1267 					dev_current = 1;
1268 				} else {
1269 					dev_current = 0;
1270 				}
1271 				break;
1272 			case FLAG_INCREMENTAL:
1273 				if (flag0 == 255 && flag1 == 0)
1274 					dev_current = 1;
1275 				else if ((flag1 == 255 && flag0 == 0) ||
1276 					 flag0 >= flag1)
1277 					dev_current = 0;
1278 				else /* flag1 > flag0 */
1279 					dev_current = 1;
1280 				break;
1281 			default:
1282 				fprintf (stderr, "Unknown flag scheme %u \n",
1283 					 environment.flag_scheme);
1284 				return -1;
1285 			}
1286 		}
1287 
1288 		/*
1289 		 * If we are reading, we don't need the flag and the CRC any
1290 		 * more, if we are writing, we will re-calculate CRC and update
1291 		 * flags before writing out
1292 		 */
1293 		if (dev_current) {
1294 			environment.image	= addr1;
1295 			environment.crc		= &redundant->crc;
1296 			environment.flags	= &redundant->flags;
1297 			environment.data	= redundant->data;
1298 			free (addr0);
1299 		} else {
1300 			environment.image	= addr0;
1301 			/* Other pointers are already set */
1302 			free (addr1);
1303 		}
1304 #ifdef DEBUG
1305 		fprintf(stderr, "Selected env in %s\n", DEVNAME(dev_current));
1306 #endif
1307 	}
1308 	return 0;
1309 
1310 open_cleanup:
1311 	if (addr0)
1312 		free(addr0);
1313 
1314 	if (addr1)
1315 		free(addr0);
1316 
1317 	return ret;
1318 }
1319 
1320 /*
1321  * Simply free allocated buffer with environment
1322  */
1323 int fw_env_close(struct env_opts *opts)
1324 {
1325 	if (environment.image)
1326 		free(environment.image);
1327 
1328 	environment.image = NULL;
1329 
1330 	return 0;
1331 }
1332 
1333 static int check_device_config(int dev)
1334 {
1335 	struct stat st;
1336 	int fd, rc = 0;
1337 
1338 	fd = open(DEVNAME(dev), O_RDONLY);
1339 	if (fd < 0) {
1340 		fprintf(stderr,
1341 			"Cannot open %s: %s\n",
1342 			DEVNAME(dev), strerror(errno));
1343 		return -1;
1344 	}
1345 
1346 	rc = fstat(fd, &st);
1347 	if (rc < 0) {
1348 		fprintf(stderr, "Cannot stat the file %s\n",
1349 			DEVNAME(dev));
1350 		goto err;
1351 	}
1352 
1353 	if (S_ISCHR(st.st_mode)) {
1354 		struct mtd_info_user mtdinfo;
1355 		rc = ioctl(fd, MEMGETINFO, &mtdinfo);
1356 		if (rc < 0) {
1357 			fprintf(stderr, "Cannot get MTD information for %s\n",
1358 				DEVNAME(dev));
1359 			goto err;
1360 		}
1361 		if (mtdinfo.type != MTD_NORFLASH &&
1362 		    mtdinfo.type != MTD_NANDFLASH &&
1363 		    mtdinfo.type != MTD_DATAFLASH &&
1364 		    mtdinfo.type != MTD_UBIVOLUME) {
1365 			fprintf(stderr, "Unsupported flash type %u on %s\n",
1366 				mtdinfo.type, DEVNAME(dev));
1367 			goto err;
1368 		}
1369 		DEVTYPE(dev) = mtdinfo.type;
1370 		if (DEVESIZE(dev) == 0)
1371 			/* Assume the erase size is the same as the env-size */
1372 			DEVESIZE(dev) = ENVSIZE(dev);
1373 	} else {
1374 		uint64_t size;
1375 		DEVTYPE(dev) = MTD_ABSENT;
1376 		if (DEVESIZE(dev) == 0)
1377 			/* Assume the erase size to be 512 bytes */
1378 			DEVESIZE(dev) = 0x200;
1379 
1380 		/*
1381 		 * Check for negative offsets, treat it as backwards offset
1382 		 * from the end of the block device
1383 		 */
1384 		if (DEVOFFSET(dev) < 0) {
1385 			rc = ioctl(fd, BLKGETSIZE64, &size);
1386 			if (rc < 0) {
1387 				fprintf(stderr, "Could not get block device size on %s\n",
1388 					DEVNAME(dev));
1389 				goto err;
1390 			}
1391 
1392 			DEVOFFSET(dev) = DEVOFFSET(dev) + size;
1393 #ifdef DEBUG
1394 			fprintf(stderr, "Calculated device offset 0x%llx on %s\n",
1395 				DEVOFFSET(dev), DEVNAME(dev));
1396 #endif
1397 		}
1398 	}
1399 
1400 	if (ENVSECTORS(dev) == 0)
1401 		/* Assume enough sectors to cover the environment */
1402 		ENVSECTORS(dev) = DIV_ROUND_UP(ENVSIZE(dev), DEVESIZE(dev));
1403 
1404 	if (DEVOFFSET(dev) % DEVESIZE(dev) != 0) {
1405 		fprintf(stderr, "Environment does not start on (erase) block boundary\n");
1406 		errno = EINVAL;
1407 		return -1;
1408 	}
1409 
1410 	if (ENVSIZE(dev) > ENVSECTORS(dev) * DEVESIZE(dev)) {
1411 		fprintf(stderr, "Environment does not fit into available sectors\n");
1412 		errno = EINVAL;
1413 		return -1;
1414 	}
1415 
1416 err:
1417 	close(fd);
1418 	return rc;
1419 }
1420 
1421 static int parse_config(struct env_opts *opts)
1422 {
1423 	int rc;
1424 
1425 	if (!opts)
1426 		opts = &default_opts;
1427 
1428 #if defined(CONFIG_FILE)
1429 	/* Fills in DEVNAME(), ENVSIZE(), DEVESIZE(). Or don't. */
1430 	if (get_config(opts->config_file)) {
1431 		fprintf(stderr, "Cannot parse config file '%s': %m\n",
1432 			opts->config_file);
1433 		return -1;
1434 	}
1435 #else
1436 	DEVNAME (0) = DEVICE1_NAME;
1437 	DEVOFFSET (0) = DEVICE1_OFFSET;
1438 	ENVSIZE (0) = ENV1_SIZE;
1439 
1440 	/* Set defaults for DEVESIZE, ENVSECTORS later once we
1441 	 * know DEVTYPE
1442 	 */
1443 #ifdef DEVICE1_ESIZE
1444 	DEVESIZE (0) = DEVICE1_ESIZE;
1445 #endif
1446 #ifdef DEVICE1_ENVSECTORS
1447 	ENVSECTORS (0) = DEVICE1_ENVSECTORS;
1448 #endif
1449 
1450 #ifdef HAVE_REDUND
1451 	DEVNAME (1) = DEVICE2_NAME;
1452 	DEVOFFSET (1) = DEVICE2_OFFSET;
1453 	ENVSIZE (1) = ENV2_SIZE;
1454 
1455 	/* Set defaults for DEVESIZE, ENVSECTORS later once we
1456 	 * know DEVTYPE
1457 	 */
1458 #ifdef DEVICE2_ESIZE
1459 	DEVESIZE (1) = DEVICE2_ESIZE;
1460 #endif
1461 #ifdef DEVICE2_ENVSECTORS
1462 	ENVSECTORS (1) = DEVICE2_ENVSECTORS;
1463 #endif
1464 	HaveRedundEnv = 1;
1465 #endif
1466 #endif
1467 	rc = check_device_config(0);
1468 	if (rc < 0)
1469 		return rc;
1470 
1471 	if (HaveRedundEnv) {
1472 		rc = check_device_config(1);
1473 		if (rc < 0)
1474 			return rc;
1475 
1476 		if (ENVSIZE(0) != ENVSIZE(1)) {
1477 			fprintf(stderr,
1478 				"Redundant environments have unequal size");
1479 			return -1;
1480 		}
1481 	}
1482 
1483 	usable_envsize = CUR_ENVSIZE - sizeof(uint32_t);
1484 	if (HaveRedundEnv)
1485 		usable_envsize -= sizeof(char);
1486 
1487 	if (opts->aes_flag)
1488 		usable_envsize &= ~(AES_KEY_LENGTH - 1);
1489 
1490 	return 0;
1491 }
1492 
1493 #if defined(CONFIG_FILE)
1494 static int get_config (char *fname)
1495 {
1496 	FILE *fp;
1497 	int i = 0;
1498 	int rc;
1499 	char dump[128];
1500 	char *devname;
1501 
1502 	fp = fopen (fname, "r");
1503 	if (fp == NULL)
1504 		return -1;
1505 
1506 	while (i < 2 && fgets (dump, sizeof (dump), fp)) {
1507 		/* Skip incomplete conversions and comment strings */
1508 		if (dump[0] == '#')
1509 			continue;
1510 
1511 		rc = sscanf(dump, "%ms %lli %lx %lx %lx",
1512 			    &devname,
1513 			    &DEVOFFSET(i),
1514 			    &ENVSIZE(i),
1515 			    &DEVESIZE(i),
1516 			    &ENVSECTORS(i));
1517 
1518 		if (rc < 3)
1519 			continue;
1520 
1521 		DEVNAME(i) = devname;
1522 
1523 		/* Set defaults for DEVESIZE, ENVSECTORS later once we
1524 		 * know DEVTYPE
1525 		 */
1526 
1527 		i++;
1528 	}
1529 	fclose (fp);
1530 
1531 	HaveRedundEnv = i - 1;
1532 	if (!i) {			/* No valid entries found */
1533 		errno = EINVAL;
1534 		return -1;
1535 	} else
1536 		return 0;
1537 }
1538 #endif
1539