gdb/common/rsp-low.c

   1 /* Low-level RSP routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 1988-2016 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "common-defs.h"
  21 #include "rsp-low.h"
  22
  23 /* See rsp-low.h.  */
  24
  25 int
  26 fromhex (int a)
  27 {
  28   if (a >= '0' && a <= '9')
  29     return a - '0';
  30   else if (a >= 'a' && a <= 'f')
  31     return a - 'a' + 10;
  32   else if (a >= 'A' && a <= 'F')
  33     return a - 'A' + 10;
  34   else
  35     error (_("Reply contains invalid hex digit %d"), a);
  36 }
  37
  38 /* See rsp-low.h.  */
  39
  40 int
  41 tohex (int nib)
  42 {
  43   if (nib < 10)
  44     return '0' + nib;
  45   else
  46     return 'a' + nib - 10;
  47 }
  48
  49 /* Encode 64 bits in 16 chars of hex.  */
  50
  51 static const char hexchars[] = "0123456789abcdef";
  52
  53 static int
  54 ishex (int ch, int *val)
  55 {
  56   if ((ch >= 'a') && (ch <= 'f'))
  57     {
  58       *val = ch - 'a' + 10;
  59       return 1;
  60     }
  61   if ((ch >= 'A') && (ch <= 'F'))
  62     {
  63       *val = ch - 'A' + 10;
  64       return 1;
  65     }
  66   if ((ch >= '0') && (ch <= '9'))
  67     {
  68       *val = ch - '0';
  69       return 1;
  70     }
  71   return 0;
  72 }
  73
  74 /* See rsp-low.h.  */
  75
  76 char *
  77 pack_nibble (char *buf, int nibble)
  78 {
  79   *buf++ = hexchars[(nibble & 0x0f)];
  80   return buf;
  81 }
  82
  83 /* See rsp-low.h.  */
  84
  85 char *
  86 pack_hex_byte (char *pkt, int byte)
  87 {
  88   *pkt++ = hexchars[(byte >> 4) & 0xf];
  89   *pkt++ = hexchars[(byte & 0xf)];
  90   return pkt;
  91 }
  92
  93 /* See rsp-low.h.  */
  94
  95 char *
  96 unpack_varlen_hex (char *buff,  /* packet to parse */
  97                    ULONGEST *result)
  98 {
  99   int nibble;
 100   ULONGEST retval = 0;
 101
 102   while (ishex (*buff, &nibble))
 103     {
 104       buff++;
 105       retval = retval << 4;
 106       retval |= nibble & 0x0f;
 107     }
 108   *result = retval;
 109   return buff;
 110 }
 111
 112 /* See rsp-low.h.  */
 113
 114 int
 115 hex2bin (const char *hex, gdb_byte *bin, int count)
 116 {
 117   int i;
 118
 119   for (i = 0; i < count; i++)
 120     {
 121       if (hex[0] == 0 || hex[1] == 0)
 122         {
 123           /* Hex string is short, or of uneven length.
 124              Return the count that has been converted so far.  */
 125           return i;
 126         }
 127       *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
 128       hex += 2;
 129     }
 130   return i;
 131 }
 132
 133 /* See rsp-low.h.  */
 134
 135 int
 136 bin2hex (const gdb_byte *bin, char *hex, int count)
 137 {
 138   int i;
 139
 140   for (i = 0; i < count; i++)
 141     {
 142       *hex++ = tohex ((*bin >> 4) & 0xf);
 143       *hex++ = tohex (*bin++ & 0xf);
 144     }
 145   *hex = 0;
 146   return i;
 147 }
 148
 149 /* Return whether byte B needs escaping when sent as part of binary data.  */
 150
 151 static int
 152 needs_escaping (gdb_byte b)
 153 {
 154   return b == '$' || b == '#' || b == '}' || b == '*';
 155 }
 156
 157 /* See rsp-low.h.  */
 158
 159 int
 160 remote_escape_output (const gdb_byte *buffer, int len_units, int unit_size,
 161                       gdb_byte *out_buf, int *out_len_units,
 162                       int out_maxlen_bytes)
 163 {
 164   int input_unit_index, output_byte_index = 0, byte_index_in_unit;
 165   int number_escape_bytes_needed;
 166
 167   /* Try to copy integral addressable memory units until
 168      (1) we run out of space or
 169      (2) we copied all of them.  */
 170   for (input_unit_index = 0;
 171        input_unit_index < len_units;
 172        input_unit_index++)
 173     {
 174       /* Find out how many escape bytes we need for this unit.  */
 175       number_escape_bytes_needed = 0;
 176       for (byte_index_in_unit = 0;
 177            byte_index_in_unit < unit_size;
 178            byte_index_in_unit++)
 179         {
 180           int idx = input_unit_index * unit_size + byte_index_in_unit;
 181           gdb_byte b = buffer[idx];
 182           if (needs_escaping (b))
 183             number_escape_bytes_needed++;
 184         }
 185
 186       /* Check if we have room to fit this escaped unit.  */
 187       if (output_byte_index + unit_size + number_escape_bytes_needed >
 188             out_maxlen_bytes)
 189           break;
 190
 191       /* Copy the unit byte per byte, adding escapes.  */
 192       for (byte_index_in_unit = 0;
 193            byte_index_in_unit < unit_size;
 194            byte_index_in_unit++)
 195         {
 196           int idx = input_unit_index * unit_size + byte_index_in_unit;
 197           gdb_byte b = buffer[idx];
 198           if (needs_escaping (b))
 199             {
 200               out_buf[output_byte_index++] = '}';
 201               out_buf[output_byte_index++] = b ^ 0x20;
 202             }
 203           else
 204             out_buf[output_byte_index++] = b;
 205         }
 206     }
 207
 208   *out_len_units = input_unit_index;
 209   return output_byte_index;
 210 }
 211
 212 /* See rsp-low.h.  */
 213
 214 int
 215 remote_unescape_input (const gdb_byte *buffer, int len,
 216                        gdb_byte *out_buf, int out_maxlen)
 217 {
 218   int input_index, output_index;
 219   int escaped;
 220
 221   output_index = 0;
 222   escaped = 0;
 223   for (input_index = 0; input_index < len; input_index++)
 224     {
 225       gdb_byte b = buffer[input_index];
 226
 227       if (output_index + 1 > out_maxlen)
 228         error (_("Received too much data from the target."));
 229
 230       if (escaped)
 231         {
 232           out_buf[output_index++] = b ^ 0x20;
 233           escaped = 0;
 234         }
 235       else if (b == '}')
 236         escaped = 1;
 237       else
 238         out_buf[output_index++] = b;
 239     }
 240
 241   if (escaped)
 242     error (_("Unmatched escape character in target response."));
 243
 244   return output_index;
 245 }
 246