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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 Copyright (c) 2001, 2002, 2003 Eliot Dresselhaus
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:
26 The above copyright notice and this permission notice shall be
27 included in all copies or substantial portions of the Software.
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.
40 # include <linux/unistd.h>
41 # include <linux/signal.h>
43 #else /* ! __KERNEL__ */
45 #define _GNU_SOURCE /* to get REG_* in ucontext.h */
54 #include <sys/socket.h>
58 #include <vppinfra/time.h>
61 #include <linux/types.h>
62 #include <linux/netlink.h>
65 #endif /* ! __KERNEL__ */
69 # include <linux/socket.h>
70 # include <linux/in.h>
71 # include <linux/ip.h>
72 # include <linux/tcp.h>
73 # include <linux/udp.h>
74 # include <linux/icmp.h>
75 # include <linux/if_ether.h>
76 # include <linux/if_arp.h>
78 # include <net/if.h> /* struct ifnet may live here */
79 # include <netinet/in.h>
80 # include <netinet/ip.h>
81 # include <netinet/tcp.h>
82 # include <netinet/udp.h>
83 # include <netinet/ip_icmp.h>
84 # include <netinet/if_ether.h>
85 #endif /* __KERNEL__ */
87 #include <vppinfra/bitops.h> /* foreach_set_bit */
88 #include <vppinfra/format.h>
89 #include <vppinfra/error.h>
91 /* Format unix network address family (e.g. AF_INET). */
92 u8 * format_address_family (u8 * s, va_list * va)
94 uword family = va_arg (*va, uword);
95 u8 * t = (u8 *) "UNKNOWN";
98 #define _(x) case PF_##x: t = (u8 *) #x; break
100 _ (UNIX); /* Unix domain sockets */
101 _ (INET); /* Internet IP Protocol */
103 _ (AX25); /* Amateur Radio AX.25 */
106 _ (IPX); /* Novell IPX */
109 _ (APPLETALK); /* AppleTalk DDP */
112 _ (NETROM); /* Amateur Radio NET/ROM */
115 _ (BRIDGE); /* Multiprotocol bridge */
118 _ (ATMPVC); /* ATM PVCs */
121 _ (X25); /* Reserved for X.25 project */
124 _ (INET6); /* IP version 6 */
127 _ (ROSE); /* Amateur Radio X.25 PLP */
130 _ (DECnet); /* Reserved for DECnet project */
133 _ (NETBEUI); /* Reserved for 802.2LLC project*/
136 _ (SECURITY); /* Security callback pseudo AF */
139 _ (KEY); /* PF_KEY key management API */
145 _ (PACKET); /* Packet family */
151 _ (ECONET); /* Acorn Econet */
154 _ (ATMSVC); /* ATM SVCs */
157 _ (SNA); /* Linux SNA Project */
160 _ (IRDA); /* IRDA sockets */
164 vec_add (s, t, strlen ((char *) t));
168 u8 * format_network_protocol (u8 * s, va_list * args)
170 uword family = va_arg (*args, uword);
171 uword protocol = va_arg (*args, uword);
174 struct protoent * p = getprotobynumber (protocol);
176 ASSERT (family == AF_INET);
178 return format (s, "%s", p->p_name);
180 return format (s, "%d", protocol);
182 return format (s, "%d/%d", family, protocol);
186 u8 * format_network_port (u8 * s, va_list * args)
188 uword proto = va_arg (*args, uword);
189 uword port = va_arg (*args, uword);
192 struct servent * p = getservbyport (port, proto == IPPROTO_UDP ? "udp" : "tcp");
195 return format (s, "%s", p->s_name);
197 return format (s, "%d", port);
199 return format (s, "%s/%d", proto == IPPROTO_UDP ? "udp" : "tcp", port);
203 /* Format generic network address: takes two arguments family and address.
204 Assumes network byte order. */
205 u8 * format_network_address (u8 * s, va_list * args)
207 uword family = va_arg (*args, uword);
208 u8 * addr = va_arg (*args, u8 *);
213 s = format (s, "%d.%d.%d.%d", addr[0], addr[1], addr[2], addr[3]);
217 /* We use AF_UNSPEC for ethernet addresses. */
218 s = format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
219 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
223 clib_error ("unsupported address family %d", family);
229 u8 * format_sockaddr (u8 * s, va_list * args)
231 void * v = va_arg (*args, void *);
232 struct sockaddr * sa = v;
234 switch (sa->sa_family)
238 struct sockaddr_in * i = v;
239 s = format (s, "%U:%U",
240 format_network_address, AF_INET, &i->sin_addr.s_addr,
241 format_network_port, IPPROTO_TCP, ntohs (i->sin_port));
249 struct sockaddr_nl * n = v;
250 s = format (s, "KERNEL-NETLINK");
252 s = format (s, " (groups 0x%x)", n->nl_groups);
259 s = format (s, "sockaddr family %d", sa->sa_family);
266 u8 * format_tcp4_packet (u8 * s, va_list * args)
268 u8 * p = va_arg (*args, u8 *);
269 struct iphdr * ip = (void *) p;
270 struct tcphdr * tcp = (void *) (ip + 1);
272 s = format (s, "tcp %U:%U -> %U:%U",
273 format_network_address, AF_INET, &ip->saddr,
274 format_network_port, IPPROTO_TCP, ntohs (tcp->source),
275 format_network_address, AF_INET, &ip->daddr,
276 format_network_port, IPPROTO_TCP, ntohs (tcp->dest));
278 s = format (s, ", seq 0x%08x -> 0x%08x", tcp->seq, tcp->ack_seq);
279 #define _(f) if (tcp->f) s = format (s, ", " #f);
280 _ (syn); _ (ack); _ (fin); _ (rst); _ (psh); _ (urg);
284 s = format (s, ", window 0x%04x", tcp->window);
286 s = format (s, ", urg 0x%04x", tcp->urg_ptr);
291 u8 * format_udp4_packet (u8 * s, va_list * args)
293 u8 * p = va_arg (*args, u8 *);
294 struct iphdr * ip = (void *) p;
295 struct udphdr * udp = (void *) (ip + 1);
297 s = format (s, "udp %U:%U -> %U:%U",
298 format_network_address, AF_INET, &ip->saddr,
299 format_network_port, IPPROTO_UDP, ntohs (udp->source),
300 format_network_address, AF_INET, &ip->daddr,
301 format_network_port, IPPROTO_UDP, ntohs (udp->dest));
306 u8 * format_icmp4_type_and_code (u8 * s, va_list * args)
308 uword icmp_type = va_arg (*args, uword);
309 uword icmp_code = va_arg (*args, uword);
313 #define _(f,str) case ICMP_##f: s = format (s, str); break;
314 _ (ECHOREPLY, "echo reply");
315 _ (DEST_UNREACH, "unreachable");
316 _ (SOURCE_QUENCH, "source quench");
317 _ (REDIRECT, "redirect");
318 _ (ECHO, "echo request");
319 _ (TIME_EXCEEDED, "time exceeded");
320 _ (PARAMETERPROB, "parameter problem");
321 _ (TIMESTAMP, "timestamp request");
322 _ (TIMESTAMPREPLY, "timestamp reply");
323 _ (INFO_REQUEST, "information request");
324 _ (INFO_REPLY, "information reply");
325 _ (ADDRESS, "address mask request");
326 _ (ADDRESSREPLY, "address mask reply");
329 s = format (s, "unknown type 0x%x", icmp_type);
332 if (icmp_type == ICMP_DEST_UNREACH)
336 #define _(f,str) case ICMP_##f: s = format (s, " " # str); break;
337 _ (NET_UNREACH, "network");
338 _ (HOST_UNREACH, "host");
339 _ (PROT_UNREACH, "protocol");
340 _ (PORT_UNREACH, "port");
341 _ (FRAG_NEEDED, ": fragmentation needed/DF set");
342 _ (SR_FAILED, "source route failed");
343 _ (NET_UNKNOWN, "network unknown");
344 _ (HOST_UNKNOWN, "host unknown");
345 _ (HOST_ISOLATED, "host isolated");
346 _ (NET_ANO, "network: admin. prohibited");
347 _ (HOST_ANO, "host: admin. prohibited");
348 _ (NET_UNR_TOS, "network for type-of-service");
349 _ (HOST_UNR_TOS, "host for type-of-service");
350 _ (PKT_FILTERED, ": packet filtered");
351 _ (PREC_VIOLATION, "precedence violation");
352 _ (PREC_CUTOFF, "precedence cut off");
355 s = format (s, "unknown code 0x%x", icmp_code);
358 else if (icmp_type == ICMP_REDIRECT)
362 #define _(f,str) case ICMP_##f: s = format (s, " " # str); break;
363 _ (REDIR_NET, "network");
364 _ (REDIR_HOST, "host");
365 _ (REDIR_NETTOS, "network for type-of-service");
366 _ (REDIR_HOSTTOS, "host for type-of-service");
369 s = format (s, "unknown code 0x%x", icmp_code);
372 else if (icmp_type == ICMP_TIME_EXCEEDED)
376 #define _(f,str) case ICMP_##f: s = format (s, " " # str); break;
377 _ (EXC_TTL, "time-to-live zero in transit");
378 _ (EXC_FRAGTIME, "time-to-live zero during reassembly");
381 s = format (s, "unknown code 0x%x", icmp_code);
394 u8 * format_icmp4_packet (u8 * s, va_list * args)
396 u8 * p = va_arg (*args, u8 *);
397 struct iphdr * ip = (void *) p;
398 icmp4_t * icmp = (void *) (ip + 1);
399 s = format (s, "icmp %U %U -> %U",
400 format_icmp4_type_and_code, icmp->type, icmp->code,
401 format_network_address, AF_INET, &ip->saddr,
402 format_network_address, AF_INET, &ip->daddr);
407 u8 * format_ip4_tos_byte (u8 * s, va_list * args)
409 uword tos = va_arg (*args, uword);
411 if (tos & IPTOS_LOWDELAY)
412 s = format (s, "minimize-delay, ");
413 if (tos & IPTOS_MINCOST)
414 s = format (s, "minimize-cost, ");
415 if (tos & IPTOS_THROUGHPUT)
416 s = format (s, "maximize-throughput, ");
417 if (tos & IPTOS_RELIABILITY)
418 s = format (s, "maximize-reliability, ");
420 switch (IPTOS_PREC (tos))
422 #define _(x,y) case IPTOS_PREC_##x: s = format (s, y); break
423 _ (NETCONTROL, "network");
424 _ (INTERNETCONTROL, "internet");
425 _ (CRITIC_ECP, "critical");
427 _ (FLASHOVERRIDE, "flash-override");
428 _ (IMMEDIATE, "immediate");
429 _ (PRIORITY, "priority");
430 _ (ROUTINE, "routine");
437 u8 * format_ip4_packet (u8 * s, va_list * args)
439 u8 * p = va_arg (*args, u8 *);
440 struct iphdr * ip = (void *) p;
442 static format_function_t * f[256];
444 if (! f[IPPROTO_TCP])
446 f[IPPROTO_TCP] = format_tcp4_packet;
447 f[IPPROTO_UDP] = format_udp4_packet;
448 f[IPPROTO_ICMP] = format_icmp4_packet;
452 return format (s, "%U", f[ip->protocol], p);
454 s = format (s, "%U: %U -> %U",
455 format_network_protocol, AF_INET, ip->protocol,
456 format_network_address, AF_INET, &ip->saddr,
457 format_network_address, AF_INET, &ip->daddr);
462 #define foreach_unix_arphrd_type \
512 _ (IEEE802_TR, 800) \
514 _ (IEEE80211_PRISM, 802) \
515 _ (IEEE80211_RADIOTAP, 803) \
519 u8 * format_unix_arphrd (u8 * s, va_list * args)
521 #ifndef __COVERITY__ /* doesn't understand this at all... */
522 u32 x = va_arg (*args, u32);
526 #define _(f,n) case ARPHRD_##f: t = #f; break;
527 foreach_unix_arphrd_type
535 s = format (s, "%s", t);
537 s = format (s, "unknown 0x%x", x);
542 #define foreach_unix_interface_flag \
563 static char * unix_interface_flag_names[] = {
565 foreach_unix_interface_flag
569 u8 * format_unix_interface_flags (u8 * s, va_list * args)
571 u32 x = va_arg (*args, u32);
575 s = format (s, "none");
576 else foreach_set_bit (i, x, ({
577 if (i < ARRAY_LEN (unix_interface_flag_names))
578 s = format (s, "%s", unix_interface_flag_names[i]);
580 s = format (s, "unknown %d", i);
582 s = format (s, ", ");
588 u16 ar_hrd; /* format of hardware address */
589 u16 ar_pro; /* format of protocol address */
590 u8 ar_hln; /* length of hardware address */
591 u8 ar_pln; /* length of protocol address */
592 u16 ar_op; /* ARP opcode (command) */
593 u8 ar_sha[6]; /* sender hardware address */
594 u8 ar_spa[4]; /* sender IP address */
595 u8 ar_tha[6]; /* target hardware address */
596 u8 ar_tpa[4]; /* target IP address */
599 u8 * format_arp_packet (u8 * s, va_list * args)
601 arp_ether_ip4_t * a = va_arg (*args, arp_ether_ip4_t *);
602 char * op = "unknown";
604 if (a->ar_pro != ETH_P_IP ||
605 a->ar_hrd != ARPHRD_ETHER)
610 #define _(f) case ARPOP_##f: op = #f; break;
618 s = format (s, "%s %U %U -> %U %U",
620 format_network_address, AF_INET, a->ar_spa,
621 format_network_address, AF_UNSPEC, a->ar_sha,
622 format_network_address, AF_INET, a->ar_tpa,
623 format_network_address, AF_UNSPEC, a->ar_tha);
627 u8 * format_ethernet_proto (u8 * s, va_list * args)
629 uword type = va_arg (*args, uword);
634 case 0: t = "BPDU"; break;
635 #define _(f) case ETH_P_##f: t = #f; break;
662 #ifdef ETH_P_PPP_DISC
691 vec_add (s, t, strlen (t));
693 s = format (s, "ether-type 0x%x", type);
697 u8 * format_ethernet_packet (u8 * s, va_list * args)
699 struct ethhdr * h = va_arg (*args, struct ethhdr *);
700 uword proto = h->h_proto;
701 u8 * payload = (void *) (h + 1);
704 /* Check for 802.2/802.3 encapsulation. */
705 if (proto < ETH_DATA_LEN)
708 u8 dsap, ssap, control;
712 ethhdr_802_t * h1 = (void *) (h + 1);
714 payload = (void *) (h1 + 1);
717 indent = format_get_indent (s);
719 s = format (s, "%U: %U -> %U",
720 format_ethernet_proto, proto,
721 format_network_address, AF_UNSPEC, h->h_source,
722 format_network_address, AF_UNSPEC, h->h_dest);
727 s = format (s, "\n%U%U",
728 format_white_space, indent,
729 format_arp_packet, payload);
737 u8 * format_hostname (u8 * s, va_list * args)
741 if (gethostname (b, sizeof (buffer)) < 0)
743 return format (s, "%s", b);
748 u8 * format_timeval (u8 * s, va_list * args)
750 char * fmt = va_arg (*args, char *);
751 struct timeval * tv = va_arg (*args, struct timeval *);
757 fmt = "y/m/d H:M:S:F";
761 static struct timeval now;
762 gettimeofday (&now, 0);
766 msec = flt_round_nearest (1e-3 * tv->tv_usec);
768 { msec = 0; tv->tv_sec++; }
771 time_t t = tv->tv_sec;
775 for (f = fmt; *f; f++)
778 char * what_fmt = "%d";
787 what = 1900 + tm->tm_year;
791 what = tm->tm_mon + 1;
816 s = format (s, what_fmt, what);
822 u8 * format_time_float (u8 * s, va_list * args)
824 u8 * fmt = va_arg (*args, u8 *);
825 f64 t = va_arg (*args, f64);
828 t = unix_time_now ();
830 tv.tv_usec = 1e6*(t - tv.tv_sec);
831 return format (s, "%U", format_timeval, fmt, &tv);
834 u8 * format_signal (u8 * s, va_list * args)
836 uword signum = va_arg (*args, uword);
840 #define _(x) case x: t = #x; break;
878 return format (s, "unknown %d", signum);
881 vec_add (s, t, strlen (t));
885 u8 * format_ucontext_pc (u8 * s, va_list * args)
887 ucontext_t * uc __attribute__((unused));
888 unsigned long * regs = 0;
891 uc = va_arg (*args, ucontext_t *);
893 #if defined (powerpc)
894 regs = &uc->uc_mcontext.uc_regs->gregs[0];
895 #elif defined (powerpc64)
896 regs = &uc->uc_mcontext.uc_regs->gp_regs[0];
897 #elif defined (i386) || defined (__x86_64__)
898 regs = (void *) &uc->uc_mcontext.gregs[0];
901 #if defined (powerpc) || defined (powerpc64)
905 #elif defined (__x86_64__)
913 return format (s, "unsupported");
915 return format (s, "%p", regs[reg_no]);
918 #endif /* __KERNEL__ */