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 */
55 #include <sys/socket.h>
59 #include <vppinfra/time.h>
62 #include <linux/types.h>
63 #include <linux/netlink.h>
66 #endif /* ! __KERNEL__ */
70 # include <linux/socket.h>
71 # include <linux/in.h>
72 # include <linux/ip.h>
73 # include <linux/tcp.h>
74 # include <linux/udp.h>
75 # include <linux/icmp.h>
76 # include <linux/if_ether.h>
77 # include <linux/if_arp.h>
79 # include <net/if.h> /* struct ifnet may live here */
80 # include <netinet/in.h>
81 # include <netinet/ip.h>
82 # include <netinet/tcp.h>
83 # include <netinet/udp.h>
84 # include <netinet/ip_icmp.h>
85 # include <netinet/if_ether.h>
86 #endif /* __KERNEL__ */
88 #include <vppinfra/bitops.h> /* foreach_set_bit */
89 #include <vppinfra/format.h>
90 #include <vppinfra/error.h>
92 /* Format unix network address family (e.g. AF_INET). */
93 u8 * format_address_family (u8 * s, va_list * va)
95 uword family = va_arg (*va, uword);
96 u8 * t = (u8 *) "UNKNOWN";
99 #define _(x) case PF_##x: t = (u8 *) #x; break
101 _ (UNIX); /* Unix domain sockets */
102 _ (INET); /* Internet IP Protocol */
104 _ (AX25); /* Amateur Radio AX.25 */
107 _ (IPX); /* Novell IPX */
110 _ (APPLETALK); /* AppleTalk DDP */
113 _ (NETROM); /* Amateur Radio NET/ROM */
116 _ (BRIDGE); /* Multiprotocol bridge */
119 _ (ATMPVC); /* ATM PVCs */
122 _ (X25); /* Reserved for X.25 project */
125 _ (INET6); /* IP version 6 */
128 _ (ROSE); /* Amateur Radio X.25 PLP */
131 _ (DECnet); /* Reserved for DECnet project */
134 _ (NETBEUI); /* Reserved for 802.2LLC project*/
137 _ (SECURITY); /* Security callback pseudo AF */
140 _ (KEY); /* PF_KEY key management API */
146 _ (PACKET); /* Packet family */
152 _ (ECONET); /* Acorn Econet */
155 _ (ATMSVC); /* ATM SVCs */
158 _ (SNA); /* Linux SNA Project */
161 _ (IRDA); /* IRDA sockets */
165 vec_add (s, t, strlen ((char *) t));
169 u8 * format_network_protocol (u8 * s, va_list * args)
171 uword family = va_arg (*args, uword);
172 uword protocol = va_arg (*args, uword);
175 struct protoent * p = getprotobynumber (protocol);
177 ASSERT (family == AF_INET);
179 return format (s, "%s", p->p_name);
181 return format (s, "%d", protocol);
183 return format (s, "%d/%d", family, protocol);
187 u8 * format_network_port (u8 * s, va_list * args)
189 uword proto = va_arg (*args, uword);
190 uword port = va_arg (*args, uword);
193 struct servent * p = getservbyport (port, proto == IPPROTO_UDP ? "udp" : "tcp");
196 return format (s, "%s", p->s_name);
198 return format (s, "%d", port);
200 return format (s, "%s/%d", proto == IPPROTO_UDP ? "udp" : "tcp", port);
204 /* Format generic network address: takes two arguments family and address.
205 Assumes network byte order. */
206 u8 * format_network_address (u8 * s, va_list * args)
208 uword family = va_arg (*args, uword);
209 u8 * addr = va_arg (*args, u8 *);
214 s = format (s, "%d.%d.%d.%d", addr[0], addr[1], addr[2], addr[3]);
218 /* We use AF_UNSPEC for ethernet addresses. */
219 s = format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
220 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
224 clib_error ("unsupported address family %d", family);
230 u8 * format_sockaddr (u8 * s, va_list * args)
232 void * v = va_arg (*args, void *);
233 struct sockaddr * sa = v;
235 switch (sa->sa_family)
239 struct sockaddr_in * i = v;
240 s = format (s, "%U:%U",
241 format_network_address, AF_INET, &i->sin_addr.s_addr,
242 format_network_port, IPPROTO_TCP, ntohs (i->sin_port));
250 struct sockaddr_nl * n = v;
251 s = format (s, "KERNEL-NETLINK");
253 s = format (s, " (groups 0x%x)", n->nl_groups);
260 s = format (s, "sockaddr family %d", sa->sa_family);
267 u8 * format_tcp4_packet (u8 * s, va_list * args)
269 u8 * p = va_arg (*args, u8 *);
270 struct iphdr * ip = (void *) p;
271 struct tcphdr * tcp = (void *) (ip + 1);
273 s = format (s, "tcp %U:%U -> %U:%U",
274 format_network_address, AF_INET, &ip->saddr,
275 format_network_port, IPPROTO_TCP, ntohs (tcp->source),
276 format_network_address, AF_INET, &ip->daddr,
277 format_network_port, IPPROTO_TCP, ntohs (tcp->dest));
279 s = format (s, ", seq 0x%08x -> 0x%08x", tcp->seq, tcp->ack_seq);
280 #define _(f) if (tcp->f) s = format (s, ", " #f);
281 _ (syn); _ (ack); _ (fin); _ (rst); _ (psh); _ (urg);
285 s = format (s, ", window 0x%04x", tcp->window);
287 s = format (s, ", urg 0x%04x", tcp->urg_ptr);
292 u8 * format_udp4_packet (u8 * s, va_list * args)
294 u8 * p = va_arg (*args, u8 *);
295 struct iphdr * ip = (void *) p;
296 struct udphdr * udp = (void *) (ip + 1);
298 s = format (s, "udp %U:%U -> %U:%U",
299 format_network_address, AF_INET, &ip->saddr,
300 format_network_port, IPPROTO_UDP, ntohs (udp->source),
301 format_network_address, AF_INET, &ip->daddr,
302 format_network_port, IPPROTO_UDP, ntohs (udp->dest));
307 u8 * format_icmp4_type_and_code (u8 * s, va_list * args)
309 uword icmp_type = va_arg (*args, uword);
310 uword icmp_code = va_arg (*args, uword);
314 #define _(f,str) case ICMP_##f: s = format (s, str); break;
315 _ (ECHOREPLY, "echo reply");
316 _ (DEST_UNREACH, "unreachable");
317 _ (SOURCE_QUENCH, "source quench");
318 _ (REDIRECT, "redirect");
319 _ (ECHO, "echo request");
320 _ (TIME_EXCEEDED, "time exceeded");
321 _ (PARAMETERPROB, "parameter problem");
322 _ (TIMESTAMP, "timestamp request");
323 _ (TIMESTAMPREPLY, "timestamp reply");
324 _ (INFO_REQUEST, "information request");
325 _ (INFO_REPLY, "information reply");
326 _ (ADDRESS, "address mask request");
327 _ (ADDRESSREPLY, "address mask reply");
330 s = format (s, "unknown type 0x%x", icmp_type);
333 if (icmp_type == ICMP_DEST_UNREACH)
337 #define _(f,str) case ICMP_##f: s = format (s, " " # str); break;
338 _ (NET_UNREACH, "network");
339 _ (HOST_UNREACH, "host");
340 _ (PROT_UNREACH, "protocol");
341 _ (PORT_UNREACH, "port");
342 _ (FRAG_NEEDED, ": fragmentation needed/DF set");
343 _ (SR_FAILED, "source route failed");
344 _ (NET_UNKNOWN, "network unknown");
345 _ (HOST_UNKNOWN, "host unknown");
346 _ (HOST_ISOLATED, "host isolated");
347 _ (NET_ANO, "network: admin. prohibited");
348 _ (HOST_ANO, "host: admin. prohibited");
349 _ (NET_UNR_TOS, "network for type-of-service");
350 _ (HOST_UNR_TOS, "host for type-of-service");
351 _ (PKT_FILTERED, ": packet filtered");
352 _ (PREC_VIOLATION, "precedence violation");
353 _ (PREC_CUTOFF, "precedence cut off");
356 s = format (s, "unknown code 0x%x", icmp_code);
359 else if (icmp_type == ICMP_REDIRECT)
363 #define _(f,str) case ICMP_##f: s = format (s, " " # str); break;
364 _ (REDIR_NET, "network");
365 _ (REDIR_HOST, "host");
366 _ (REDIR_NETTOS, "network for type-of-service");
367 _ (REDIR_HOSTTOS, "host for type-of-service");
370 s = format (s, "unknown code 0x%x", icmp_code);
373 else if (icmp_type == ICMP_TIME_EXCEEDED)
377 #define _(f,str) case ICMP_##f: s = format (s, " " # str); break;
378 _ (EXC_TTL, "time-to-live zero in transit");
379 _ (EXC_FRAGTIME, "time-to-live zero during reassembly");
382 s = format (s, "unknown code 0x%x", icmp_code);
395 u8 * format_icmp4_packet (u8 * s, va_list * args)
397 u8 * p = va_arg (*args, u8 *);
398 struct iphdr * ip = (void *) p;
399 icmp4_t * icmp = (void *) (ip + 1);
400 s = format (s, "icmp %U %U -> %U",
401 format_icmp4_type_and_code, icmp->type, icmp->code,
402 format_network_address, AF_INET, &ip->saddr,
403 format_network_address, AF_INET, &ip->daddr);
408 u8 * format_ip4_tos_byte (u8 * s, va_list * args)
410 uword tos = va_arg (*args, uword);
412 if (tos & IPTOS_LOWDELAY)
413 s = format (s, "minimize-delay, ");
414 if (tos & IPTOS_MINCOST)
415 s = format (s, "minimize-cost, ");
416 if (tos & IPTOS_THROUGHPUT)
417 s = format (s, "maximize-throughput, ");
418 if (tos & IPTOS_RELIABILITY)
419 s = format (s, "maximize-reliability, ");
421 switch (IPTOS_PREC (tos))
423 #define _(x,y) case IPTOS_PREC_##x: s = format (s, y); break
424 _ (NETCONTROL, "network");
425 _ (INTERNETCONTROL, "internet");
426 _ (CRITIC_ECP, "critical");
428 _ (FLASHOVERRIDE, "flash-override");
429 _ (IMMEDIATE, "immediate");
430 _ (PRIORITY, "priority");
431 _ (ROUTINE, "routine");
438 u8 * format_ip4_packet (u8 * s, va_list * args)
440 u8 * p = va_arg (*args, u8 *);
441 struct iphdr * ip = (void *) p;
443 static format_function_t * f[256];
445 if (! f[IPPROTO_TCP])
447 f[IPPROTO_TCP] = format_tcp4_packet;
448 f[IPPROTO_UDP] = format_udp4_packet;
449 f[IPPROTO_ICMP] = format_icmp4_packet;
453 return format (s, "%U", f[ip->protocol], p);
455 s = format (s, "%U: %U -> %U",
456 format_network_protocol, AF_INET, ip->protocol,
457 format_network_address, AF_INET, &ip->saddr,
458 format_network_address, AF_INET, &ip->daddr);
463 #define foreach_unix_arphrd_type \
513 _ (IEEE802_TR, 800) \
515 _ (IEEE80211_PRISM, 802) \
516 _ (IEEE80211_RADIOTAP, 803) \
520 u8 * format_unix_arphrd (u8 * s, va_list * args)
522 #ifndef __COVERITY__ /* doesn't understand this at all... */
523 u32 x = va_arg (*args, u32);
527 #define _(f,n) case ARPHRD_##f: t = #f; break;
528 foreach_unix_arphrd_type
536 s = format (s, "%s", t);
538 s = format (s, "unknown 0x%x", x);
543 #define foreach_unix_interface_flag \
564 static char * unix_interface_flag_names[] = {
566 foreach_unix_interface_flag
570 u8 * format_unix_interface_flags (u8 * s, va_list * args)
572 u32 x = va_arg (*args, u32);
576 s = format (s, "none");
577 else foreach_set_bit (i, x, ({
578 if (i < ARRAY_LEN (unix_interface_flag_names))
579 s = format (s, "%s", unix_interface_flag_names[i]);
581 s = format (s, "unknown %d", i);
583 s = format (s, ", ");
589 u16 ar_hrd; /* format of hardware address */
590 u16 ar_pro; /* format of protocol address */
591 u8 ar_hln; /* length of hardware address */
592 u8 ar_pln; /* length of protocol address */
593 u16 ar_op; /* ARP opcode (command) */
594 u8 ar_sha[6]; /* sender hardware address */
595 u8 ar_spa[4]; /* sender IP address */
596 u8 ar_tha[6]; /* target hardware address */
597 u8 ar_tpa[4]; /* target IP address */
600 u8 * format_arp_packet (u8 * s, va_list * args)
602 arp_ether_ip4_t * a = va_arg (*args, arp_ether_ip4_t *);
603 char * op = "unknown";
605 if (a->ar_pro != ETH_P_IP ||
606 a->ar_hrd != ARPHRD_ETHER)
611 #define _(f) case ARPOP_##f: op = #f; break;
619 s = format (s, "%s %U %U -> %U %U",
621 format_network_address, AF_INET, a->ar_spa,
622 format_network_address, AF_UNSPEC, a->ar_sha,
623 format_network_address, AF_INET, a->ar_tpa,
624 format_network_address, AF_UNSPEC, a->ar_tha);
628 u8 * format_ethernet_proto (u8 * s, va_list * args)
630 uword type = va_arg (*args, uword);
635 case 0: t = "BPDU"; break;
636 #define _(f) case ETH_P_##f: t = #f; break;
663 #ifdef ETH_P_PPP_DISC
692 vec_add (s, t, strlen (t));
694 s = format (s, "ether-type 0x%x", type);
698 u8 * format_ethernet_packet (u8 * s, va_list * args)
700 struct ethhdr * h = va_arg (*args, struct ethhdr *);
701 uword proto = h->h_proto;
702 u8 * payload = (void *) (h + 1);
705 /* Check for 802.2/802.3 encapsulation. */
706 if (proto < ETH_DATA_LEN)
709 u8 dsap, ssap, control;
713 ethhdr_802_t * h1 = (void *) (h + 1);
715 payload = (void *) (h1 + 1);
718 indent = format_get_indent (s);
720 s = format (s, "%U: %U -> %U",
721 format_ethernet_proto, proto,
722 format_network_address, AF_UNSPEC, h->h_source,
723 format_network_address, AF_UNSPEC, h->h_dest);
728 s = format (s, "\n%U%U",
729 format_white_space, indent,
730 format_arp_packet, payload);
738 u8 * format_hostname (u8 * s, va_list * args)
742 if (gethostname (b, sizeof (buffer)) < 0)
744 return format (s, "%s", b);
749 u8 * format_timeval (u8 * s, va_list * args)
751 char * fmt = va_arg (*args, char *);
752 struct timeval * tv = va_arg (*args, struct timeval *);
758 fmt = "y/m/d H:M:S:F";
762 static struct timeval now;
763 gettimeofday (&now, 0);
767 msec = flt_round_nearest (1e-3 * tv->tv_usec);
769 { msec = 0; tv->tv_sec++; }
772 time_t t = tv->tv_sec;
776 for (f = fmt; *f; f++)
779 char * what_fmt = "%d";
788 what = 1900 + tm->tm_year;
792 what = tm->tm_mon + 1;
817 s = format (s, what_fmt, what);
823 u8 * format_time_float (u8 * s, va_list * args)
825 u8 * fmt = va_arg (*args, u8 *);
826 f64 t = va_arg (*args, f64);
829 t = unix_time_now ();
831 tv.tv_usec = 1e6*(t - tv.tv_sec);
832 return format (s, "%U", format_timeval, fmt, &tv);
835 u8 * format_signal (u8 * s, va_list * args)
837 uword signum = va_arg (*args, uword);
841 #define _(x) case x: t = #x; break;
879 return format (s, "unknown %d", signum);
882 vec_add (s, t, strlen (t));
886 u8 * format_ucontext_pc (u8 * s, va_list * args)
888 ucontext_t * uc __attribute__((unused));
889 unsigned long * regs = 0;
892 uc = va_arg (*args, ucontext_t *);
894 #if defined (powerpc)
895 regs = &uc->uc_mcontext.uc_regs->gregs[0];
896 #elif defined (powerpc64)
897 regs = &uc->uc_mcontext.uc_regs->gp_regs[0];
898 #elif defined (i386) || defined (__x86_64__)
899 regs = (void *) &uc->uc_mcontext.gregs[0];
902 #if defined (powerpc) || defined (powerpc64)
906 #elif defined (__x86_64__)
914 return format (s, "unsupported");
916 return format (s, "%p", regs[reg_no]);
920 unformat_unix_gid (unformat_input_t * input, va_list * args)
922 gid_t *gid = va_arg (*args, gid_t *);
923 struct group *grp = 0;
927 if (unformat (input, "%d", &r))
931 else if (unformat (input, "%s", &s))
933 grp = getgrnam ((char *) s);
944 #endif /* __KERNEL__ */