tools/env/fw_env.c

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