apps/bootblocktool-R1_3_0/bootblocktool.c

Go to the documentation of this file.

/*!***************************************************************************
*!
*! FILE NAME  : bootblocktool.c
*!
*! DESCRIPTION: Handles bootblock parameters
*!
*! ---------------------------------------------------------------------------
*! (C) Copyright 2000-2007, Axis Communications AB, LUND, SWEDEN
*! 
*! This program is free software; you can redistribute it and/or 
*! modify it under the terms of the GNU General Public License 
*! as published by the Free Software Foundation; either 
*! version 2 of the License, or (at your option) any later 
*! version.
*! 
*! This program is distributed in the hope that it will be useful,
*! but WITHOUT ANY WARRANTY; without even the implied warranty of
*! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*! GNU General Public License for more details.
*! 
*! You should have received a copy of the GNU General Public License
*! along with this program; if not, write to the Free Software
*! Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*! ---------------------------------------------------------------------------
*! HISTORY
*!
*! DATE         NAME               CHANGES
*! ----         ----               -------
*! $Log: bootblocktool.c,v $
*! Revision 1.1.1.1  2008/11/27 20:04:01  elphel
*!
*!
*! Revision 1.1.1.1  2007/06/29 12:39:49  elphel
*! This is a fresh tree based on elphel353-2.10
*!
*! Revision 1.1  2007/06/29 12:39:49  spectr_rain
*! *** empty log message ***
*!
*! Revision 1.28  2007/02/23 14:26:11  karljope
*! Merged task_branch--nandflash_support
*!
*! Revision 1.27  2007/01/10 15:43:05  karljope
*! Copyright statement added.
*!
*! Revision 1.26.2.11  2007/02/21 18:11:01  karljope
*! Sync with HEAD
*!
*! Revision 1.26.2.10  2007/02/13 13:14:19  karljope
*! Made it compile for kernels older than 2.6.19 again
*!
*! Revision 1.26.2.9  2007/02/07 16:00:22  karljope
*! * Removed inclusion of linux/compiler.h as the file is no longer available.
*!   What was it used for? Compiles fine without it anyway.
*! * Added a space in HTML_END to avoid warning. Why do we use it when we
*!   obviously don't intend to print anything?
*!
*! Revision 1.26.2.8  2007/01/23 21:41:57  ricardw
*! Cleaned file of all tabs.
*!
*! Revision 1.26.2.7  2007/01/19 15:36:13  ricardw
*! Freed wrong pointer in readParam loop, fixed. Also free parvalue in same
*! function if caller is not interested in value.
*!
*! Revision 1.26.2.6  2007/01/19 14:44:35  ricardw
*! Fixes from review 070115:
*! Added checks so that the implementation limit of max one block of parameters
*! and max one page per parameter are not exceeded.
*! Removed tabs in file.
*! Plug memory leak in loop in readParam.
*! Miscellaneous code cleanup.
*!
*! Revision 1.26.2.5  2006/11/22 12:30:50  ricardw
*! Name change of rescue partition /dev/part/crescue -> /dev/part/rescue.
*!
*! Revision 1.26.2.4  2006/11/14 07:34:54  ricardw
*! Conditonally use fwinfo area only when fwinfo set in axis config.
*!
*! Revision 1.26.2.3  2006/11/09 15:46:29  ricardw
*! imageinfo -> fwinfo (name change).
*! Added backwards compatbility for old kernels (<2.6.18, <2.6.0).
*!
*! Revision 1.26.2.2  2006/10/13 15:31:08  ricardw
*! Modified to use image info area instead of hard coded addresses.
*!
*! Revision 1.26.2.1  2006/10/13 13:51:20  ricardw
*! Initial support for NAND flash.
*!
*! Revision 1.26  2006/08/14 12:01:53  martinnn
*! Added option -err which sets exit status on errors.
*!
*! Revision 1.25  2004/11/08 14:54:11  ulfo
*! Corrected the HTTP header
*!
*! Revision 1.24  2004/02/11 17:52:31  henriken
*! '-w' argument parsing bug fixes:
*!
*! * ignore variables submitted without a value
*! * stop on variables with empty name
*!
*! Revision 1.23  2002/08/04 19:22:31  andorzn
*! * Added include of errrno.h.
*! * Added syslog messages.
*! * Added and corrected logging/printing of errno values.
*! * Removed some magic numbers.
*!
*! Revision 1.22  2002/01/23 13:48:00  johana
*! Clarified/reformatted usage.
*!
*! Revision 1.21  2002/01/22 14:26:13  orjanf
*! Added -backup option (changes flash offset and magic).
*!
*! Revision 1.20  2001/06/12 12:06:41  jonashg
*! Print usage instead of segfault.
*!
*! Revision 1.19  2001/03/27 14:16:59  jonashg
*! Removed warning message. sftpd will be modified.
*!
*! Revision 1.18  2000/12/19 09:40:29  pkj
*! Added option -nocgi (must be the first option supplied) to prevent
*! output of Content-Type when run through a web-script (PHP).
*!
*! Revision 1.17  2000/11/22 17:27:22  johana
*! Fixed parsing bugs for -w and -c (it worked if there happend to be
*! 0x00 after the argv, easaly detected if tested on host,
*! the bugs are probably in apps/paramtool as well where that code was taken from,
*! but there are no (good) reasons to use paramtool nowadays anyway:-)
*! Fixed null terminating of name in readParamAt. (It happend to work if the
*! allocated memory contained 0x00..)
*!
*! Changed all FILE* operations to the unbuffered versions using filedescriptors,
*! fseek and fwrite was very weird on my host.
*!
*! Revision 1.16  2000/08/30 12:07:02  olak
*! added printf used by sftpd
*!
*! Revision 1.15  2000/08/24 16:45:33  johana
*! Added unistd.h to remove warning (getpid())
*!
*! Revision 1.14  2000/08/09 18:03:42  finn
*! More cleanup.
*!
*! Revision 1.13  2000/08/07 16:05:17  finn
*! Cleanup.
*!
*! Revision 1.12  2000/07/04 13:21:02  johana
*! Support same parameters as paramtool: -w and -c
*! Added -lenv option to print all parameters in setenv format.
*!
*!***************************************************************************/
/* $Id: bootblocktool.c,v 1.1.1.1 2008/11/27 20:04:01 elphel Exp $ */

/****************** INCLUDE FILES SECTION ***********************************/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <syslog.h>
#include <sys/ioctl.h>
#include <linux/version.h>
#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 8)
#if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 19)
#include <linux/compiler.h>
#endif
#include <mtd/mtd-user.h>
#else
#include <linux/mtd/mtd.h>
#endif
#ifdef USE_FWINFO_AREA
#include <fwinfo.h>
#endif

/****************** CONSTANT AND MACRO SECTION ******************************/

#define EMPTYMAGIC         0xffffffff   /* what the flash looks like empty */
#define PARAMMAGIC_PRIMARY 0xbeefcace   /* default */
#define PARAMMAGIC_BACKUP  0xdeadbabe   /* backup */

#define MAX_PARAM_NAME_LEN 0xff /* format has name length in single byte */
#define MAX_RECORD_LEN   0xffff /* format has record length in two bytes */

#define ERR_NO_MAGIC -3
#define ERR_END_OF_PARAMS -2
#define ERR_OTHER -1
#define NO_ERROR   0

#define NAND_NOR_COMPATIBILITY_MODE (1)

/* Given a len, round up to the next multiple of pagesize */
#define ROUND_UP(len, pagesize) ((((len) - 1) & ~((pagesize) - 1)) + (pagesize))
/* Given an offset, return 1 if it refers to the first address of a block */
#define BLOCK_START(offset, blocksize) (((offset) & ((blocksize) -1)) == 0)
/* Given an offset, keep the bits describing the block no */
#define BLOCK_ADDR(offset, blocksize) ((offset) & ~((blocksize) -1))

static const char *dev = "/dev/part/rescue";  /* bootblock partition */

const char usage[] =
"Usage: bootblocktool [options] command\n"
"Options:\n"
"  -backup    Makes all subsequent parameters pertain to the backup block\n"
"  -nocgi     Disable CGI detection\n"
"  -d device  The device to use\n"
"  -err       Set exit status != 0 on parameter errors\n"
"Commands:\n"
"  -x name1 name2 ...          ; get\n"
"  -c name:name2:name3         ; get/check\n"
"  -a name1 value1 name2 value2 ... ; set\n"
"  -w name=value:name2=value2       ; set\n"
"  -l     ; list parameters\n"
"  -lenv  ; list parameters in setenv format\n"
;

const char HTML_END[] = " ";
/*"</pre>\n</BODY></HTML>\n"; */

//#define DEBUG
#ifdef DEBUG
#define D(x) x
#define close(x) printf("close\n"); close(x)

int open_dbg(const char* name, int type)
{
  printf("open(%s, %i)\n", name, type); 
  return open(name, type);
}
#define open(name, type) open_dbg(name, type)

int lseek_dbg(int f, long offset, int whence)
{
  int res;
//  printf(" ftell: %li\n", ftell(f));

  res = lseek(f, offset, whence);
  printf(" seek to %li %i result: %i %s\n", offset, whence, 
         res, res!=offset?"!!!!":""); 
//  printf(" ftell: %li\n", ftell(f));
  return res;
  
}
#define lseek(f, offset, whence) lseek_dbg(f, offset, whence)
#else
#define D(x)
#endif

/***************** TYPE DEFINITION SECTION **********************************/

typedef enum {SCRIPT, NAMEVALUE } Toutput_type;

/****************** LOCAL FUNCTION DECLARATION SECTION **********************/

static void printUsage(void);
static void die(const char *);

static void listParams(Toutput_type output_type);

static int readParam(const char *name, char **value, int *firstfree);
static int writeParam(const char *name, const char *value);

static int writeMagic(int file, int *offset);

static int readParamAt(int f, int offset,
                       char **name, int *nameLen,
                       char **value, int *valueLen,
                       int *totlen);
static int writeParamAt(int f, int offset, const char *name,
                        const char *value);

static void skipBadBlocks(int fd, int *offset);

static int getChipParams(void);

static int setFlashParams(void);

/****************** GLOBAL VARIABLE DECLARATION SECTION *********************/

/********************** LOCAL VARIABLE SECTION ****************************/

static int useHTML = 0;
static int setExitErr = 0;
static int exitStat = 0;

static int PARAMMAGIC = PARAMMAGIC_PRIMARY;

static int FlashOffset; /* first address in flash used for params */
static int FlashEnd; /* location after highest location we may write to */

static int nandFlash = 0; /* 0 for nor, 1 for nand */
/* The following two only relevant for nand flash */
static unsigned int blockSize;
static unsigned int pageSize;

/********************** FUNCTION DEFINITION SECTION ************************/

int
main(int argc, char **argv)
{
  int dummy;
  const char *method;
  
  argc--;
  argv++;

  if (argc > 0 && !strcmp(*argv, "-nocgi"))
  {
    argc--;
    argv++;
  }
  else if ((method = getenv("REQUEST_METHOD")))
  {
    useHTML = 1;
    printf("Content-type: text/plain\r\n\r\n");
  }
#if 0
  if (useHTML)
  {
    printf("<HTML><BODY>\n");
    printf("<pre>\n");
  }
#endif
  if (argc > 0 && !strcmp(*argv, "-err"))
  {
    setExitErr = 1;
    argc--;
    argv++;
  }
  if (argc < 1)
  {
    printUsage();
  }

  openlog("bootblocktool", LOG_PID, LOG_USER);

  if (setFlashParams() < 0)
    return 1;

  while (argc)
  {
    /* Change offset and magic to the backup block. (This option must be
       checked first since arguments are processed in the order they appear
       on the command line.) */
    if (!strcmp("-backup", *argv))
    {
      argc--;
      argv++;
      PARAMMAGIC = PARAMMAGIC_BACKUP;
      if (setFlashParams() < 0)
        return 1;
    }
    else if (!strcmp("-x", *argv))
    {
      argc--;
      argv++;
      if (argc < 1) {
        printUsage();
      }
      /* Read any number of params from device.  */
      while (argc > 0)
      {
        /* Extract a bootparam value.  */
        char *value = 0;
        if (!readParam(*argv, &value, &dummy))
        {
          /* Print to stdout.  */
          printf("%s\n", value);
          free(value);
        }
        else
        {
          fprintf(stderr, "Warning: Parameter %s not found.\n", *argv);
          exitStat = 1;
        }
        argc--;
        argv++;
      }
    }
    else if (!strcmp("-l", *argv))
    {
      argc--;
      argv++;
      /* List all parameters.  */
      listParams(NAMEVALUE);
    }
    else if (!strcmp("-lenv", *argv))
    {
      argc--;
      argv++;
      /* List all parameters.  */
      listParams(SCRIPT);
    }
    else if (!strcmp("-a", *argv))
    {
      argc--;
      argv++;
      if (argc < 1) {
        printUsage();
      }
      /* Write any number of params to device. */
      while (argc > 1)
      {
        if (writeParam(argv[0], argv[1]))
        {
          fprintf(stderr, "Warning: Parameter %s already exists.\n", argv[0]);
          exitStat = 1;
        }
        argc -= 2;
        argv += 2;
      }
    }
    else if (!strcmp("-d", *argv))
    {
      /* Specify a device to use. */
      dev = argv[1];
      D(printf("New device set: \"%s\"\n", dev));
      argv += 2;
      argc -= 2;
      /* must set flash parameters again now */
      if (setFlashParams() < 0)
        return 1;
    }
    else if (!strcmp("-c", *argv))
    {
      /* -c&SERNO:HWID:BRAND */
      char *name;
      char *sep;

      argc--;
      argv++;
      if (argc < 1) {
        printUsage();
      }
      name = *argv;
      sep = strchr(*argv, ':');

      /* Read any number of params from device. */
      while (name != NULL && *name != '\0')
      {
        /* Extract a bootparam value. */
        char *value = 0;
        if (sep != NULL)
        {
          *sep = '\0'; /* terminate the name */
          sep++;
        }

        if (!readParam(name, &value, &dummy))
        {
          /* Print to stdout. */
          if (name != *argv)
          {
            printf(" ");
          }
          printf("%s", value);
          free(value);
        }
        else
        {
          fprintf(stderr, "Warning: Parameter %s not found.\n", name);
          printf("Warning: Parameter %s not found.\n", name);
          exitStat = 1;
        }
        name = sep;
        if (sep)
        {
          sep = strchr(sep, ':');
        }
      }
      argc--;
      argv++;
    }
    else if (!strcmp("-w", *argv))
    {
      /* -w&SERNO=0800460814db:BRAND=Axis:HWID=400 */
      char *name;
      char *value;
      char *sep = NULL;

      argc--;
      argv++;
      if (argc < 1) {
        printUsage();
      }
      name = *argv;
      value = strchr(name, '=');
      sep = strchr(name, ':');
      if (value)
      {
        if (sep && sep < value) 
        {
          value = NULL;
        }
        else 
        {
          *value = '\0'; /* terminate name */
          value++;
        }
      }
      if (sep)
      {
        *sep = '\0'; /* terminate value */
        sep++;
      }

      printf("-w: %s\n", name);

      /* Write any number of params to device. */
      while (name != NULL && *name != '\0')
      {
        if (value)
        {
          if (writeParam(name, value))
          {
            fprintf(stderr, "Warning: Parameter %s already exists.\n", name);
            exitStat = 1;
          }
        }
        else
        {
          fprintf(stderr, "Warning: Parameter %s submitted without value.\n", name);
          exitStat = 1;
        }
        name = sep;
        if (name)
        {
          value = strchr(name, '=');
          sep = strchr(name, ':');
          if (value)
          {
            if (sep && sep < value)
            {
              value = NULL;
            }
            else
            {
              *value = '\0'; /* terminate name */
              value++;
            }
          }
          if (sep)
          {
            *sep = '\0'; /* terminate value */
            sep++;
          }
        }
      }
      argc--;
      argv++;
    }
    else
    {
      printUsage();
    }
  }
  if (useHTML)
  {
    printf(HTML_END);
  }
  closelog();

  if (setExitErr)
    return exitStat;
  return NO_ERROR;
}


/* Print helping message to user. */
static void
printUsage(void)
{
  if (useHTML)
  {
    printf(usage);
  }
  else
  {
    fprintf(stderr, usage);
  }
  exit(1);
}


/* Print error message and exit. */
static void
die(const char *err)
{
  if (useHTML)
  {
    printf("Error: %s\n", err);
    printf(HTML_END);
    exit(1);
  }
  else
  {
    fprintf(stderr, "Error: %s\n", err);
    exit(1);
  }
}


/* Write a parameter with the specified name and value.  */
static int
writeParam(const char *name, const char *value)
{
  int offset;
  int f;
  int readerr;

  D(printf("writeParam: %s=%s\n", name, value));

  if (strlen(name) > MAX_PARAM_NAME_LEN)
  {
    syslog(LOG_ERR, "Parameter name too long! %m");
    die("Parameter name too long!\n");
  }

  /* See if it already exists. The reference to offset
  ** is set to the next position to store a param at.
  */
  readerr = readParam(name, 0, &offset);
  if (!readerr)
  {
    /* It already exists!  */
    return ERR_OTHER;
  }

  if ((f = open(dev, O_WRONLY )) == -1)
  {
    syslog(LOG_ERR, "Couldn't open bootblock device! %m");
    die("Couldn't open device!\n");
  }

  /* If the offset was at start of area, we need to write a magic.  */

  if (readerr == ERR_NO_MAGIC)
  {
    if (writeMagic(f, &offset) < 0)
    {
      close(f);
      die("Error writing magic!\n");
    }
  }

  if (writeParamAt(f, offset, name, value) < 0)
  {
    close(f);
    die("Error writing parameters!\n");
  }
  syslog(LOG_NOTICE, "Wrote new parameter: %s=%s\n", name, value);
  close(f);
  return NO_ERROR;
}


/* List the parameters */
static void
listParams(Toutput_type output_type)
{
  int offset = FlashOffset;
  int f;
  char *parname;
  char *parvalue;
  int namelen;
  int valuelen;
  int totlen;
  unsigned long magic = 0;

  if ((f = open(dev, O_RDONLY)) == -1)
  {
    syslog(LOG_ERR, "Couldn't open bootblock device! %m");
    die("Couldn't open bootblock device!\n");
  }

  /* for nand flash, must skip bad blocks */
  if (nandFlash)
    skipBadBlocks(f, &offset);

  /* Check for correct magic.  */

  if (lseek(f, offset, SEEK_SET) < 0)
  {
    int err_saved = errno;
    
    perror("lseek");
    syslog(LOG_ERR, "lseek() failed. %s", strerror(err_saved));
    fprintf(stderr, "bootblocktool[%d]: seek failed.\n", getpid());
    close(f);
    return;
  }

  read(f, &magic, sizeof(magic));

  if (magic == EMPTYMAGIC)
  {
    /* Empty, probably not written yet.  */
    D(printf("EMPTYMAGIC!\n"));
    close(f);
    return;
  }

  if (magic != PARAMMAGIC)
  {
    syslog(LOG_ERR, "Wrong magic number found when trying to read parameter.");
    printf("ERROR: Wrong MAGIC for bootparams in listParams!\n");
    close(f);
    return;
  }

  /* OK magic, proceed...  */

  offset += nandFlash ? pageSize : sizeof(magic);

  /* Iterate through all parameters in the device, printing each one. */
  for (;;)
  {
    /* end of flash */
    if (offset >= FlashEnd)
    {
      close(f);
      return;
    }

    /* for nand flash, must skip bad blocks */
    if (nandFlash && BLOCK_START(offset, blockSize))
      skipBadBlocks(f, &offset);

    int ret = readParamAt(f, offset, &parname, &namelen,
                          &parvalue, &valuelen, &totlen);
    if (ret == ERR_END_OF_PARAMS)
    {
      /* Parameter not found. */
      close(f);
      return;
    }
    else if (ret)
    {
      close(f);
      printf("ERROR: Unknown error when reading bootblock in listParams!\n");
      return;
    }
    else
    {
      /* We found a parameter. */
      switch (output_type)
      {
       case NAMEVALUE:
        printf("%s=%s\n", parname, parvalue);
        break;
       case SCRIPT:
        printf("setenv %s \"%s\"\n", parname, parvalue);
        break;
      }
      free (parname);
      free (parvalue);

      /* for nandflash, round offset to nearest larger page */
      offset += nandFlash ? ROUND_UP(totlen, pageSize) : totlen; 
    }
  }
}


/* Search for the parameter named 'name'. Set the value reference to
** point to the value of it, which must be freed by the caller
** (when NO_ERROR is returned. When an error is returned, the
** value should not be freed). Value may also be 0 in which case 
** the reference is not set. If firstfree is non-zero, it is set to 
** the next free location in case the parameter is not found.
*/
static int
readParam(const char *name, char **value, int *firstfree)
{
  int offset = FlashOffset;
  int f;
  char *parname;
  char *parvalue;
  int namelen;
  int valuelen;
  int totlen;
  unsigned long magic = 0;
  D(printf("readParam: '%s' \n", name));
  
  if ((f = open(dev, O_RDONLY)) == -1)
  {
    syslog(LOG_ERR, "Couldn't open bootblock device! %m");
    die("Couldn't open bootblock device!\n");
  }

  /* for nand flash, must skip bad blocks */
  if (nandFlash)
    skipBadBlocks(f, &offset);

  /* Check for correct magic.  */

  if (lseek(f, offset, SEEK_SET) < 0)
  {
    int err_saved = errno;
    
    perror("lseek");
    close(f);
    syslog(LOG_ERR, "lseek() failed. %s", strerror(err_saved));
    die("bootblocktoo: seek failed.\n");
  }
  read(f, &magic, sizeof(magic));

  if (magic == EMPTYMAGIC)
  {
    /* Empty.  Probably not written yet.  */
    close(f);
    *firstfree = offset;
    return ERR_NO_MAGIC;
  }

  if (magic != PARAMMAGIC)
  {
    close(f);
    syslog(LOG_ERR, "Wrong magic number found when trying to read parameter.");
    die("Wrong MAGIC for bootparams in readParam!\n");
  }

  /* ok magic, proceed */

  offset += nandFlash ? pageSize : sizeof(magic);

  /* Iterate through all parameters in the device, looking for a name
     match.  */
  for (;;)  /* Until found or failure. */
  {
    /* for nand flash, must skip bad blocks */
    if (nandFlash && BLOCK_START(offset, blockSize))
      skipBadBlocks(f, &offset);

    int ret = readParamAt(f, offset, &parname, &namelen,
                          &parvalue, &valuelen, &totlen);
    if (ret == ERR_END_OF_PARAMS)
    {
      /* Parameter not found. */
      close(f);
      *firstfree = offset;
      return ERR_OTHER;
    }
    else if (ret == ERR_OTHER)
    {
      close(f);
      die("Unknown error when reading bootblock in readParam!\n");
    }
    else if (!strcmp(parname, name))
    {
      /* We found the parameter. */
      free (parname);
      if (value)
        *value = parvalue; /* Must be freed by caller.  */
      else
        free (parvalue); /* caller not interested, so must free it here */
      close(f);
      return NO_ERROR;
    }
    else
    {
      free (parname);
      free (parvalue);
      /* for nandflash, round offset to nearest larger page */
      offset += nandFlash ? ROUND_UP(totlen, pageSize) : totlen;
    }
  }
}


/* Read a bootparam at the specified offset.
** Create strings and set lengths. Name and value
** references must be freed by the caller when NO_ERROR is returned.
** When an error is returned, no freeing is required or should be done.
*/
static int
readParamAt(int f, int offset, char **name, int *nameLen,
      char **value, int *valueLen, int *totlen)
{
  unsigned int totallen;
  unsigned char buf[2];
  D(printf("readParamAt: %i\n", offset));

  /* Don't attempt to read beyond end of parameters */
  if (offset >= FlashEnd)
      return ERR_END_OF_PARAMS;
  
  /* Seek to the given offset.  */
  if (lseek(f, offset, SEEK_SET) < 0)
  {
    syslog(LOG_ERR, "Could not read parameter! lseek() failed! %m");
    D(printf("lseek failed\n"));

    return ERR_OTHER;
  }

  /* See the format specified in the README file.  */
  if (read(f, buf, 2) != 2)
  {
    return ERR_OTHER;
  }
  totallen = buf[0] + (buf[1] << 8);
  D(printf(" totallen: %i \n", totallen));
  if (totallen == 0xffff)
  {
    return ERR_END_OF_PARAMS;
  }
  if (read(f, buf, 1) != 1)
  {
    return ERR_OTHER;
  }
  *nameLen = (int)buf[0];
  D(printf(" nameLen: %i \n", *nameLen));
  /* Allocate space for the name.  Null-terminate it.  */
  if (!(*name = (char *)malloc(*nameLen + 1))) 
    return ERR_OTHER;
  if (read(f, *name, *nameLen) != *nameLen)
  {
    free (*name);
    return ERR_OTHER;
  }
  (*name)[*nameLen] = '\0';
  D(printf(" *name: %s \n", *name));
  *valueLen = totallen - 3 - *nameLen;
  /* Allocate space for the value.  Null-terminated.  */
  if (!(*value = (char *)malloc(*valueLen + 1)))
  {
    free(*name);
    return ERR_OTHER;
  }

  if (read(f, *value, *valueLen) != *valueLen)
  {
    free(*name);
    free(*value);
    return ERR_OTHER;
  }
  (*value)[*valueLen] = 0;
  *totlen = totallen;
  return 0;
}


/* I think this is pretty obvious. Write a parameter at the offset specified.
** See the README file for info on the format.
*/
static int
writeParamAt(int f, int offset, const char *name, const char *value)
{
  int bufsize;
  unsigned char *buf;
  int valuelen;
  int namelen;
  int totlen;
  D(printf("writeParamAt: %i'%s'='%s' \n", offset, name, value));
  valuelen = strlen(value);
  namelen = strlen(name);
  totlen = 3 + namelen + valuelen;

  /* for nand flash, need to write in complete pages, so round up buffer
   * size to next complete page
   */
  bufsize = nandFlash ? ROUND_UP(totlen, pageSize) : totlen;
  D(printf("buffer size %d\n", bufsize));

  if (totlen >= MAX_RECORD_LEN || /* >= because 0xffff is the end marker */
      !(buf = (unsigned char *)malloc(bufsize)) ||
      offset + bufsize >= FlashEnd)
  {
    return ERR_OTHER;
  }

  /* Since we haven't implemented functionality for letting parameters
   * span bad blocks in nand flashes, we need to enforce a limitation
   * that all parameters must be in the same page.
   * Therefore, when adding a parameter, check that the parameter + 
   * end marker (in its own page) is still within the same block.
   */
  if (nandFlash) {
    if ((offset & ~(blockSize - 1)) != /* blockno << 14 of start of parameter */
        ((offset + bufsize) & ~(blockSize - 1))) /* blockno << 14 of next one */
    {
      D(printf("parameter won't fit!\n"));
      D(printf("offset = 0x%x, bufsize = 0x%x, "
               "offsetpage = 0x%x, offset+bufpage = 0x%x\n",
               offset, bufsize, offset & ~(blockSize -1), 
               (offset + bufsize) & ~(blockSize-1)));
      return ERR_OTHER;
    }
  }

  if (nandFlash)
    memset(buf, 0xff, bufsize);

  buf[0] = (totlen & 0x00ff) >> 0;
  buf[1] = (totlen & 0xff00) >> 8;
  buf[2] = (namelen & 0x00ff) >> 0;
  memcpy(buf + 3, name, namelen);
  memcpy(buf + 3 + namelen, value, valuelen);

  if (lseek(f, offset, SEEK_SET) < 0)
  {
    int err_saved = errno;
    
    D(perror("lseek");
      printf("lseek failed\n");
      );
    syslog(LOG_ERR, "Could not write parameter! lseek() failed! %s", strerror(err_saved));
    goto error;
  }

  /* If not the entire buf can be written in one chunk, then there is
     something fishy.  */
  if (write(f, buf, bufsize) != bufsize)
  {
    int err_saved = errno;
    
    D(perror("write ");
      printf("write failed\n"); 
      );
    syslog(LOG_ERR, "Could not write parameter! write() failed! %s", strerror(err_saved));
    goto error;
  }

  free(buf);
  return NO_ERROR;

 error:
  free(buf);
  return ERR_OTHER;
}


/* Write PARAMMAGIC at *offset; update *offset to reflect position to
 * write first parameter at.
 */
static int
writeMagic(int file, int *offset)
{
  int bufsize;
  unsigned char *buf;
  unsigned long magic = PARAMMAGIC;

  D(printf("writeMagic at %i \n", *offset));

  bufsize = nandFlash ? pageSize : sizeof(magic);
  if (!(buf = (unsigned char *)malloc(bufsize)))
  {
    return ERR_OTHER;
  }

  if (nandFlash)
    memset(buf, 0xff, bufsize);

  memcpy(buf, &magic, sizeof(magic));

  if (lseek(file, *offset, SEEK_SET) < 0)
  {
    int err_saved = errno;
    
    D(perror("lseek");
      printf("lseek failed\n");
      );
    syslog(LOG_ERR, "Could not write magic number! lseek() failed! %s", strerror(err_saved));
    goto error;
  }
  /* If not the entire buf can be written in one chunk, then there is
     something fishy.  */
  if (write(file, buf, bufsize) != bufsize)
  {
    int err_saved = errno;

    D(perror("write"); 
      printf("write failed\n"););
    syslog(LOG_ERR, "Could not write magic number! write() failed! %s", strerror(err_saved));
    goto error;
  }

  (*offset) += bufsize;

  free(buf);

  return NO_ERROR;

 error:
  free(buf);
  return ERR_OTHER;
}


/* Obtain chip parameters from mtd layer, set nandFlash, blockSize and pageSize.
 * Return 0 if all ok, -1 if couldn't get parameters.
 * die if running on system with NAND flash but not proper NAND support in
 * kernel mtd layer (e.g. Linux 2.4 with NAND flash; not likely in 
 * practice).
 */
static int
getChipParams(void)
{
  int fd;
  struct mtd_info_user mtdInfo;

  if ((fd = open(dev, O_RDONLY)) < 0)
  {
    syslog(LOG_ERR, "Couldn't open bootblock device! %m");
    die("Couldn't open bootblock device!\n");
  }

  /* read chip parameters */

#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)

  if ((ioctl(fd, MEMGETINFO, &mtdInfo)) < 0) 
  {
    close(fd);
    syslog(LOG_ERR, "Couldn't get chip parameters! %m");
    die("Couldn't get chip parameters!\n");
  }

  nandFlash = (mtdInfo.type == MTD_NANDFLASH); /* 1 or 0 */
  blockSize = mtdInfo.erasesize; /* eg. 16k for 32Mbyte nand flash */
#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 18)
  pageSize = mtdInfo.writesize; /* eg. 512 for 32Mbyte nand flash */
#else
  pageSize = mtdInfo.oobblock; /* eg. 512 for 32Mbyte nand flash */
#endif

#else /* no NAND support in 2.4.x */

  nandFlash = blockSize = pageSize = 0;

#endif

  D(printf("Flash type %s, blocksize %d, pagesize %d\n",
    nandFlash ? "NAND" : "NOR", blockSize, pageSize));

#if !defined(MEMGETBADBLOCK)
  if (nandFlash)
  {
    syslog(LOG_ERR, "NAND flash bad block detection "
                    "not supported in this kernel version! %m");
    die("NAND flash bad block detection not supported in this kernel version\n");
  }
#endif

  close(fd);

  return 0;
}


/* Update *offset to refer to next available good block.
 * Return 0 if block could be found, 1 if we hit FlashEnd.
 */
static void
skipBadBlocks(int fd, int *offset)
{
#if defined(MEMGETBADBLOCK)
  int blockbad = 1;

  loff_t loffset = *offset;

  while (blockbad && loffset < FlashEnd)
  {
    if ((blockbad = ioctl(fd, MEMGETBADBLOCK, &loffset)) < 0)
    {
      close(fd);
      syslog(LOG_ERR, "Couldn't determine block status! %m");
      die("Couldn't determine block status!\n");
    }
    if (blockbad)
      loffset += blockSize;
  }

  *offset = loffset;
  if (loffset >= FlashEnd)
  {
    close(fd);
    syslog(LOG_ERR, "Ran out of good blocks!");
    die("Ran out of good blocks!\n");
  }

#else
  /* not much we can do. The fact that bad blocks are not handled properly
   * will have been noted when the chip parameters were detected and the 
   * program terminated accordingly.
   */
#endif
}


/* Set program internal flash memory parameters (start and end)
 * from chip parameters. 
 * Return 0 if all is well, -1 if couldn't obtain chip parameters.
 */
static int
setFlashParams(void)
{

#if !defined(USE_FWINFO_AREA) || NAND_NOR_COMPATIBILITY_MODE

/* same addresses as ordinarily used for NOR flash. Only useful for testing. */
/* Also includes this weird backup stuff. So far. */
  if (PARAMMAGIC == PARAMMAGIC_PRIMARY) {
    FlashOffset = 0xc000;
    FlashEnd = 0x10000;
  } else {
    FlashOffset = 0x10000;
    FlashEnd = 0x14000; /* i.e. one block on a 16k-block flash */
  }

#else

  struct fwinfo fwinfo;

  if (read_flash_fwinfo(dev, &fwinfo) < 0)
      return -1;

  FlashOffset = fwinfo.bootblkpar_flash_addr;
  FlashEnd = fwinfo.bootblkpar_flash_end;

#endif

  if (getChipParams() < 0)
    return -1;

  return 0;
}

/****************** END OF FILE bootblocktool.c *****************************/

---