FD.io VPP  v20.01-46-g7006026de
Vector Packet Processing
std-formats.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 /*
16  Copyright (c) 2001, 2002, 2003 Eliot Dresselhaus
17 
18  Permission is hereby granted, free of charge, to any person obtaining
19  a copy of this software and associated documentation files (the
20  "Software"), to deal in the Software without restriction, including
21  without limitation the rights to use, copy, modify, merge, publish,
22  distribute, sublicense, and/or sell copies of the Software, and to
23  permit persons to whom the Software is furnished to do so, subject to
24  the following conditions:
25 
26  The above copyright notice and this permission notice shall be
27  included in all copies or substantial portions of the Software.
28 
29  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
30  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
31  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
32  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
33  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
34  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
35  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
36 */
37 
38 #include <vppinfra/format.h>
39 #include <ctype.h>
40 
41 /* Format vectors. */
42 u8 *
43 format_vec32 (u8 * s, va_list * va)
44 {
45  u32 *v = va_arg (*va, u32 *);
46  char *fmt = va_arg (*va, char *);
47  uword i;
48  for (i = 0; i < vec_len (v); i++)
49  {
50  if (i > 0)
51  s = format (s, ", ");
52  s = format (s, fmt, v[i]);
53  }
54  return s;
55 }
56 
57 u8 *
58 format_vec_uword (u8 * s, va_list * va)
59 {
60  uword *v = va_arg (*va, uword *);
61  char *fmt = va_arg (*va, char *);
62  uword i;
63  for (i = 0; i < vec_len (v); i++)
64  {
65  if (i > 0)
66  s = format (s, ", ");
67  s = format (s, fmt, v[i]);
68  }
69  return s;
70 }
71 
72 /* Ascii buffer and length. */
73 u8 *
74 format_ascii_bytes (u8 * s, va_list * va)
75 {
76  u8 *v = va_arg (*va, u8 *);
77  uword n_bytes = va_arg (*va, uword);
78  vec_add (s, v, n_bytes);
79  return s;
80 }
81 
82 /* Format hex dump. */
83 u8 *
84 format_hex_bytes (u8 * s, va_list * va)
85 {
86  u8 *bytes = va_arg (*va, u8 *);
87  int n_bytes = va_arg (*va, int);
88  uword i;
89 
90  /* Print short or long form depending on byte count. */
91  uword short_form = n_bytes <= 32;
92  u32 indent = format_get_indent (s);
93 
94  if (n_bytes == 0)
95  return s;
96 
97  for (i = 0; i < n_bytes; i++)
98  {
99  if (!short_form && (i % 32) == 0)
100  s = format (s, "%08x: ", i);
101 
102  s = format (s, "%02x", bytes[i]);
103 
104  if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
105  s = format (s, "\n%U", format_white_space, indent);
106  }
107 
108  return s;
109 }
110 
111 u8 *
112 format_hex_bytes_no_wrap (u8 * s, va_list * va)
113 {
114  u8 *bytes = va_arg (*va, u8 *);
115  int n_bytes = va_arg (*va, int);
116  uword i;
117 
118  if (n_bytes == 0)
119  return s;
120 
121  for (i = 0; i < n_bytes; i++)
122  s = format (s, "%02x", bytes[i]);
123 
124  return s;
125 }
126 
127 /* Add variable number of spaces. */
128 u8 *
129 format_white_space (u8 * s, va_list * va)
130 {
131  u32 n = va_arg (*va, u32);
132  while (n-- > 0)
133  vec_add1 (s, ' ');
134  return s;
135 }
136 
137 u8 *
138 format_time_interval (u8 * s, va_list * args)
139 {
140  u8 *fmt = va_arg (*args, u8 *);
141  f64 t = va_arg (*args, f64);
142  u8 *f;
143 
144  const f64 seconds_per_minute = 60;
145  const f64 seconds_per_hour = 60 * seconds_per_minute;
146  const f64 seconds_per_day = 24 * seconds_per_hour;
147  uword days, hours, minutes, secs, msecs, usecs;
148 
149  days = t / seconds_per_day;
150  t -= days * seconds_per_day;
151 
152  hours = t / seconds_per_hour;
153  t -= hours * seconds_per_hour;
154 
155  minutes = t / seconds_per_minute;
156  t -= minutes * seconds_per_minute;
157 
158  secs = t;
159  t -= secs;
160 
161  msecs = 1e3 * t;
162  usecs = 1e6 * t;
163 
164  for (f = fmt; *f; f++)
165  {
166  uword what, c;
167  char *what_fmt = "%d";
168 
169  switch (c = *f)
170  {
171  default:
172  vec_add1 (s, c);
173  continue;
174 
175  case 'd':
176  what = days;
177  what_fmt = "%d";
178  break;
179  case 'h':
180  what = hours;
181  what_fmt = "%02d";
182  break;
183  case 'm':
184  what = minutes;
185  what_fmt = "%02d";
186  break;
187  case 's':
188  what = secs;
189  what_fmt = "%02d";
190  break;
191  case 'f':
192  what = msecs;
193  what_fmt = "%03d";
194  break;
195  case 'u':
196  what = usecs;
197  what_fmt = "%06d";
198  break;
199  }
200 
201  s = format (s, what_fmt, what);
202  }
203 
204  return s;
205 }
206 
207 /* Unparse memory size e.g. 100, 100k, 100m, 100g. */
208 u8 *
209 format_memory_size (u8 * s, va_list * va)
210 {
211  uword size = va_arg (*va, uword);
212  uword l, u, log_u;
213 
214  l = size > 0 ? min_log2 (size) : 0;
215  if (l < 10)
216  log_u = 0;
217  else if (l < 20)
218  log_u = 10;
219  else if (l < 30)
220  log_u = 20;
221  else
222  log_u = 30;
223 
224  u = (uword) 1 << log_u;
225  if (size & (u - 1))
226  s = format (s, "%.2f", (f64) size / (f64) u);
227  else
228  s = format (s, "%d", size >> log_u);
229 
230  if (log_u != 0)
231  s = format (s, "%c", " kmg"[log_u / 10]);
232 
233  return s;
234 }
235 
236 /* Parse memory size e.g. 100, 100k, 100m, 100g. */
237 uword
238 unformat_memory_size (unformat_input_t * input, va_list * va)
239 {
240  uword amount, shift, c;
241  uword *result = va_arg (*va, uword *);
242 
243  if (!unformat (input, "%wd%_", &amount))
244  return 0;
245 
246  c = unformat_get_input (input);
247  switch (c)
248  {
249  case 'k':
250  case 'K':
251  shift = 10;
252  break;
253  case 'm':
254  case 'M':
255  shift = 20;
256  break;
257  case 'g':
258  case 'G':
259  shift = 30;
260  break;
261  default:
262  shift = 0;
263  unformat_put_input (input);
264  break;
265  }
266 
267  *result = amount << shift;
268  return 1;
269 }
270 
271 /* Format c identifier: e.g. a_name -> "a name".
272  Works for both vector names and null terminated c strings. */
273 u8 *
274 format_c_identifier (u8 * s, va_list * va)
275 {
276  u8 *id = va_arg (*va, u8 *);
277  uword i, l;
278 
279  l = ~0;
280  if (clib_mem_is_vec (id))
281  l = vec_len (id);
282 
283  if (id)
284  for (i = 0; id[i] != 0 && i < l; i++)
285  {
286  u8 c = id[i];
287 
288  if (c == '_')
289  c = ' ';
290  vec_add1 (s, c);
291  }
292 
293  return s;
294 }
295 
296 u8 *
297 format_hexdump (u8 * s, va_list * args)
298 {
299  u8 *data = va_arg (*args, u8 *);
300  uword len = va_arg (*args, uword);
301  int i, index = 0;
302  const int line_len = 16;
303  u8 *line_hex = 0;
304  u8 *line_str = 0;
305  u32 indent = format_get_indent (s);
306 
307  if (!len)
308  return s;
309 
310  for (i = 0; i < len; i++)
311  {
312  line_hex = format (line_hex, "%02x ", data[i]);
313  line_str = format (line_str, "%c", isprint (data[i]) ? data[i] : '.');
314  if (!((i + 1) % line_len))
315  {
316  s = format (s, "%U%05x: %v[%v]",
317  format_white_space, index ? indent : 0,
318  index, line_hex, line_str);
319  if (i < len - 1)
320  s = format (s, "\n");
321  index = i + 1;
322  vec_reset_length (line_hex);
323  vec_reset_length (line_str);
324  }
325  }
326 
327  while (i++ % line_len)
328  line_hex = format (line_hex, " ");
329 
330  if (vec_len (line_hex))
331  s = format (s, "%U%05x: %v[%v]",
332  format_white_space, index ? indent : 0,
333  index, line_hex, line_str);
334 
335  vec_free (line_hex);
336  vec_free (line_str);
337 
338  return s;
339 }
340 
341 /*
342  * fd.io coding-style-patch-verification: ON
343  *
344  * Local Variables:
345  * eval: (c-set-style "gnu")
346  * End:
347  */
u8 * format_ascii_bytes(u8 *s, va_list *va)
Definition: std-formats.c:74
static uword unformat_get_input(unformat_input_t *input)
Definition: format.h:192
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:523
int i
static u32 format_get_indent(u8 *s)
Definition: format.h:72
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
u8 * format_hexdump(u8 *s, va_list *args)
Definition: std-formats.c:297
unsigned char u8
Definition: types.h:56
static uword min_log2(uword x)
Definition: clib.h:144
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
double f64
Definition: types.h:142
#define vec_add(V, E, N)
Add N elements to end of vector V (no header, unspecified alignment)
Definition: vec.h:599
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:129
u8 * format_hex_bytes(u8 *s, va_list *va)
Definition: std-formats.c:84
unsigned int u32
Definition: types.h:88
struct _unformat_input_t unformat_input_t
u64 size
Definition: vhost_user.h:140
static void unformat_put_input(unformat_input_t *input)
Definition: format.h:205
u8 * format_memory_size(u8 *s, va_list *va)
Definition: std-formats.c:209
u8 len
Definition: ip_types.api:91
svmdb_client_t * c
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:342
u8 * format_vec32(u8 *s, va_list *va)
Definition: std-formats.c:43
u8 data[128]
Definition: ipsec_types.api:87
u8 * format_hex_bytes_no_wrap(u8 *s, va_list *va)
Definition: std-formats.c:112
u8 * format_c_identifier(u8 *s, va_list *va)
Definition: std-formats.c:274
u8 * format_vec_uword(u8 *s, va_list *va)
Definition: std-formats.c:58
uword unformat_memory_size(unformat_input_t *input, va_list *va)
Definition: std-formats.c:238
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u64 uword
Definition: types.h:112
u8 * format_time_interval(u8 *s, va_list *args)
Definition: std-formats.c:138
static uword clib_mem_is_vec(void *v)
Predicate function, says whether the supplied vector is a clib heap object.
Definition: vec.h:207
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978