GDBserver
rsp-low.c
Go to the documentation of this file.
1 /* Low-level RSP routines for GDB, the GNU debugger.
2 
3  Copyright (C) 1988-2015 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
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
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 
int remote_unescape_input(const gdb_byte *buffer, int len, gdb_byte *out_buf, int out_maxlen)
Definition: rsp-low.c:215
int bin2hex(const gdb_byte *bin, char *hex, int count)
Definition: rsp-low.c:136
int tohex(int nib)
Definition: rsp-low.c:41
int remote_escape_output(const gdb_byte *buffer, int len_units, int unit_size, gdb_byte *out_buf, int *out_len_units, int out_maxlen_bytes)
Definition: rsp-low.c:160
#define _(String)
Definition: gdb_locale.h:40
char * pack_nibble(char *buf, int nibble)
Definition: rsp-low.c:77
char * unpack_varlen_hex(char *buff, ULONGEST *result)
Definition: rsp-low.c:96
int fromhex(int a)
Definition: rsp-low.c:26
bfd_byte gdb_byte
Definition: common-types.h:38
Definition: buffer.h:23
char * pack_hex_byte(char *pkt, int byte)
Definition: rsp-low.c:86
static const char hexchars[]
Definition: rsp-low.c:51
unsigned long long ULONGEST
Definition: common-types.h:53
static int needs_escaping(gdb_byte b)
Definition: rsp-low.c:152
int hex2bin(const char *hex, gdb_byte *bin, int count)
Definition: rsp-low.c:115
void error(const char *fmt,...)
Definition: errors.c:38
static int ishex(int ch, int *val)
Definition: rsp-low.c:54