Subversion Repositories or1k

/* XMODEM support for GDB, the GNU debugger.

   Copyright 1995, 2000, 2001 Free Software Foundation, Inc.

   This file is part of GDB.

   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., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.  */

#include "defs.h"

#include "serial.h"

#include "target.h"

#include "xmodem.h"

/* These definitions are for xmodem protocol. */

#define SOH     0x01

#define STX     0x02

#define ACK     0x06

#define NAK     0x15

#define EOT     0x04

#define CANCEL  0x18

static int blknum;              /* XMODEM block number */

static int crcflag;             /* Sez we are using CRC's instead of cksums */

static int

readchar (serial_t desc, int timeout)

{

  int c;

  c = SERIAL_READCHAR (desc, timeout);

  if (remote_debug > 0)

    fputc_unfiltered (c, gdb_stdlog);

  if (c >= 0)

    return c;

  if (c == SERIAL_TIMEOUT)

    error ("Timeout reading from remote system.");

  perror_with_name ("xmodem.c:readchar()");

}

#define CRC16 0x1021            /* Generator polynomial (X^16 + X^12 + X^5 + 1) */

static unsigned short *crctab;

/* Call this to init the fast CRC-16 calculation table.  */

static void

crcinit (void)

{

  static int crctab_inited = 0;

  int val;

  if (crctab_inited == 1)

    return;

  crctab = xmalloc (256 * sizeof (short));

  for (val = 0; val <= 255; val++)

    {

      int i;

      unsigned int crc;

      crc = val << 8;

      for (i = 0; i < 8; ++i)

        {

          crc <<= 1;

          if (crc & 0x10000)

            crc ^= CRC16;

        }

      crctab[val] = crc;

    }

  crctab_inited = 1;

}

/* Calculate a CRC-16 for the LEN byte message pointed at by P.  */

static unsigned short

docrc (unsigned char *p, int len)

{

  unsigned short crc = 0;

  while (len-- > 0)

    crc = (crc << 8) ^ crctab[(crc >> 8) ^ *p++];

  return crc;

}

/* Start up the transmit process.  Reset state variables.  Wait for receiver to

   send NAK or CRC request.  */

int

xmodem_init_xfer (serial_t desc)

{

  int c;

  int i;

  blknum = 1;

  crcflag = 0;

  crcinit ();

  for (i = 1; i <= 10; i++)

    {

      c = readchar (desc, 6);

      switch (c)

        {

        case 'C':

          crcflag = 1;

        case NAK:

          return 0;

        default:

          fprintf_unfiltered (gdb_stderr, "xmodem_init_xfer: Got unexpected character %c (0%o)\n", c, c);

          continue;

        case CANCEL:            /* target aborted load */

          fprintf_unfiltered (gdb_stderr, "Got a CANCEL from the target.\n");

          continue;

        }

    }

  error ("xmodem_init_xfer:  Too many unexpected characters.");

}

/* Take 128 bytes of data and make a packet out of it.

 *      Each packet looks like this:

 *      +-----+-------+-------+------+-----+

 *      | SOH | Seq1. | Seq2. | data | SUM |

 *      +-----+-------+-------+------+-----+

 *      SOH  = 0x01

 *      Seq1 = The sequence number.

 *      Seq2 = The complement of the sequence number.

 *      Data = A 128 bytes of data.

 *      SUM  = Add the contents of the 128 bytes and use the low-order

 *             8 bits of the result.

 *

 * send_xmodem_packet fills in the XMODEM fields of PACKET and sends it to the

 * remote system.  PACKET must be XMODEM_PACKETSIZE bytes long.  The data must

 * start 3 bytes after the beginning of the packet to leave room for the

 * XMODEM header.  LEN is the length of the data portion of the packet (and

 * must be <= 128 bytes).  If it is < 128 bytes, ^Z padding will be added.

 */

void

xmodem_send_packet (serial_t desc, unsigned char *packet, int len, int hashmark)

{

  int i;

  int retries;

  int pktlen;

  int datasize;

  /* build the packet header */

  packet[1] = blknum;

  packet[2] = ~blknum;

  blknum++;

  if (len <= XMODEM_DATASIZE)

    {

      packet[0] = SOH;

      datasize = XMODEM_DATASIZE;

    }

  else if (len <= XMODEM_1KDATASIZE)

    {

      packet[0] = STX;

      datasize = XMODEM_1KDATASIZE;

    }

  else

    internal_error (__FILE__, __LINE__, "failed internal consistency check");                   /* Packet way too large */

  /* Add ^Z padding if packet < 128 (or 1024) bytes */

  memset (packet + 3 + len, '\026', datasize - len);

  if (crcflag)

    {

      int crc;

      crc = docrc (packet + 3, datasize);

      packet[3 + datasize] = crc >> 8;

      packet[3 + datasize + 1] = crc;

      pktlen = datasize + 5;

    }

  else

    {

      int sum;

      sum = 0;

      for (i = 3; i < datasize + 3; i++)

        sum += packet[i];

      packet[3 + datasize] = sum;       /* add the checksum */

      pktlen = datasize + 4;

    }

  for (retries = 3; retries >= 0; retries--)

    {

      int c;

      SERIAL_WRITE (desc, packet, pktlen);

      c = readchar (desc, 3);

      switch (c)

        {

        case ACK:

          return;

        case NAK:

          if (!hashmark)

            continue;

          putchar_unfiltered ('-');

          gdb_flush (gdb_stdout);

          continue;

        case CANCEL:

          error ("xmodem_send_packet: Transfer aborted by receiver.");

        default:

          fprintf_unfiltered (gdb_stderr, "xmodem_send_packet: Got unexpected character %c (0%o)\n", c, c);

          continue;

        }

    }

  SERIAL_WRITE (desc, "\004", 1);       /* Send an EOT */

  error ("xmodem_send_packet:  Excessive retries.");

}

/* Finish off the transfer.  Send out the EOT, and wait for an ACK.  */

void

xmodem_finish_xfer (serial_t desc)

{

  int retries;

  for (retries = 10; retries >= 0; retries--)

    {

      int c;

      SERIAL_WRITE (desc, "\004", 1);   /* Send an EOT */

      c = readchar (desc, 3);

      switch (c)

        {

        case ACK:

          return;

        case NAK:

          continue;

        case CANCEL:

          error ("xmodem_finish_xfer: Transfer aborted by receiver.");

        default:

          fprintf_unfiltered (gdb_stderr, "xmodem_send_packet: Got unexpected character %c (0%o)\n", c, c);

          continue;

        }

    }

  error ("xmodem_finish_xfer:  Excessive retries.");

}