tools/env/fw_env.c

   1 /*
   2  * (C) Copyright 2000-2008
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21  * MA 02111-1307 USA
  22  */
  23
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <stddef.h>
  29 #include <string.h>
  30 #include <sys/types.h>
  31 #include <sys/ioctl.h>
  32 #include <sys/stat.h>
  33 #include <unistd.h>
  34
  35 #ifdef MTD_OLD
  36 # include <stdint.h>
  37 # include <linux/mtd/mtd.h>
  38 #else
  39 # define  __user        /* nothing */
  40 # include <mtd/mtd-user.h>
  41 #endif
  42
  43 #include "fw_env.h"
  44
  45 #define CMD_GETENV      "fw_printenv"
  46 #define CMD_SETENV      "fw_setenv"
  47
  48 typedef struct envdev_s {
  49         char devname[16];               /* Device name */
  50         ulong devoff;                   /* Device offset */
  51         ulong env_size;                 /* environment size */
  52         ulong erase_size;               /* device erase size */
  53 } envdev_t;
  54
  55 static envdev_t envdevices[2];
  56 static int curdev;
  57
  58 #define DEVNAME(i)    envdevices[(i)].devname
  59 #define DEVOFFSET(i)  envdevices[(i)].devoff
  60 #define ENVSIZE(i)    envdevices[(i)].env_size
  61 #define DEVESIZE(i)   envdevices[(i)].erase_size
  62
  63 #define CFG_ENV_SIZE ENVSIZE(curdev)
  64
  65 #define ENV_SIZE      getenvsize()
  66
  67 typedef struct environment_s {
  68         ulong crc;                      /* CRC32 over data bytes    */
  69         unsigned char flags;            /* active or obsolete */
  70         char *data;
  71 } env_t;
  72
  73 static env_t environment;
  74
  75 static int HaveRedundEnv = 0;
  76
  77 static unsigned char active_flag = 1;
  78 static unsigned char obsolete_flag = 0;
  79
  80
  81 #define XMK_STR(x)      #x
  82 #define MK_STR(x)       XMK_STR(x)
  83
  84 static char default_environment[] = {
  85 #if defined(CONFIG_BOOTARGS)
  86         "bootargs=" CONFIG_BOOTARGS "\0"
  87 #endif
  88 #if defined(CONFIG_BOOTCOMMAND)
  89         "bootcmd=" CONFIG_BOOTCOMMAND "\0"
  90 #endif
  91 #if defined(CONFIG_RAMBOOTCOMMAND)
  92         "ramboot=" CONFIG_RAMBOOTCOMMAND "\0"
  93 #endif
  94 #if defined(CONFIG_NFSBOOTCOMMAND)
  95         "nfsboot=" CONFIG_NFSBOOTCOMMAND "\0"
  96 #endif
  97 #if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
  98         "bootdelay=" MK_STR (CONFIG_BOOTDELAY) "\0"
  99 #endif
 100 #if defined(CONFIG_BAUDRATE) && (CONFIG_BAUDRATE >= 0)
 101         "baudrate=" MK_STR (CONFIG_BAUDRATE) "\0"
 102 #endif
 103 #ifdef  CONFIG_LOADS_ECHO
 104         "loads_echo=" MK_STR (CONFIG_LOADS_ECHO) "\0"
 105 #endif
 106 #ifdef  CONFIG_ETHADDR
 107         "ethaddr=" MK_STR (CONFIG_ETHADDR) "\0"
 108 #endif
 109 #ifdef  CONFIG_ETH1ADDR
 110         "eth1addr=" MK_STR (CONFIG_ETH1ADDR) "\0"
 111 #endif
 112 #ifdef  CONFIG_ETH2ADDR
 113         "eth2addr=" MK_STR (CONFIG_ETH2ADDR) "\0"
 114 #endif
 115 #ifdef  CONFIG_ETH3ADDR
 116         "eth3addr=" MK_STR (CONFIG_ETH3ADDR) "\0"
 117 #endif
 118 #ifdef  CONFIG_ETHPRIME
 119         "ethprime=" CONFIG_ETHPRIME "\0"
 120 #endif
 121 #ifdef  CONFIG_IPADDR
 122         "ipaddr=" MK_STR (CONFIG_IPADDR) "\0"
 123 #endif
 124 #ifdef  CONFIG_SERVERIP
 125         "serverip=" MK_STR (CONFIG_SERVERIP) "\0"
 126 #endif
 127 #ifdef  CFG_AUTOLOAD
 128         "autoload=" CFG_AUTOLOAD "\0"
 129 #endif
 130 #ifdef  CONFIG_ROOTPATH
 131         "rootpath=" MK_STR (CONFIG_ROOTPATH) "\0"
 132 #endif
 133 #ifdef  CONFIG_GATEWAYIP
 134         "gatewayip=" MK_STR (CONFIG_GATEWAYIP) "\0"
 135 #endif
 136 #ifdef  CONFIG_NETMASK
 137         "netmask=" MK_STR (CONFIG_NETMASK) "\0"
 138 #endif
 139 #ifdef  CONFIG_HOSTNAME
 140         "hostname=" MK_STR (CONFIG_HOSTNAME) "\0"
 141 #endif
 142 #ifdef  CONFIG_BOOTFILE
 143         "bootfile=" MK_STR (CONFIG_BOOTFILE) "\0"
 144 #endif
 145 #ifdef  CONFIG_LOADADDR
 146         "loadaddr=" MK_STR (CONFIG_LOADADDR) "\0"
 147 #endif
 148 #ifdef  CONFIG_PREBOOT
 149         "preboot=" CONFIG_PREBOOT "\0"
 150 #endif
 151 #ifdef  CONFIG_CLOCKS_IN_MHZ
 152         "clocks_in_mhz=" "1" "\0"
 153 #endif
 154 #if defined(CONFIG_PCI_BOOTDELAY) && (CONFIG_PCI_BOOTDELAY > 0)
 155         "pcidelay=" MK_STR (CONFIG_PCI_BOOTDELAY) "\0"
 156 #endif
 157 #ifdef  CONFIG_EXTRA_ENV_SETTINGS
 158         CONFIG_EXTRA_ENV_SETTINGS
 159 #endif
 160         "\0"                    /* Termimate env_t data with 2 NULs */
 161 };
 162
 163 static int flash_io (int mode);
 164 static char *envmatch (char * s1, char * s2);
 165 static int env_init (void);
 166 static int parse_config (void);
 167
 168 #if defined(CONFIG_FILE)
 169 static int get_config (char *);
 170 #endif
 171 static inline ulong getenvsize (void)
 172 {
 173         ulong rc = CFG_ENV_SIZE - sizeof (long);
 174
 175         if (HaveRedundEnv)
 176                 rc -= sizeof (char);
 177         return rc;
 178 }
 179
 180 /*
 181  * Search the environment for a variable.
 182  * Return the value, if found, or NULL, if not found.
 183  */
 184 char *fw_getenv (char *name)
 185 {
 186         char *env, *nxt;
 187
 188         if (env_init ())
 189                 return (NULL);
 190
 191         for (env = environment.data; *env; env = nxt + 1) {
 192                 char *val;
 193
 194                 for (nxt = env; *nxt; ++nxt) {
 195                         if (nxt >= &environment.data[ENV_SIZE]) {
 196                                 fprintf (stderr, "## Error: "
 197                                         "environment not terminated\n");
 198                                 return (NULL);
 199                         }
 200                 }
 201                 val = envmatch (name, env);
 202                 if (!val)
 203                         continue;
 204                 return (val);
 205         }
 206         return (NULL);
 207 }
 208
 209 /*
 210  * Print the current definition of one, or more, or all
 211  * environment variables
 212  */
 213 int fw_printenv (int argc, char *argv[])
 214 {
 215         char *env, *nxt;
 216         int i, n_flag;
 217         int rc = 0;
 218
 219         if (env_init ())
 220                 return (-1);
 221
 222         if (argc == 1) {                /* Print all env variables  */
 223                 for (env = environment.data; *env; env = nxt + 1) {
 224                         for (nxt = env; *nxt; ++nxt) {
 225                                 if (nxt >= &environment.data[ENV_SIZE]) {
 226                                         fprintf (stderr, "## Error: "
 227                                                 "environment not terminated\n");
 228                                         return (-1);
 229                                 }
 230                         }
 231
 232                         printf ("%s\n", env);
 233                 }
 234                 return (0);
 235         }
 236
 237         if (strcmp (argv[1], "-n") == 0) {
 238                 n_flag = 1;
 239                 ++argv;
 240                 --argc;
 241                 if (argc != 2) {
 242                         fprintf (stderr, "## Error: "
 243                                 "`-n' option requires exactly one argument\n");
 244                         return (-1);
 245                 }
 246         } else {
 247                 n_flag = 0;
 248         }
 249
 250         for (i = 1; i < argc; ++i) {    /* print single env variables   */
 251                 char *name = argv[i];
 252                 char *val = NULL;
 253
 254                 for (env = environment.data; *env; env = nxt + 1) {
 255
 256                         for (nxt = env; *nxt; ++nxt) {
 257                                 if (nxt >= &environment.data[ENV_SIZE]) {
 258                                         fprintf (stderr, "## Error: "
 259                                                 "environment not terminated\n");
 260                                         return (-1);
 261                                 }
 262                         }
 263                         val = envmatch (name, env);
 264                         if (val) {
 265                                 if (!n_flag) {
 266                                         fputs (name, stdout);
 267                                         putc ('=', stdout);
 268                                 }
 269                                 puts (val);
 270                                 break;
 271                         }
 272                 }
 273                 if (!val) {
 274                         fprintf (stderr, "## Error: \"%s\" not defined\n", name);
 275                         rc = -1;
 276                 }
 277         }
 278
 279         return (rc);
 280 }
 281
 282 /*
 283  * Deletes or sets environment variables. Returns errno style error codes:
 284  * 0      - OK
 285  * EINVAL - need at least 1 argument
 286  * EROFS  - certain variables ("ethaddr", "serial#") cannot be
 287  *          modified or deleted
 288  *
 289  */
 290 int fw_setenv (int argc, char *argv[])
 291 {
 292         int i, len;
 293         char *env, *nxt;
 294         char *oldval = NULL;
 295         char *name;
 296
 297         if (argc < 2) {
 298                 return (EINVAL);
 299         }
 300
 301         if (env_init ())
 302                 return (errno);
 303
 304         name = argv[1];
 305
 306         /*
 307          * search if variable with this name already exists
 308          */
 309         for (nxt = env = environment.data; *env; env = nxt + 1) {
 310                 for (nxt = env; *nxt; ++nxt) {
 311                         if (nxt >= &environment.data[ENV_SIZE]) {
 312                                 fprintf (stderr, "## Error: "
 313                                         "environment not terminated\n");
 314                                 return (EINVAL);
 315                         }
 316                 }
 317                 if ((oldval = envmatch (name, env)) != NULL)
 318                         break;
 319         }
 320
 321         /*
 322          * Delete any existing definition
 323          */
 324         if (oldval) {
 325                 /*
 326                  * Ethernet Address and serial# can be set only once
 327                  */
 328                 if ((strcmp (name, "ethaddr") == 0) ||
 329                         (strcmp (name, "serial#") == 0)) {
 330                         fprintf (stderr, "Can't overwrite \"%s\"\n", name);
 331                         return (EROFS);
 332                 }
 333
 334                 if (*++nxt == '\0') {
 335                         *env = '\0';
 336                 } else {
 337                         for (;;) {
 338                                 *env = *nxt++;
 339                                 if ((*env == '\0') && (*nxt == '\0'))
 340                                         break;
 341                                 ++env;
 342                         }
 343                 }
 344                 *++env = '\0';
 345         }
 346
 347         /* Delete only ? */
 348         if (argc < 3)
 349                 goto WRITE_FLASH;
 350
 351         /*
 352          * Append new definition at the end
 353          */
 354         for (env = environment.data; *env || *(env + 1); ++env);
 355         if (env > environment.data)
 356                 ++env;
 357         /*
 358          * Overflow when:
 359          * "name" + "=" + "val" +"\0\0"  > CFG_ENV_SIZE - (env-environment)
 360          */
 361         len = strlen (name) + 2;
 362         /* add '=' for first arg, ' ' for all others */
 363         for (i = 2; i < argc; ++i) {
 364                 len += strlen (argv[i]) + 1;
 365         }
 366         if (len > (&environment.data[ENV_SIZE] - env)) {
 367                 fprintf (stderr,
 368                         "Error: environment overflow, \"%s\" deleted\n",
 369                         name);
 370                 return (-1);
 371         }
 372         while ((*env = *name++) != '\0')
 373                 env++;
 374         for (i = 2; i < argc; ++i) {
 375                 char *val = argv[i];
 376
 377                 *env = (i == 2) ? '=' : ' ';
 378                 while ((*++env = *val++) != '\0');
 379         }
 380
 381         /* end is marked with double '\0' */
 382         *++env = '\0';
 383
 384   WRITE_FLASH:
 385
 386         /* Update CRC */
 387         environment.crc = crc32 (0, (uint8_t*) environment.data, ENV_SIZE);
 388
 389         /* write environment back to flash */
 390         if (flash_io (O_RDWR)) {
 391                 fprintf (stderr, "Error: can't write fw_env to flash\n");
 392                 return (-1);
 393         }
 394
 395         return (0);
 396 }
 397
 398 static int flash_io (int mode)
 399 {
 400         int fd, fdr, rc, otherdev, len, resid;
 401         struct erase_info_user erase;
 402         char *data = NULL;
 403
 404         if ((fd = open (DEVNAME (curdev), mode)) < 0) {
 405                 fprintf (stderr,
 406                         "Can't open %s: %s\n",
 407                         DEVNAME (curdev), strerror (errno));
 408                 return (-1);
 409         }
 410
 411         len = sizeof (environment.crc);
 412         if (HaveRedundEnv) {
 413                 len += sizeof (environment.flags);
 414         }
 415
 416         if (mode == O_RDWR) {
 417                 if (HaveRedundEnv) {
 418                         /* switch to next partition for writing */
 419                         otherdev = !curdev;
 420                         if ((fdr = open (DEVNAME (otherdev), mode)) < 0) {
 421                                 fprintf (stderr,
 422                                         "Can't open %s: %s\n",
 423                                         DEVNAME (otherdev),
 424                                         strerror (errno));
 425                                 return (-1);
 426                         }
 427                 } else {
 428                         otherdev = curdev;
 429                         fdr = fd;
 430                 }
 431                 printf ("Unlocking flash...\n");
 432                 erase.length = DEVESIZE (otherdev);
 433                 erase.start = DEVOFFSET (otherdev);
 434                 ioctl (fdr, MEMUNLOCK, &erase);
 435
 436                 if (HaveRedundEnv) {
 437                         erase.length = DEVESIZE (curdev);
 438                         erase.start = DEVOFFSET (curdev);
 439                         ioctl (fd, MEMUNLOCK, &erase);
 440                         environment.flags = active_flag;
 441                 }
 442
 443                 printf ("Done\n");
 444                 resid = DEVESIZE (otherdev) - CFG_ENV_SIZE;
 445                 if (resid) {
 446                         if ((data = malloc (resid)) == NULL) {
 447                                 fprintf (stderr,
 448                                         "Cannot malloc %d bytes: %s\n",
 449                                         resid,
 450                                         strerror (errno));
 451                                 return (-1);
 452                         }
 453                         if (lseek (fdr, DEVOFFSET (otherdev) + CFG_ENV_SIZE, SEEK_SET)
 454                                 == -1) {
 455                                 fprintf (stderr, "seek error on %s: %s\n",
 456                                         DEVNAME (otherdev),
 457                                         strerror (errno));
 458                                 return (-1);
 459                         }
 460                         if ((rc = read (fdr, data, resid)) != resid) {
 461                                 fprintf (stderr,
 462                                         "read error on %s: %s\n",
 463                                         DEVNAME (otherdev),
 464                                         strerror (errno));
 465                                 return (-1);
 466                         }
 467                 }
 468
 469                 printf ("Erasing old environment...\n");
 470
 471                 erase.length = DEVESIZE (otherdev);
 472                 erase.start = DEVOFFSET (otherdev);
 473                 if (ioctl (fdr, MEMERASE, &erase) != 0) {
 474                         fprintf (stderr, "MTD erase error on %s: %s\n",
 475                                 DEVNAME (otherdev),
 476                                 strerror (errno));
 477                         return (-1);
 478                 }
 479
 480                 printf ("Done\n");
 481
 482                 printf ("Writing environment to %s...\n", DEVNAME (otherdev));
 483                 if (lseek (fdr, DEVOFFSET (otherdev), SEEK_SET) == -1) {
 484                         fprintf (stderr,
 485                                 "seek error on %s: %s\n",
 486                                 DEVNAME (otherdev), strerror (errno));
 487                         return (-1);
 488                 }
 489                 if (write (fdr, &environment, len) != len) {
 490                         fprintf (stderr,
 491                                 "CRC write error on %s: %s\n",
 492                                 DEVNAME (otherdev), strerror (errno));
 493                         return (-1);
 494                 }
 495                 if (write (fdr, environment.data, ENV_SIZE) != ENV_SIZE) {
 496                         fprintf (stderr,
 497                                 "Write error on %s: %s\n",
 498                                 DEVNAME (otherdev), strerror (errno));
 499                         return (-1);
 500                 }
 501                 if (resid) {
 502                         if (write (fdr, data, resid) != resid) {
 503                                 fprintf (stderr,
 504                                         "write error on %s: %s\n",
 505                                         DEVNAME (curdev), strerror (errno));
 506                                 return (-1);
 507                         }
 508                         free (data);
 509                 }
 510                 if (HaveRedundEnv) {
 511                         /* change flag on current active env partition */
 512                         if (lseek (fd, DEVOFFSET (curdev) + sizeof (ulong), SEEK_SET)
 513                                 == -1) {
 514                                 fprintf (stderr, "seek error on %s: %s\n",
 515                                         DEVNAME (curdev), strerror (errno));
 516                                 return (-1);
 517                         }
 518                         if (write (fd, &obsolete_flag, sizeof (obsolete_flag)) !=
 519                                 sizeof (obsolete_flag)) {
 520                                 fprintf (stderr,
 521                                         "Write error on %s: %s\n",
 522                                         DEVNAME (curdev), strerror (errno));
 523                                 return (-1);
 524                         }
 525                 }
 526                 printf ("Done\n");
 527                 printf ("Locking ...\n");
 528                 erase.length = DEVESIZE (otherdev);
 529                 erase.start = DEVOFFSET (otherdev);
 530                 ioctl (fdr, MEMLOCK, &erase);
 531                 if (HaveRedundEnv) {
 532                         erase.length = DEVESIZE (curdev);
 533                         erase.start = DEVOFFSET (curdev);
 534                         ioctl (fd, MEMLOCK, &erase);
 535                         if (close (fdr)) {
 536                                 fprintf (stderr,
 537                                         "I/O error on %s: %s\n",
 538                                         DEVNAME (otherdev),
 539                                         strerror (errno));
 540                                 return (-1);
 541                         }
 542                 }
 543                 printf ("Done\n");
 544         } else {
 545
 546                 if (lseek (fd, DEVOFFSET (curdev), SEEK_SET) == -1) {
 547                         fprintf (stderr,
 548                                 "seek error on %s: %s\n",
 549                                 DEVNAME (curdev), strerror (errno));
 550                         return (-1);
 551                 }
 552                 if (read (fd, &environment, len) != len) {
 553                         fprintf (stderr,
 554                                 "CRC read error on %s: %s\n",
 555                                 DEVNAME (curdev), strerror (errno));
 556                         return (-1);
 557                 }
 558                 if ((rc = read (fd, environment.data, ENV_SIZE)) != ENV_SIZE) {
 559                         fprintf (stderr,
 560                                 "Read error on %s: %s\n",
 561                                 DEVNAME (curdev), strerror (errno));
 562                         return (-1);
 563                 }
 564         }
 565
 566         if (close (fd)) {
 567                 fprintf (stderr,
 568                         "I/O error on %s: %s\n",
 569                         DEVNAME (curdev), strerror (errno));
 570                 return (-1);
 571         }
 572
 573         /* everything ok */
 574         return (0);
 575 }
 576
 577 /*
 578  * s1 is either a simple 'name', or a 'name=value' pair.
 579  * s2 is a 'name=value' pair.
 580  * If the names match, return the value of s2, else NULL.
 581  */
 582
 583 static char *envmatch (char * s1, char * s2)
 584 {
 585
 586         while (*s1 == *s2++)
 587                 if (*s1++ == '=')
 588                         return (s2);
 589         if (*s1 == '\0' && *(s2 - 1) == '=')
 590                 return (s2);
 591         return (NULL);
 592 }
 593
 594 /*
 595  * Prevent confusion if running from erased flash memory
 596  */
 597 static int env_init (void)
 598 {
 599         int crc1, crc1_ok;
 600         char *addr1;
 601
 602         int crc2, crc2_ok;
 603         char flag1, flag2, *addr2;
 604
 605         if (parse_config ())            /* should fill envdevices */
 606                 return 1;
 607
 608         if ((addr1 = calloc (1, ENV_SIZE)) == NULL) {
 609                 fprintf (stderr,
 610                         "Not enough memory for environment (%ld bytes)\n",
 611                         ENV_SIZE);
 612                 return (errno);
 613         }
 614
 615         /* read environment from FLASH to local buffer */
 616         environment.data = addr1;
 617         curdev = 0;
 618         if (flash_io (O_RDONLY)) {
 619                 return (errno);
 620         }
 621
 622         crc1_ok = ((crc1 = crc32 (0, (uint8_t *) environment.data, ENV_SIZE))
 623                            == environment.crc);
 624         if (!HaveRedundEnv) {
 625                 if (!crc1_ok) {
 626                         fprintf (stderr,
 627                                 "Warning: Bad CRC, using default environment\n");
 628                         memcpy(environment.data, default_environment, sizeof default_environment);
 629                 }
 630         } else {
 631                 flag1 = environment.flags;
 632
 633                 curdev = 1;
 634                 if ((addr2 = calloc (1, ENV_SIZE)) == NULL) {
 635                         fprintf (stderr,
 636                                 "Not enough memory for environment (%ld bytes)\n",
 637                                 ENV_SIZE);
 638                         return (errno);
 639                 }
 640                 environment.data = addr2;
 641
 642                 if (flash_io (O_RDONLY)) {
 643                         return (errno);
 644                 }
 645
 646                 crc2_ok = ((crc2 = crc32 (0, (uint8_t *) environment.data, ENV_SIZE))
 647                                    == environment.crc);
 648                 flag2 = environment.flags;
 649
 650                 if (crc1_ok && !crc2_ok) {
 651                         environment.data = addr1;
 652                         environment.flags = flag1;
 653                         environment.crc = crc1;
 654                         curdev = 0;
 655                         free (addr2);
 656                 } else if (!crc1_ok && crc2_ok) {
 657                         environment.data = addr2;
 658                         environment.flags = flag2;
 659                         environment.crc = crc2;
 660                         curdev = 1;
 661                         free (addr1);
 662                 } else if (!crc1_ok && !crc2_ok) {
 663                         fprintf (stderr,
 664                                 "Warning: Bad CRC, using default environment\n");
 665                         memcpy(environment.data, default_environment, sizeof default_environment);
 666                         curdev = 0;
 667                         free (addr1);
 668                 } else if (flag1 == active_flag && flag2 == obsolete_flag) {
 669                         environment.data = addr1;
 670                         environment.flags = flag1;
 671                         environment.crc = crc1;
 672                         curdev = 0;
 673                         free (addr2);
 674                 } else if (flag1 == obsolete_flag && flag2 == active_flag) {
 675                         environment.data = addr2;
 676                         environment.flags = flag2;
 677                         environment.crc = crc2;
 678                         curdev = 1;
 679                         free (addr1);
 680                 } else if (flag1 == flag2) {
 681                         environment.data = addr1;
 682                         environment.flags = flag1;
 683                         environment.crc = crc1;
 684                         curdev = 0;
 685                         free (addr2);
 686                 } else if (flag1 == 0xFF) {
 687                         environment.data = addr1;
 688                         environment.flags = flag1;
 689                         environment.crc = crc1;
 690                         curdev = 0;
 691                         free (addr2);
 692                 } else if (flag2 == 0xFF) {
 693                         environment.data = addr2;
 694                         environment.flags = flag2;
 695                         environment.crc = crc2;
 696                         curdev = 1;
 697                         free (addr1);
 698                 }
 699         }
 700         return (0);
 701 }
 702
 703
 704 static int parse_config ()
 705 {
 706         struct stat st;
 707
 708 #if defined(CONFIG_FILE)
 709         /* Fills in DEVNAME(), ENVSIZE(), DEVESIZE(). Or don't. */
 710         if (get_config (CONFIG_FILE)) {
 711                 fprintf (stderr,
 712                         "Cannot parse config file: %s\n", strerror (errno));
 713                 return 1;
 714         }
 715 #else
 716         strcpy (DEVNAME (0), DEVICE1_NAME);
 717         DEVOFFSET (0) = DEVICE1_OFFSET;
 718         ENVSIZE (0) = ENV1_SIZE;
 719         DEVESIZE (0) = DEVICE1_ESIZE;
 720 #ifdef HAVE_REDUND
 721         strcpy (DEVNAME (1), DEVICE2_NAME);
 722         DEVOFFSET (1) = DEVICE2_OFFSET;
 723         ENVSIZE (1) = ENV2_SIZE;
 724         DEVESIZE (1) = DEVICE2_ESIZE;
 725         HaveRedundEnv = 1;
 726 #endif
 727 #endif
 728         if (stat (DEVNAME (0), &st)) {
 729                 fprintf (stderr,
 730                         "Cannot access MTD device %s: %s\n",
 731                         DEVNAME (0), strerror (errno));
 732                 return 1;
 733         }
 734
 735         if (HaveRedundEnv && stat (DEVNAME (1), &st)) {
 736                 fprintf (stderr,
 737                         "Cannot access MTD device %s: %s\n",
 738                         DEVNAME (1), strerror (errno));
 739                 return 1;
 740         }
 741         return 0;
 742 }
 743
 744 #if defined(CONFIG_FILE)
 745 static int get_config (char *fname)
 746 {
 747         FILE *fp;
 748         int i = 0;
 749         int rc;
 750         char dump[128];
 751
 752         if ((fp = fopen (fname, "r")) == NULL) {
 753                 return 1;
 754         }
 755
 756         while ((i < 2) && ((rc = fscanf (fp, "%s %lx %lx %lx",
 757                                   DEVNAME (i),
 758                                   &DEVOFFSET (i),
 759                                   &ENVSIZE (i),
 760                                   &DEVESIZE (i)  )) != EOF)) {
 761
 762                 /* Skip incomplete conversions and comment strings */
 763                 if ((rc < 3) || (*DEVNAME (i) == '#')) {
 764                         fgets (dump, sizeof (dump), fp);        /* Consume till end */
 765                         continue;
 766                 }
 767
 768                 i++;
 769         }
 770         fclose (fp);
 771
 772         HaveRedundEnv = i - 1;
 773         if (!i) {                       /* No valid entries found */
 774                 errno = EINVAL;
 775                 return 1;
 776         } else
 777                 return 0;
 778 }
 779 #endif