tools/env/fw_env.c

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