fileio.c File Reference

#include "ac_cfg.h"
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <stdint.h>
#include "avrdude.h"
#include "libavrdude.h"

Include dependency graph for fileio.c:

Go to the source code of this file.

Classes
struct	ihexrec

Macros
#define	IHEX_MAXDATA   256
#define	MAX_LINE_LEN   256 /* max line length for ASCII format input files */
#define	MAX_MODE_LEN   32

Functions
static int	b2ihex (unsigned char *inbuf, int bufsize, int recsize, int startaddr, char *outfile, FILE *outf)
static int	ihex2b (char *infile, FILE *inf, AVRMEM *mem, int bufsize, unsigned int fileoffset)
static int	b2srec (unsigned char *inbuf, int bufsize, int recsize, int startaddr, char *outfile, FILE *outf)
static int	srec2b (char *infile, FILE *inf, AVRMEM *mem, int bufsize, unsigned int fileoffset)
static int	ihex_readrec (struct ihexrec *ihex, char *rec)
static int	srec_readrec (struct ihexrec *srec, char *rec)
static int	fileio_rbin (struct fioparms *fio, char *filename, FILE *f, AVRMEM *mem, int size)
static int	fileio_ihex (struct fioparms *fio, char *filename, FILE *f, AVRMEM *mem, int size)
static int	fileio_srec (struct fioparms *fio, char *filename, FILE *f, AVRMEM *mem, int size)
static int	fileio_num (struct fioparms *fio, char *filename, FILE *f, AVRMEM *mem, int size, FILEFMT fmt)
static int	fmt_autodetect (char *fname, unsigned section)
FILE *	fopen_utf8 (const char *filename, const char *mode)
static FILE *	fopen_and_seek (const char *filename, const char *mode, unsigned section)
char *	fmtstr (FILEFMT format)
static char *	itoa_simple (int n, char *buf, int base)
static int	fileio_imm (struct fioparms *fio, char *filename, FILE *f, AVRMEM *mem, int size)
int	fileio_setparms (int op, struct fioparms *fp, struct avrpart *p, AVRMEM *m)
int	fileio (int op, char *filename, FILEFMT format, struct avrpart *p, char *memtype, int size, unsigned section)

---

Class Documentation

ihexrec

struct ihexrec

Class Members
unsigned char	cksum
unsigned char	data[IHEX_MAXDATA]
unsigned int	loadofs
unsigned char	reclen
unsigned char	rectyp

Macro Definition Documentation

IHEX_MAXDATA

#define IHEX_MAXDATA   256

MAX_LINE_LEN

#define MAX_LINE_LEN   256 /* max line length for ASCII format input files */

MAX_MODE_LEN

#define MAX_MODE_LEN   32

Function Documentation

b2ihex()

static int b2ihex ( unsigned char *  inbuf, int  bufsize, int  recsize, int  startaddr, char *  outfile, FILE *  outf  )

static

{
  unsigned char * buf;
  unsigned int nextaddr;
  int n, nbytes, n_64k;
  int i;
  unsigned char cksum;
 
  if (recsize > 255) {
    avrdude_message(MSG_INFO, "%s: recsize=%d, must be < 256\n",
              progname, recsize);
    return -1;
  }
 
  n_64k    = 0;
  nextaddr = startaddr;
  buf      = inbuf;
  nbytes   = 0;
 
  while (bufsize) {
    n = recsize;
    if (n > bufsize)
      n = bufsize;
 
    if ((nextaddr + n) > 0x10000)
      n = 0x10000 - nextaddr;
 
    if (n) {
      cksum = 0;
      fprintf(outf, ":%02X%04X00", n, nextaddr);
      cksum += n + ((nextaddr >> 8) & 0x0ff) + (nextaddr & 0x0ff);
      for (i=0; i<n; i++) {
        fprintf(outf, "%02X", buf[i]);
        cksum += buf[i];
      }
      cksum = -cksum;
      fprintf(outf, "%02X\n", cksum);
      
      nextaddr += n;
      nbytes   += n;
    }
 
    if (nextaddr >= 0x10000) {
      int lo, hi;
      /* output an extended address record */
      n_64k++;
      lo = n_64k & 0xff;
      hi = (n_64k >> 8) & 0xff;
      cksum = 0;
      fprintf(outf, ":02000004%02X%02X", hi, lo);
      cksum += 2 + 0 + 4 + hi + lo;
      cksum = -cksum;
      fprintf(outf, "%02X\n", cksum);
      nextaddr = 0;
    }
 
    /* advance to next 'recsize' bytes */
    buf += n;
    bufsize -= n;
  }
 
  /*-----------------------------------------------------------------
    add the end of record data line
    -----------------------------------------------------------------*/
  cksum = 0;
  n = 0;
  nextaddr = 0;
  fprintf(outf, ":%02X%04X01", n, nextaddr);
  cksum += n + ((nextaddr >> 8) & 0x0ff) + (nextaddr & 0x0ff) + 1;
  cksum = -cksum;
  fprintf(outf, "%02X\n", cksum);
 
  return nbytes;
}

References avrdude_message(), MSG_INFO, and progname.

Referenced by fileio_ihex().

Here is the call graph for this function:

Here is the caller graph for this function:

b2srec()

static int b2srec ( unsigned char *  inbuf, int  bufsize, int  recsize, int  startaddr, char *  outfile, FILE *  outf  )

static

{
  unsigned char * buf;
  unsigned int nextaddr;
  int n, nbytes, addr_width;
  int i;
  unsigned char cksum;
 
  char * tmpl=0;
 
  if (recsize > 255) {
    avrdude_message(MSG_INFO, "%s: ERROR: recsize=%d, must be < 256\n",
            progname, recsize);
    return -1;
  }
  
  nextaddr = startaddr;
  buf = inbuf;
  nbytes = 0;    
 
  addr_width = 0;
 
  while (bufsize) {
 
    n = recsize;
 
    if (n > bufsize) 
      n = bufsize;
 
    if (n) {
      cksum = 0;
      if (nextaddr + n <= 0xffff) {
        addr_width = 2;
        tmpl="S1%02X%04X";
      }
      else if (nextaddr + n <= 0xffffff) {
        addr_width = 3;
        tmpl="S2%02X%06X";
      }
      else if (nextaddr + n <= 0xffffffff) {
        addr_width = 4;
        tmpl="S3%02X%08X";
      }
      else {
        avrdude_message(MSG_INFO, "%s: ERROR: address=%d, out of range\n",
                progname, nextaddr);
        return -1;
      }
 
      fprintf(outf, tmpl, n + addr_width + 1, nextaddr);
 
      cksum += n + addr_width + 1;
 
      for (i = addr_width; i>0; i--) {
        cksum += (nextaddr >> (i-1) * 8) & 0xff;
      }
 
      for (unsigned i = nextaddr; i < nextaddr + n; i++) {
        fprintf(outf, "%02X", buf[i]);
        cksum += buf[i];
      }
 
      cksum = 0xff - cksum;
      fprintf(outf, "%02X\n", cksum);
 
      nextaddr += n;
      nbytes +=n;
    }
 
    /* advance to next 'recsize' bytes */
    bufsize -= n;
  }
 
  /*-----------------------------------------------------------------
    add the end of record data line
    -----------------------------------------------------------------*/
  cksum = 0;
  n = 0;
  nextaddr = 0;
 
  if (startaddr <= 0xffff) {
    addr_width = 2;
    tmpl="S9%02X%04X";
  }
  else if (startaddr <= 0xffffff) {
    addr_width = 3;
    tmpl="S9%02X%06X";
  }
  else if (startaddr <= 0xffffffff) {
    addr_width = 4;
    tmpl="S9%02X%08X";
  }
 
  fprintf(outf, tmpl, n + addr_width + 1, nextaddr);
 
  cksum += n + addr_width +1;
  for (i=addr_width; i>0; i--) 
    cksum += (nextaddr >> (i - 1) * 8) & 0xff;
  cksum = 0xff - cksum;
  fprintf(outf, "%02X\n", cksum);
 
  return nbytes; 
}

References avrdude_message(), ihexrec::cksum, MSG_INFO, and progname.

Referenced by fileio_srec().

Here is the call graph for this function:

Here is the caller graph for this function:

fileio()

int fileio	(	int	op,
		char *	filename,
		FILEFMT	format,
		struct avrpart *	p,
		char *	memtype,
		int	size,
		unsigned	section
	)

{
  int rc;
  FILE * f;
  char * fname;
  struct fioparms fio;
  AVRMEM * mem;
  int using_stdio;
 
  mem = avr_locate_mem(p, memtype);
  if (mem == NULL) {
    avrdude_message(MSG_INFO, "fileio(): memory type \"%s\" not configured for device \"%s\"\n",
                    memtype, p->desc);
    return -1;
  }
 
  rc = fileio_setparms(op, &fio, p, mem);
  if (rc < 0)
    return -1;
 
  if (fio.op == FIO_READ)
    size = mem->size;
 
  if (fio.op == FIO_READ) {
    /* 0xff fill unspecified memory */
    memset(mem->buf, 0xff, size);
  }
  memset(mem->tags, 0, size);
 
  using_stdio = 0;
 
  if (strcmp(filename, "-")==0) {
    return -1;
    // Note: we don't want to read stdin or write to stdout as part of Slic3r
    // if (fio.op == FIO_READ) {
    //   fname = "<stdin>";
    //   f = stdin;
    // }
    // else {
    //   fname = "<stdout>";
    //   f = stdout;
    // }
    // using_stdio = 1;
  }
  else {
    fname = filename;
    f = NULL;
  }
 
  if (format == FMT_AUTO) {
    int format_detect;
 
    if (using_stdio) {
      avrdude_message(MSG_INFO, "%s: can't auto detect file format when using stdin/out.\n"
                      "%s  Please specify a file format and try again.\n",
                      progname, progbuf);
      return -1;
    }
 
    format_detect = fmt_autodetect(fname, section);
    if (format_detect < 0) {
      avrdude_message(MSG_INFO, "%s: can't determine file format for %s, specify explicitly\n",
                      progname, fname);
      return -1;
    }
    format = format_detect;
 
    if (quell_progress < 2) {
      avrdude_message(MSG_INFO, "%s: %s file %s auto detected as %s\n",
              progname, fio.iodesc, fname, fmtstr(format));
    }
  }
 
#if defined(WIN32NATIVE)
  /* Open Raw Binary and ELF format in binary mode on Windows.*/
  if(format == FMT_RBIN || format == FMT_ELF)
  {
      if(fio.op == FIO_READ)
      {
          fio.mode = "rb";
      }
      if(fio.op == FIO_WRITE)
      {
          fio.mode = "wb";
      }
  }
#endif
 
  if (format != FMT_IMM) {
    if (!using_stdio) {
      f = fopen_and_seek(fname, fio.mode, section);
      if (f == NULL) {
        avrdude_message(MSG_INFO, "%s: can't open %s file %s: %s\n",
                progname, fio.iodesc, fname, strerror(errno));
        return -1;
      }
    }
  }
 
  switch (format) {
    case FMT_IHEX:
      rc = fileio_ihex(&fio, fname, f, mem, size);
      break;
 
    case FMT_SREC:
      rc = fileio_srec(&fio, fname, f, mem, size);
      break;
 
    case FMT_RBIN:
      rc = fileio_rbin(&fio, fname, f, mem, size);
      break;
 
    case FMT_ELF:
#ifdef HAVE_LIBELF
      rc = fileio_elf(&fio, fname, f, mem, p, size);
#else
      avrdude_message(MSG_INFO, "%s: can't handle ELF file %s, "
                      "ELF file support was not compiled in\n",
                      progname, fname);
      rc = -1;
#endif
      break;
 
    case FMT_IMM:
      rc = fileio_imm(&fio, fname, f, mem, size);
      break;
 
    case FMT_HEX:
    case FMT_DEC:
    case FMT_OCT:
    case FMT_BIN:
      rc = fileio_num(&fio, fname, f, mem, size, format);
      break;
 
    default:
      avrdude_message(MSG_INFO, "%s: invalid %s file format: %d\n",
              progname, fio.iodesc, format);
      return -1;
  }
 
  if (rc > 0) {
    if ((op == FIO_READ) && (strcasecmp(mem->desc, "flash") == 0 ||
                             strcasecmp(mem->desc, "application") == 0 ||
                             strcasecmp(mem->desc, "apptable") == 0 ||
                             strcasecmp(mem->desc, "boot") == 0)) {
      /*
       * if we are reading flash, just mark the size as being the
       * highest non-0xff byte
       */
      rc = avr_mem_hiaddr(mem);
    }
  }
  if (format != FMT_IMM && !using_stdio) {
    fclose(f);
  }
 
  return rc;
}

References avr_locate_mem(), avr_mem_hiaddr(), avrdude_message(), avrpart::desc, fileio_ihex(), fileio_imm(), fileio_num(), fileio_rbin(), fileio_setparms(), fileio_srec(), FIO_READ, FIO_WRITE, FMT_AUTO, fmt_autodetect(), FMT_BIN, FMT_DEC, FMT_ELF, FMT_HEX, FMT_IHEX, FMT_IMM, FMT_OCT, FMT_RBIN, FMT_SREC, fmtstr(), fopen_and_seek(), fioparms::iodesc, fioparms::mode, MSG_INFO, fioparms::op, progbuf, progname, quell_progress, and strcasecmp.

Referenced by do_op().

Here is the call graph for this function:

Here is the caller graph for this function:

fileio_ihex()

static int fileio_ihex ( struct fioparms *  fio, char *  filename, FILE *  f, AVRMEM *  mem, int  size  )

static

{
  int rc;
 
  switch (fio->op) {
    case FIO_WRITE:
      rc = b2ihex(mem->buf, size, 32, fio->fileoffset, filename, f);
      if (rc < 0) {
        return -1;
      }
      break;
 
    case FIO_READ:
      rc = ihex2b(filename, f, mem, size, fio->fileoffset);
      if (rc < 0)
        return -1;
      break;
 
    default:
      avrdude_message(MSG_INFO, "%s: invalid Intex Hex file I/O operation=%d\n",
              progname, fio->op);
      return -1;
      break;
  }
 
  return rc;
}

References avrdude_message(), b2ihex(), avrmem::buf, fioparms::fileoffset, FIO_READ, FIO_WRITE, ihex2b(), MSG_INFO, fioparms::op, and progname.

Referenced by fileio().

Here is the call graph for this function:

Here is the caller graph for this function:

fileio_imm()

static int fileio_imm ( struct fioparms *  fio, char *  filename, FILE *  f, AVRMEM *  mem, int  size  )

static

{
  int rc = 0;
  char * e, * p;
  unsigned long b;
  int loc;
 
  switch (fio->op) {
    case FIO_READ:
      loc = 0;
      p = strtok(filename, " ,");
      while (p != NULL && loc < size) {
        b = strtoul(p, &e, 0);
  /* check for binary formated (0b10101001) strings */
  b = (strncmp (p, "0b", 2))?
      strtoul (p, &e, 0):
      strtoul (p + 2, &e, 2);
        if (*e != 0) {
          avrdude_message(MSG_INFO, "%s: invalid byte value (%s) specified for immediate mode\n",
                          progname, p);
          return -1;
        }
        mem->buf[loc] = (char)b;
        mem->tags[loc++] = TAG_ALLOCATED;
        p = strtok(NULL, " ,");
        rc = loc;
      }
      break;
    default:
      avrdude_message(MSG_INFO, "%s: fileio: invalid operation=%d\n",
              progname, fio->op);
      return -1;
  }
 
  if (rc < 0 || (fio->op == FIO_WRITE && rc < size)) {
    avrdude_message(MSG_INFO, "%s: %s error %s %s: %s; %s %d of the expected %d bytes\n",
                    progname, fio->iodesc, fio->dir, filename, strerror(errno),
                    fio->rw, rc, size);
    return -1;
  }
 
  return rc;
}

References avrdude_message(), avrmem::buf, fioparms::dir, FIO_READ, FIO_WRITE, fioparms::iodesc, MSG_INFO, fioparms::op, progname, fioparms::rw, TAG_ALLOCATED, and avrmem::tags.

Referenced by fileio().

Here is the call graph for this function:

Here is the caller graph for this function:

fileio_num()

static int fileio_num ( struct fioparms *  fio, char *  filename, FILE *  f, AVRMEM *  mem, int  size, FILEFMT  fmt  )

static

{
  const char *prefix;
  char cbuf[20];
  int base, i, num;
 
  switch (fmt) {
    case FMT_HEX:
      prefix = "0x";
      base = 16;
      break;
 
    default:
    case FMT_DEC:
      prefix = "";
      base = 10;
      break;
 
    case FMT_OCT:
      prefix = "0";
      base = 8;
      break;
 
    case FMT_BIN:
      prefix = "0b";
      base = 2;
      break;
 
  }
 
  switch (fio->op) {
    case FIO_WRITE:
      break;
    default:
      avrdude_message(MSG_INFO, "%s: fileio: invalid operation=%d\n",
              progname, fio->op);
      return -1;
  }
 
  for (i = 0; i < size; i++) {
    if (i > 0) {
      if (putc(',', f) == EOF)
  goto writeerr;
    }
    num = (unsigned int)(mem->buf[i]);
    /*
     * For a base of 8 and a value < 8 to convert, don't write the
     * prefix.  The conversion will be indistinguishable from a
     * decimal one then.
     */
    if (prefix[0] != '\0' && !(base == 8 && num < 8)) {
      if (fputs(prefix, f) == EOF)
  goto writeerr;
    }
    itoa_simple(num, cbuf, base);
    if (fputs(cbuf, f) == EOF)
      goto writeerr;
  }
  if (putc('\n', f) == EOF)
    goto writeerr;
 
  return 0;
 
 writeerr:
  avrdude_message(MSG_INFO, "%s: error writing to %s: %s\n",
    progname, filename, strerror(errno));
  return -1;
}

References avrdude_message(), avrmem::buf, FIO_WRITE, FMT_BIN, FMT_DEC, FMT_HEX, FMT_OCT, itoa_simple(), MSG_INFO, fioparms::op, and progname.

Referenced by fileio().

Here is the call graph for this function:

Here is the caller graph for this function:

fileio_rbin()

static int fileio_rbin ( struct fioparms *  fio, char *  filename, FILE *  f, AVRMEM *  mem, int  size  )

static

{
  int rc;
  unsigned char *buf = mem->buf;
 
  switch (fio->op) {
    case FIO_READ:
      rc = (int)fread(buf, 1, size, f);
      if (rc > 0)
        memset(mem->tags, TAG_ALLOCATED, rc);
      break;
    case FIO_WRITE:
      rc = (int)fwrite(buf, 1, size, f);
      break;
    default:
      avrdude_message(MSG_INFO, "%s: fileio: invalid operation=%d\n",
              progname, fio->op);
      return -1;
  }
 
  if (rc < 0 || (fio->op == FIO_WRITE && rc < size)) {
    avrdude_message(MSG_INFO, "%s: %s error %s %s: %s; %s %d of the expected %d bytes\n",
                    progname, fio->iodesc, fio->dir, filename, strerror(errno),
                    fio->rw, rc, size);
    return -1;
  }
 
  return rc;
}

References avrdude_message(), avrmem::buf, fioparms::dir, FIO_READ, FIO_WRITE, fioparms::iodesc, MSG_INFO, fioparms::op, progname, fioparms::rw, TAG_ALLOCATED, and avrmem::tags.

Referenced by fileio().

Here is the call graph for this function:

Here is the caller graph for this function:

fileio_setparms()

int fileio_setparms	(	int	op,
		struct fioparms *	fp,
		struct avrpart *	p,
		AVRMEM *	m
	)

{
  fp->op = op;
 
  switch (op) {
    case FIO_READ:
      fp->mode   = "r";
      fp->iodesc = "input";
      fp->dir    = "from";
      fp->rw     = "read";
      break;
 
    case FIO_WRITE:
      fp->mode   = "w";
      fp->iodesc = "output";
      fp->dir    = "to";
      fp->rw     = "wrote";
      break;
 
    default:
      avrdude_message(MSG_INFO, "%s: invalid I/O operation %d\n",
              progname, op);
      return -1;
      break;
  }
 
  /*
   * AVR32 devices maintain their load offset within the file itself,
   * but AVRDUDE maintains all memory images 0-based.
   */
  if ((p->flags & AVRPART_AVR32) != 0)
  {
    fp->fileoffset = m->offset;
  }
  else
  {
    fp->fileoffset = 0;
  }
 
  return 0;
}

References avrdude_message(), AVRPART_AVR32, fioparms::dir, fioparms::fileoffset, FIO_READ, FIO_WRITE, avrpart::flags, fioparms::iodesc, fioparms::mode, MSG_INFO, avrmem::offset, fioparms::op, progname, and fioparms::rw.

Referenced by fileio().

Here is the call graph for this function:

Here is the caller graph for this function:

fileio_srec()

static int fileio_srec ( struct fioparms *  fio, char *  filename, FILE *  f, AVRMEM *  mem, int  size  )

static

{
  int rc;
 
  switch (fio->op) {
    case FIO_WRITE:
      rc = b2srec(mem->buf, size, 32, fio->fileoffset, filename, f);
      if (rc < 0) {
        return -1;
      }
      break;
 
    case FIO_READ:
      rc = srec2b(filename, f, mem, size, fio->fileoffset);
      if (rc < 0)
        return -1;
      break;
 
    default:
      avrdude_message(MSG_INFO, "%s: ERROR: invalid Motorola S-Records file I/O "
              "operation=%d\n",
              progname, fio->op);
      return -1;
      break;
  }
 
  return rc;
}

References avrdude_message(), b2srec(), avrmem::buf, fioparms::fileoffset, FIO_READ, FIO_WRITE, MSG_INFO, fioparms::op, progname, and srec2b().

Referenced by fileio().

Here is the call graph for this function:

Here is the caller graph for this function:

fmt_autodetect()

static int fmt_autodetect ( char *  fname, unsigned  section  )

static

{
  FILE * f;
  unsigned char buf[MAX_LINE_LEN];
  int i;
  int len;
  int found;
  int first = 1;
 
#if defined(WIN32NATIVE)
  f = fopen_and_seek(fname, "r", section);
#else
  f = fopen_and_seek(fname, "rb", section);
#endif
 
  if (f == NULL) {
    avrdude_message(MSG_INFO, "%s: error opening %s: %s\n",
            progname, fname, strerror(errno));
    return -1;
  }
 
  while (fgets((char *)buf, MAX_LINE_LEN, f)!=NULL) {
    /* check for ELF file */
    if (first &&
        (buf[0] == 0177 && buf[1] == 'E' &&
         buf[2] == 'L' && buf[3] == 'F')) {
      fclose(f);
      return FMT_ELF;
    }
 
    buf[MAX_LINE_LEN-1] = 0;
    len = (int)strlen((char *)buf);
    if (buf[len-1] == '\n')
      buf[--len] = 0;
 
    /* check for binary data */
    found = 0;
    for (i=0; i<len; i++) {
      if (buf[i] > 127) {
        found = 1;
        break;
      }
    }
    if (found) {
      fclose(f);
      return FMT_RBIN;
    }
 
    /* check for lines that look like intel hex */
    if ((buf[0] == ':') && (len >= 11)) {
      found = 1;
      for (i=1; i<len; i++) {
        if (!isxdigit(buf[1])) {
          found = 0;
          break;
        }
      }
      if (found) {
        fclose(f);
        return FMT_IHEX;
      }
    }
 
    /* check for lines that look like motorola s-record */
    if ((buf[0] == 'S') && (len >= 10) && isdigit(buf[1])) {
      found = 1;
      for (i=1; i<len; i++) {
        if (!isxdigit(buf[1])) {
          found = 0;
          break;
        }
      }
      if (found) {
        fclose(f);
        return FMT_SREC;
      }
    }
 
    first = 0;
  }
 
  fclose(f);
  return -1;
}

References avrdude_message(), FMT_ELF, FMT_IHEX, FMT_RBIN, FMT_SREC, fopen_and_seek(), MAX_LINE_LEN, MSG_INFO, and progname.

Referenced by fileio().

Here is the call graph for this function:

Here is the caller graph for this function:

fmtstr()

char * fmtstr

(

FILEFMT

format

)

{
  switch (format) {
    case FMT_AUTO : return "auto-detect"; break;
    case FMT_SREC : return "Motorola S-Record"; break;
    case FMT_IHEX : return "Intel Hex"; break;
    case FMT_RBIN : return "raw binary"; break;
    case FMT_ELF  : return "ELF"; break;
    default       : return "invalid format"; break;
  };
}

References FMT_AUTO, FMT_ELF, FMT_IHEX, FMT_RBIN, and FMT_SREC.

Referenced by fileio(), Slic3r::Utils::anonymous_namespace{Time.cpp}::process_format(), Slic3r::Utils::str2time(), and Slic3r::Utils::time2str().

Here is the caller graph for this function:

fopen_and_seek()

static FILE * fopen_and_seek ( const char *  filename, const char *  mode, unsigned  section  )

static

{
  FILE *file = fopen_utf8(filename, mode);
 
  if (file == NULL) {
    return NULL;
  }
 
  // Seek to the specified 'section'
  static const char *hex_terminator = ":00000001FF\r";
  unsigned terms_seen = 0;
  char buffer[MAX_LINE_LEN + 1];
 
  while (terms_seen < section && fgets(buffer, MAX_LINE_LEN, file) != NULL) {
    size_t len = strlen(buffer);
 
    if (buffer[len - 1] == '\n') {
      len--;
      buffer[len] = 0;
    }
    if (buffer[len - 1] != '\r') {
      buffer[len] = '\r';
      len++;
      buffer[len] = 0;
    }
 
    if (strcmp(buffer, hex_terminator) == 0) {
      // Found a section terminator
      terms_seen++;
    }
  }
 
  if (feof(file)) {
    // Section not found
    fclose(file);
    return NULL;
  }
 
  return file;
}

References fopen_utf8(), and MAX_LINE_LEN.

Referenced by fileio(), and fmt_autodetect().

Here is the call graph for this function:

Here is the caller graph for this function:

fopen_utf8()

FILE * fopen_utf8	(	const char *	filename,
		const char *	mode
	)

{
  // On Windows we need to convert the filename to UTF-16
#if defined(WIN32NATIVE)
  static wchar_t fname_buffer[PATH_MAX];
  static wchar_t mode_buffer[MAX_MODE_LEN];
 
  if (MultiByteToWideChar(CP_UTF8, 0, filename, -1, fname_buffer, PATH_MAX) == 0) { return NULL; }
  if (MultiByteToWideChar(CP_UTF8, 0, mode, -1, mode_buffer, MAX_MODE_LEN) == 0) { return NULL; }
 
  return _wfopen(fname_buffer, mode_buffer);
#else
  return fopen(filename, mode);
#endif
}

References MAX_MODE_LEN, and PATH_MAX.

Referenced by fopen_and_seek(), and read_config().

Here is the caller graph for this function:

ihex2b()

static int ihex2b ( char *  infile, FILE *  inf, AVRMEM *  mem, int  bufsize, unsigned int  fileoffset  )

static

{
  char buffer [ MAX_LINE_LEN ];
  unsigned int nextaddr, baseaddr, maxaddr;
  int i;
  int lineno;
  int len;
  struct ihexrec ihex;
  int rc;
 
  lineno   = 0;
  baseaddr = 0;
  maxaddr  = 0;
  nextaddr = 0;
 
  while (fgets((char *)buffer,MAX_LINE_LEN,inf)!=NULL) {
    lineno++;
    len = (int)strlen(buffer);
    if (buffer[len-1] == '\n') 
      buffer[--len] = 0;
    if (buffer[0] != ':')
      continue;
    rc = ihex_readrec(&ihex, buffer);
    if (rc < 0) {
      avrdude_message(MSG_INFO, "%s: invalid record at line %d of \"%s\"\n",
              progname, lineno, infile);
      return -1;
    }
    else if (rc != ihex.cksum) {
      avrdude_message(MSG_INFO, "%s: ERROR: checksum mismatch at line %d of \"%s\"\n",
              progname, lineno, infile);
      avrdude_message(MSG_INFO, "%s: checksum=0x%02x, computed checksum=0x%02x\n",
              progname, ihex.cksum, rc);
      return -1;
    }
 
    switch (ihex.rectyp) {
      case 0: /* data record */
        if (fileoffset != 0 && baseaddr < fileoffset) {
          avrdude_message(MSG_INFO, "%s: ERROR: address 0x%04x out of range (below fileoffset 0x%x) at line %d of %s\n",
                          progname, baseaddr, fileoffset, lineno, infile);
          return -1;
        }
        nextaddr = ihex.loadofs + baseaddr - fileoffset;
        if (nextaddr + ihex.reclen > (unsigned)bufsize) {
          avrdude_message(MSG_INFO, "%s: ERROR: address 0x%04x out of range at line %d of %s\n",
                          progname, nextaddr+ihex.reclen, lineno, infile);
          return -1;
        }
        for (i=0; i<ihex.reclen; i++) {
          mem->buf[nextaddr+i] = ihex.data[i];
          mem->tags[nextaddr+i] = TAG_ALLOCATED;
        }
        if (nextaddr+ihex.reclen > maxaddr)
          maxaddr = nextaddr+ihex.reclen;
        break;
 
      case 1: /* end of file record */
        return maxaddr;
        break;
 
      case 2: /* extended segment address record */
        baseaddr = (ihex.data[0] << 8 | ihex.data[1]) << 4;
        break;
 
      case 3: /* start segment address record */
        /* we don't do anything with the start address */
        break;
 
      case 4: /* extended linear address record */
        baseaddr = (ihex.data[0] << 8 | ihex.data[1]) << 16;
        break;
 
      case 5: /* start linear address record */
        /* we don't do anything with the start address */
        break;
 
      default:
        avrdude_message(MSG_INFO, "%s: don't know how to deal with rectype=%d "
                        "at line %d of %s\n",
                        progname, ihex.rectyp, lineno, infile);
        return -1;
        break;
    }
 
  } /* while */
 
  if (maxaddr == 0) {
    avrdude_message(MSG_INFO, "%s: ERROR: No valid record found in Intel Hex "
                    "file \"%s\"\n",
                    progname, infile);
 
    return -1;
  }
  else {
    avrdude_message(MSG_INFO, "%s: WARNING: no end of file record found for Intel Hex "
                    "file \"%s\"\n",
                    progname, infile);
 
    return maxaddr;
  }
}

References avrdude_message(), avrmem::buf, ihexrec::cksum, ihexrec::data, ihex_readrec(), infile, lineno, ihexrec::loadofs, MAX_LINE_LEN, MSG_INFO, progname, ihexrec::reclen, ihexrec::rectyp, TAG_ALLOCATED, and avrmem::tags.

Referenced by fileio_ihex().

Here is the call graph for this function:

Here is the caller graph for this function:

ihex_readrec()

static int ihex_readrec ( struct ihexrec *  ihex, char *  rec  )

static

{
  int i, j;
  char buf[8];
  int offset, len;
  char * e;
  unsigned char cksum;
  int rc;
 
  len    = (int)strlen(rec);
  offset = 1;
  cksum  = 0;
 
  /* reclen */
  if (offset + 2 > len)
    return -1;
  for (i=0; i<2; i++)
    buf[i] = rec[offset++];
  buf[i] = 0;
  ihex->reclen = (unsigned char)strtoul(buf, &e, 16);
  if (e == buf || *e != 0)
    return -1;
 
  /* load offset */
  if (offset + 4 > len)
    return -1;
  for (i=0; i<4; i++)
    buf[i] = rec[offset++];
  buf[i] = 0;
  ihex->loadofs = strtoul(buf, &e, 16);
  if (e == buf || *e != 0)
    return -1;
 
  /* record type */
  if (offset + 2 > len)
    return -1;
  for (i=0; i<2; i++)
    buf[i] = rec[offset++];
  buf[i] = 0;
  ihex->rectyp = (unsigned char)strtoul(buf, &e, 16);
  if (e == buf || *e != 0)
    return -1;
 
  cksum = ihex->reclen + ((ihex->loadofs >> 8) & 0x0ff) + 
    (ihex->loadofs & 0x0ff) + ihex->rectyp;
 
  /* data */
  for (j=0; j<ihex->reclen; j++) {
    if (offset + 2 > len)
      return -1;
    for (i=0; i<2; i++)
      buf[i] = rec[offset++];
    buf[i] = 0;
    ihex->data[j] = (char)strtoul(buf, &e, 16);
    if (e == buf || *e != 0)
      return -1;
    cksum += ihex->data[j];
  }
 
  /* cksum */
  if (offset + 2 > len)
    return -1;
  for (i=0; i<2; i++)
    buf[i] = rec[offset++];
  buf[i] = 0;
  ihex->cksum = (char)strtoul(buf, &e, 16);
  if (e == buf || *e != 0)
    return -1;
 
  rc = -cksum & 0x000000ff;
 
  return rc;
}

References ihexrec::cksum, ihexrec::data, ihexrec::loadofs, ihexrec::reclen, and ihexrec::rectyp.

Referenced by ihex2b().

Here is the caller graph for this function:

itoa_simple()

static char * itoa_simple ( int  n, char *  buf, int  base  )

static

{
  div_t q;
  char c, *cp, *cp2;
 
  cp = buf;
  /*
   * Divide by base until the number disappeared, but ensure at least
   * one digit will be emitted.
   */
  do {
    q = div(n, base);
    n = q.quot;
    if (q.rem >= 10)
      c = q.rem - 10 + 'a';
    else
      c = q.rem + '0';
    *cp++ = c;
  } while (q.quot != 0);
 
  /* Terminate the string. */
  *cp-- = '\0';
 
  /* Now revert the result string. */
  cp2 = buf;
  while (cp > cp2) {
    c = *cp;
    *cp-- = *cp2;
    *cp2++ = c;
  }
 
  return buf;
}

Referenced by fileio_num().

Here is the caller graph for this function:

srec2b()

static int srec2b ( char *  infile, FILE *  inf, AVRMEM *  mem, int  bufsize, unsigned int  fileoffset  )

static

{
  char buffer [ MAX_LINE_LEN ];
  unsigned int nextaddr, maxaddr;
  int i;
  int lineno;
  int len;
  struct ihexrec srec;
  int rc;
  int reccount;
  unsigned char datarec;
 
  char * msg = 0;
 
  lineno   = 0;
  maxaddr  = 0;
  reccount = 0;
 
  while (fgets((char *)buffer,MAX_LINE_LEN,inf)!=NULL) {
    lineno++;
    len = (int)strlen(buffer);
    if (buffer[len-1] == '\n') 
      buffer[--len] = 0;
    if (buffer[0] != 0x53)
      continue;
    rc = srec_readrec(&srec, buffer);
 
    if (rc < 0) {
      avrdude_message(MSG_INFO, "%s: ERROR: invalid record at line %d of \"%s\"\n",
              progname, lineno, infile);
      return -1;
    }
    else if (rc != srec.cksum) {
      avrdude_message(MSG_INFO, "%s: ERROR: checksum mismatch at line %d of \"%s\"\n",
              progname, lineno, infile);
      avrdude_message(MSG_INFO, "%s: checksum=0x%02x, computed checksum=0x%02x\n",
              progname, srec.cksum, rc);
      return -1;
    }
 
    datarec=0; 
    switch (srec.rectyp) {
      case 0x30: /* S0 - header record*/
        /* skip */
        break;
 
      case 0x31: /* S1 - 16 bit address data record */
        datarec=1;
        msg="%s: ERROR: address 0x%04x out of range %sat line %d of %s\n";
        break;
 
      case 0x32: /* S2 - 24 bit address data record */
        datarec=1;
        msg="%s: ERROR: address 0x%06x out of range %sat line %d of %s\n";
        break;
 
      case 0x33: /* S3 - 32 bit address data record */
        datarec=1;
        msg="%s: ERROR: address 0x%08x out of range %sat line %d of %s\n";
        break;
 
      case 0x34: /* S4 - symbol record (LSI extension) */
        avrdude_message(MSG_INFO, "%s: ERROR: not supported record at line %d of %s\n",
                        progname, lineno, infile);
        return -1;
 
      case 0x35: /* S5 - count of S1,S2 and S3 records previously tx'd */
        if (srec.loadofs != reccount){
          avrdude_message(MSG_INFO, "%s: ERROR: count of transmitted data records mismatch "
                          "at line %d of \"%s\"\n",
                          progname, lineno, infile);
          avrdude_message(MSG_INFO, "%s: transmitted data records= %d, expected "
                  "value= %d\n",
                  progname, reccount, srec.loadofs);
          return -1;
        }
        break;
 
      case 0x37: /* S7 Record - end record for 32 bit address data */
      case 0x38: /* S8 Record - end record for 24 bit address data */
      case 0x39: /* S9 Record - end record for 16 bit address data */
        return maxaddr;
 
      default:
        avrdude_message(MSG_INFO, "%s: ERROR: don't know how to deal with rectype S%d "
                        "at line %d of %s\n",
                        progname, srec.rectyp, lineno, infile);
        return -1;
    }
 
    if (datarec == 1) {
      nextaddr = srec.loadofs;
      if (nextaddr < fileoffset) {
        avrdude_message(MSG_INFO, msg, progname, nextaddr,
                "(below fileoffset) ",
                lineno, infile);
        return -1;
      }
      nextaddr -= fileoffset;
      if (nextaddr + srec.reclen > (unsigned)bufsize) {
        avrdude_message(MSG_INFO, msg, progname, nextaddr+srec.reclen, "",
                lineno, infile);
        return -1;
      }
      for (i=0; i<srec.reclen; i++) {
        mem->buf[nextaddr+i] = srec.data[i];
        mem->tags[nextaddr+i] = TAG_ALLOCATED;
      }
      if (nextaddr+srec.reclen > maxaddr)
        maxaddr = nextaddr+srec.reclen;
      reccount++;
    }
 
  }
 
  avrdude_message(MSG_INFO, "%s: WARNING: no end of file record found for Motorola S-Records "
                  "file \"%s\"\n",
                  progname, infile);
 
  return maxaddr;
}

References avrdude_message(), avrmem::buf, ihexrec::cksum, ihexrec::data, infile, lineno, ihexrec::loadofs, MAX_LINE_LEN, MSG_INFO, progname, ihexrec::reclen, ihexrec::rectyp, srec_readrec(), TAG_ALLOCATED, and avrmem::tags.

Referenced by fileio_srec().

Here is the call graph for this function:

Here is the caller graph for this function:

srec_readrec()

static int srec_readrec ( struct ihexrec *  srec, char *  rec  )

static

{
  int i, j;
  char buf[8];
  int offset, len, addr_width;
  char * e;
  unsigned char cksum;
  int rc;
 
  len = (int)strlen(rec);
  offset = 1;
  cksum = 0;
  addr_width = 2;
 
  /* record type */
  if (offset + 1 > len) 
    return -1;
  srec->rectyp = rec[offset++];
  if (srec->rectyp == 0x32 || srec->rectyp == 0x38) 
    addr_width = 3; /* S2,S8-record */
  else if (srec->rectyp == 0x33 || srec->rectyp == 0x37) 
    addr_width = 4; /* S3,S7-record */
 
  /* reclen */
  if (offset + 2 > len) 
    return -1;
  for (i=0; i<2; i++) 
    buf[i] = rec[offset++];
  buf[i] = 0;
  srec->reclen = (char)strtoul(buf, &e, 16);
  cksum += srec->reclen;
  srec->reclen -= (addr_width+1);
  if (e == buf || *e != 0) 
    return -1;
 
  /* load offset */
  if (offset + addr_width > len) 
    return -1;
  for (i=0; i<addr_width*2; i++) 
    buf[i] = rec[offset++];
  buf[i] = 0;
  srec->loadofs = strtoul(buf, &e, 16);
  if (e == buf || *e != 0) 
    return -1;
 
  for (i=addr_width; i>0; i--)
    cksum += (srec->loadofs >> (i - 1) * 8) & 0xff;
 
  /* data */
  for (j=0; j<srec->reclen; j++) {
    if (offset+2  > len) 
      return -1;
    for (i=0; i<2; i++) 
      buf[i] = rec[offset++];
    buf[i] = 0;
    srec->data[j] = (char)strtoul(buf, &e, 16);
    if (e == buf || *e != 0) 
      return -1;
    cksum += srec->data[j];
  }
 
  /* cksum */
  if (offset + 2 > len) 
    return -1;
  for (i=0; i<2; i++) 
    buf[i] = rec[offset++];
  buf[i] = 0;
  srec->cksum = (char)strtoul(buf, &e, 16);
  if (e == buf || *e != 0) 
    return -1;
 
  rc = 0xff - cksum;
  return rc;
}

References ihexrec::cksum, ihexrec::data, ihexrec::loadofs, ihexrec::reclen, and ihexrec::rectyp.

Referenced by srec2b().

Here is the caller graph for this function: