1 /* Low-level RSP routines for GDB, the GNU debugger.
3 Copyright (C) 1988-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
20 #include "common-defs.h"
28 if (a >= '0' && a <= '9')
30 else if (a >= 'a' && a <= 'f')
32 else if (a >= 'A' && a <= 'F')
35 error (_("Reply contains invalid hex digit %d"), a);
46 return 'a' + nib - 10;
49 /* Encode 64 bits in 16 chars of hex. */
51 static const char hexchars[] = "0123456789abcdef";
54 ishex (int ch, int *val)
56 if ((ch >= 'a') && (ch <= 'f'))
61 if ((ch >= 'A') && (ch <= 'F'))
66 if ((ch >= '0') && (ch <= '9'))
77 pack_nibble (char *buf, int nibble)
79 *buf++ = hexchars[(nibble & 0x0f)];
86 pack_hex_byte (char *pkt, int byte)
88 *pkt++ = hexchars[(byte >> 4) & 0xf];
89 *pkt++ = hexchars[(byte & 0xf)];
96 unpack_varlen_hex (char *buff, /* packet to parse */
102 while (ishex (*buff, &nibble))
105 retval = retval << 4;
106 retval |= nibble & 0x0f;
115 hex2bin (const char *hex, gdb_byte *bin, int count)
119 for (i = 0; i < count; i++)
121 if (hex[0] == 0 || hex[1] == 0)
123 /* Hex string is short, or of uneven length.
124 Return the count that has been converted so far. */
127 *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
136 bin2hex (const gdb_byte *bin, char *hex, int count)
140 for (i = 0; i < count; i++)
142 *hex++ = tohex ((*bin >> 4) & 0xf);
143 *hex++ = tohex (*bin++ & 0xf);
149 /* Return whether byte B needs escaping when sent as part of binary data. */
152 needs_escaping (gdb_byte b)
154 return b == '$' || b == '#' || b == '}' || b == '*';
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)
164 int input_unit_index, output_byte_index = 0, byte_index_in_unit;
165 int number_escape_bytes_needed;
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;
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++)
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++;
186 /* Check if we have room to fit this escaped unit. */
187 if (output_byte_index + unit_size + number_escape_bytes_needed >
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++)
196 int idx = input_unit_index * unit_size + byte_index_in_unit;
197 gdb_byte b = buffer[idx];
198 if (needs_escaping (b))
200 out_buf[output_byte_index++] = '}';
201 out_buf[output_byte_index++] = b ^ 0x20;
204 out_buf[output_byte_index++] = b;
208 *out_len_units = input_unit_index;
209 return output_byte_index;
215 remote_unescape_input (const gdb_byte *buffer, int len,
216 gdb_byte *out_buf, int out_maxlen)
218 int input_index, output_index;
223 for (input_index = 0; input_index < len; input_index++)
225 gdb_byte b = buffer[input_index];
227 if (output_index + 1 > out_maxlen)
228 error (_("Received too much data from the target."));
232 out_buf[output_index++] = b ^ 0x20;
238 out_buf[output_index++] = b;
242 error (_("Unmatched escape character in target response."));