libnl  3.2.28
utils.c
1 /*
2  * lib/utils.c Utility Functions
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation version 2.1
7  * of the License.
8  *
9  * Copyright (c) 2003-2012 Thomas Graf <tgraf@suug.ch>
10  */
11 
12 /**
13  * @ingroup core
14  * @defgroup utils Utilities
15  *
16  * Collection of helper functions
17  *
18  * @{
19  *
20  * Header
21  * ------
22  * ~~~~{.c}
23  * #include <netlink/utils.h>
24  * ~~~~
25  */
26 
27 #include <netlink-private/netlink.h>
28 #include <netlink/netlink.h>
29 #include <netlink/utils.h>
30 #include <linux/socket.h>
31 #include <stdlib.h> /* exit() */
32 
33 /**
34  * Global variable indicating the desired level of debugging output.
35  *
36  * Level | Messages Printed
37  * ----- | ---------------------------------------------------------
38  * 0 | Debugging output disabled
39  * 1 | Warnings, important events and notifications
40  * 2 | More or less important debugging messages
41  * 3 | Repetitive events causing a flood of debugging messages
42  * 4 | Even less important messages
43  *
44  * If available, the variable will be initialized to the value of the
45  * environment variable `NLDBG`. The default value is 0 (disabled).
46  *
47  * For more information, see section @core_doc{_debugging, Debugging}.
48  */
49 int nl_debug = 0;
50 
51 /** @cond SKIP */
52 #ifdef NL_DEBUG
53 struct nl_dump_params nl_debug_dp = {
55 };
56 
57 static void __init nl_debug_init(void)
58 {
59  char *nldbg, *end;
60 
61  if ((nldbg = getenv("NLDBG"))) {
62  long level = strtol(nldbg, &end, 0);
63  if (nldbg != end)
64  nl_debug = level;
65  }
66 
67  nl_debug_dp.dp_fd = stderr;
68 }
69 #endif
70 
71 int __nl_read_num_str_file(const char *path, int (*cb)(long, const char *))
72 {
73  FILE *fd;
74  char buf[128];
75 
76  fd = fopen(path, "r");
77  if (fd == NULL)
78  return -nl_syserr2nlerr(errno);
79 
80  while (fgets(buf, sizeof(buf), fd)) {
81  int goodlen, err;
82  long num;
83  char *end;
84 
85  if (*buf == '#' || *buf == '\n' || *buf == '\r')
86  continue;
87 
88  num = strtol(buf, &end, 0);
89  if (end == buf) {
90  fclose(fd);
91  return -NLE_INVAL;
92  }
93 
94  if (num == LONG_MIN || num == LONG_MAX) {
95  fclose(fd);
96  return -NLE_RANGE;
97  }
98 
99  while (*end == ' ' || *end == '\t')
100  end++;
101 
102  goodlen = strcspn(end, "#\r\n\t ");
103  if (goodlen == 0) {
104  fclose(fd);
105  return -NLE_INVAL;
106  }
107 
108  end[goodlen] = '\0';
109 
110  err = cb(num, end);
111  if (err < 0) {
112  fclose(fd);
113  return err;
114  }
115  }
116 
117  fclose(fd);
118 
119  return 0;
120 }
121 /** @endcond */
122 
123 /**
124  * @name Pretty Printing of Numbers
125  * @{
126  */
127 
128 /**
129  * Cancel down a byte counter
130  * @arg l byte counter
131  * @arg unit destination unit pointer
132  *
133  * Cancels down a byte counter until it reaches a reasonable
134  * unit. The chosen unit is assigned to \a unit.
135  * This function assume 1024 bytes in one kilobyte
136  *
137  * @return The cancelled down byte counter in the new unit.
138  */
139 double nl_cancel_down_bytes(unsigned long long l, char **unit)
140 {
141  if (l >= 1099511627776LL) {
142  *unit = "TiB";
143  return ((double) l) / 1099511627776LL;
144  } else if (l >= 1073741824) {
145  *unit = "GiB";
146  return ((double) l) / 1073741824;
147  } else if (l >= 1048576) {
148  *unit = "MiB";
149  return ((double) l) / 1048576;
150  } else if (l >= 1024) {
151  *unit = "KiB";
152  return ((double) l) / 1024;
153  } else {
154  *unit = "B";
155  return (double) l;
156  }
157 }
158 
159 /**
160  * Cancel down a bit counter
161  * @arg l bit counter
162  * @arg unit destination unit pointer
163  *
164  * Cancels down bit counter until it reaches a reasonable
165  * unit. The chosen unit is assigned to \a unit.
166  * This function assume 1000 bits in one kilobit
167  *
168  * @return The cancelled down bit counter in the new unit.
169  */
170 double nl_cancel_down_bits(unsigned long long l, char **unit)
171 {
172  if (l >= 1000000000000ULL) {
173  *unit = "Tbit";
174  return ((double) l) / 1000000000000ULL;
175  }
176 
177  if (l >= 1000000000) {
178  *unit = "Gbit";
179  return ((double) l) / 1000000000;
180  }
181 
182  if (l >= 1000000) {
183  *unit = "Mbit";
184  return ((double) l) / 1000000;
185  }
186 
187  if (l >= 1000) {
188  *unit = "Kbit";
189  return ((double) l) / 1000;
190  }
191 
192  *unit = "bit";
193  return (double) l;
194 }
195 
196 int nl_rate2str(unsigned long long rate, int type, char *buf, size_t len)
197 {
198  char *unit;
199  double frac;
200 
201  switch (type) {
202  case NL_BYTE_RATE:
203  frac = nl_cancel_down_bytes(rate, &unit);
204  break;
205 
206  case NL_BIT_RATE:
207  frac = nl_cancel_down_bits(rate, &unit);
208  break;
209 
210  default:
211  BUG();
212  }
213 
214  return snprintf(buf, len, "%.2f%s/s", frac, unit);
215 }
216 
217 /**
218  * Cancel down a micro second value
219  * @arg l micro seconds
220  * @arg unit destination unit pointer
221  *
222  * Cancels down a microsecond counter until it reaches a
223  * reasonable unit. The chosen unit is assigned to \a unit.
224  *
225  * @return The cancelled down microsecond in the new unit
226  */
227 double nl_cancel_down_us(uint32_t l, char **unit)
228 {
229  if (l >= 1000000) {
230  *unit = "s";
231  return ((double) l) / 1000000;
232  } else if (l >= 1000) {
233  *unit = "ms";
234  return ((double) l) / 1000;
235  } else {
236  *unit = "us";
237  return (double) l;
238  }
239 }
240 
241 /** @} */
242 
243 /**
244  * @name Generic Unit Translations
245  * @{
246  */
247 
248 /**
249  * Convert a character string to a size
250  * @arg str size encoded as character string
251  *
252  * Converts the specified size as character to the corresponding
253  * number of bytes.
254  *
255  * Supported formats are:
256  * - b,kb/k,m/mb,gb/g for bytes
257  * - bit,kbit/mbit/gbit
258  *
259  * This function assume 1000 bits in one kilobit and
260  * 1024 bytes in one kilobyte
261  *
262  * @return The number of bytes or -1 if the string is unparseable
263  */
264 long nl_size2int(const char *str)
265 {
266  char *p;
267  long l = strtol(str, &p, 0);
268  if (p == str)
269  return -NLE_INVAL;
270 
271  if (*p) {
272  if (!strcasecmp(p, "kb") || !strcasecmp(p, "k"))
273  l *= 1024;
274  else if (!strcasecmp(p, "gb") || !strcasecmp(p, "g"))
275  l *= 1024*1024*1024;
276  else if (!strcasecmp(p, "gbit"))
277  l *= 1000000000L/8;
278  else if (!strcasecmp(p, "mb") || !strcasecmp(p, "m"))
279  l *= 1024*1024;
280  else if (!strcasecmp(p, "mbit"))
281  l *= 1000000/8;
282  else if (!strcasecmp(p, "kbit"))
283  l *= 1000/8;
284  else if (!strcasecmp(p, "bit"))
285  l /= 8;
286  else if (strcasecmp(p, "b") != 0)
287  return -NLE_INVAL;
288  }
289 
290  return l;
291 }
292 
293 static const struct {
294  double limit;
295  const char *unit;
296 } size_units[] = {
297  { 1024. * 1024. * 1024. * 1024. * 1024., "EiB" },
298  { 1024. * 1024. * 1024. * 1024., "TiB" },
299  { 1024. * 1024. * 1024., "GiB" },
300  { 1024. * 1024., "MiB" },
301  { 1024., "KiB" },
302  { 0., "B" },
303 };
304 
305 /**
306  * Convert a size toa character string
307  * @arg size Size in number of bytes
308  * @arg buf Buffer to write character string to
309  * @arg len Size of buf
310  *
311  * This function converts a value in bytes to a human readable representation
312  * of it. The function uses IEC prefixes:
313  *
314  * @code
315  * 1024 bytes => 1 KiB
316  * 1048576 bytes => 1 MiB
317  * @endcode
318  *
319  * The highest prefix is used which ensures a result of >= 1.0, the result
320  * is provided as floating point number with a maximum precision of 2 digits:
321  * @code
322  * 965176 bytes => 942.55 KiB
323  * @endcode
324  *
325  * @return pointer to buf
326  */
327 char *nl_size2str(const size_t size, char *buf, const size_t len)
328 {
329  size_t i;
330 
331  if (size == 0) {
332  snprintf(buf, len, "0B");
333  return buf;
334  }
335 
336  for (i = 0; i < ARRAY_SIZE(size_units); i++) {
337  if (size >= size_units[i].limit) {
338  snprintf(buf, len, "%.2g%s",
339  (double) size / size_units[i].limit,
340  size_units[i].unit);
341  return buf;
342  }
343  }
344 
345  BUG();
346 }
347 
348 /**
349  * Convert a character string to a probability
350  * @arg str probability encoded as character string
351  *
352  * Converts the specified probability as character to the
353  * corresponding probability number.
354  *
355  * Supported formats are:
356  * - 0.0-1.0
357  * - 0%-100%
358  *
359  * @return The probability relative to NL_PROB_MIN and NL_PROB_MAX
360  */
361 long nl_prob2int(const char *str)
362 {
363  char *p;
364  double d = strtod(str, &p);
365 
366  if (p == str)
367  return -NLE_INVAL;
368 
369  if (d > 1.0)
370  d /= 100.0f;
371 
372  if (d > 1.0f || d < 0.0f)
373  return -NLE_RANGE;
374 
375  if (*p && strcmp(p, "%") != 0)
376  return -NLE_INVAL;
377 
378  return rint(d * NL_PROB_MAX);
379 }
380 
381 /** @} */
382 
383 /**
384  * @name Time Translations
385  * @{
386  */
387 
388 #ifndef USER_HZ
389 #define USER_HZ 100
390 #endif
391 
392 static uint32_t user_hz = USER_HZ;
393 static uint32_t psched_hz = USER_HZ;
394 
395 static double ticks_per_usec = 1.0f;
396 
397 /* Retrieves the configured HZ and ticks/us value in the kernel.
398  * The value is cached. Supported ways of getting it:
399  *
400  * 1) environment variable
401  * 2) /proc/net/psched and sysconf
402  *
403  * Supports the environment variables:
404  * PROC_NET_PSCHED - may point to psched file in /proc
405  * PROC_ROOT - may point to /proc fs */
406 static void __init get_psched_settings(void)
407 {
408  char name[FILENAME_MAX];
409  FILE *fd;
410  int got_hz = 0;
411 
412  if (getenv("HZ")) {
413  long hz = strtol(getenv("HZ"), NULL, 0);
414 
415  if (LONG_MIN != hz && LONG_MAX != hz) {
416  user_hz = hz;
417  got_hz = 1;
418  }
419  }
420 
421  if (!got_hz)
422  user_hz = sysconf(_SC_CLK_TCK);
423 
424  psched_hz = user_hz;
425 
426  if (getenv("TICKS_PER_USEC")) {
427  double t = strtod(getenv("TICKS_PER_USEC"), NULL);
428  ticks_per_usec = t;
429  }
430  else {
431  if (getenv("PROC_NET_PSCHED"))
432  snprintf(name, sizeof(name), "%s", getenv("PROC_NET_PSCHED"));
433  else if (getenv("PROC_ROOT"))
434  snprintf(name, sizeof(name), "%s/net/psched",
435  getenv("PROC_ROOT"));
436  else
437  strncpy(name, "/proc/net/psched", sizeof(name) - 1);
438 
439  if ((fd = fopen(name, "r"))) {
440  unsigned int ns_per_usec, ns_per_tick, nom, denom;
441 
442  if (fscanf(fd, "%08x %08x %08x %08x",
443  &ns_per_usec, &ns_per_tick, &nom, &denom) != 4) {
444  NL_DBG(1, "Fatal error: can not read psched settings from \"%s\". " \
445  "Try to set TICKS_PER_USEC, PROC_NET_PSCHED or PROC_ROOT " \
446  "environment variables\n", name);
447  exit(1);
448  }
449 
450  ticks_per_usec = (double) ns_per_usec /
451  (double) ns_per_tick;
452 
453  if (nom == 1000000)
454  psched_hz = denom;
455 
456  fclose(fd);
457  }
458  }
459 }
460 
461 
462 /**
463  * Return the value of HZ
464  */
465 int nl_get_user_hz(void)
466 {
467  return user_hz;
468 }
469 
470 /**
471  * Return the value of packet scheduler HZ
472  */
474 {
475  return psched_hz;
476 }
477 
478 /**
479  * Convert micro seconds to ticks
480  * @arg us micro seconds
481  * @return number of ticks
482  */
483 uint32_t nl_us2ticks(uint32_t us)
484 {
485  return us * ticks_per_usec;
486 }
487 
488 
489 /**
490  * Convert ticks to micro seconds
491  * @arg ticks number of ticks
492  * @return microseconds
493  */
494 uint32_t nl_ticks2us(uint32_t ticks)
495 {
496  return ticks / ticks_per_usec;
497 }
498 
499 int nl_str2msec(const char *str, uint64_t *result)
500 {
501  uint64_t total = 0, l;
502  int plen;
503  char *p;
504 
505  do {
506  l = strtoul(str, &p, 0);
507  if (p == str)
508  return -NLE_INVAL;
509  else if (*p) {
510  plen = strcspn(p, " \t");
511 
512  if (!plen)
513  total += l;
514  else if (!strncasecmp(p, "sec", plen))
515  total += (l * 1000);
516  else if (!strncasecmp(p, "min", plen))
517  total += (l * 1000*60);
518  else if (!strncasecmp(p, "hour", plen))
519  total += (l * 1000*60*60);
520  else if (!strncasecmp(p, "day", plen))
521  total += (l * 1000*60*60*24);
522  else
523  return -NLE_INVAL;
524 
525  str = p + plen;
526  } else
527  total += l;
528  } while (*str && *p);
529 
530  *result = total;
531 
532  return 0;
533 }
534 
535 /**
536  * Convert milliseconds to a character string
537  * @arg msec number of milliseconds
538  * @arg buf destination buffer
539  * @arg len buffer length
540  *
541  * Converts milliseconds to a character string split up in days, hours,
542  * minutes, seconds, and milliseconds and stores it in the specified
543  * destination buffer.
544  *
545  * @return The destination buffer.
546  */
547 char * nl_msec2str(uint64_t msec, char *buf, size_t len)
548 {
549  uint64_t split[5];
550  size_t i;
551  static const char *units[5] = {"d", "h", "m", "s", "msec"};
552  char * const buf_orig = buf;
553 
554  if (msec == 0) {
555  snprintf(buf, len, "0msec");
556  return buf_orig;
557  }
558 
559 #define _SPLIT(idx, unit) if ((split[idx] = msec / unit)) msec %= unit
560  _SPLIT(0, 86400000); /* days */
561  _SPLIT(1, 3600000); /* hours */
562  _SPLIT(2, 60000); /* minutes */
563  _SPLIT(3, 1000); /* seconds */
564 #undef _SPLIT
565  split[4] = msec;
566 
567  for (i = 0; i < ARRAY_SIZE(split) && len; i++) {
568  int l;
569  if (split[i] == 0)
570  continue;
571  l = snprintf(buf, len, "%s%" PRIu64 "%s",
572  (buf==buf_orig) ? "" : " ", split[i], units[i]);
573  buf += l;
574  len -= l;
575  }
576 
577  return buf_orig;
578 }
579 
580 /** @} */
581 
582 /**
583  * @name Netlink Family Translations
584  * @{
585  */
586 
587 static const struct trans_tbl nlfamilies[] = {
588  __ADD(NETLINK_ROUTE,route),
589  __ADD(NETLINK_USERSOCK,usersock),
590  __ADD(NETLINK_FIREWALL,firewall),
591  __ADD(NETLINK_INET_DIAG,inetdiag),
592  __ADD(NETLINK_NFLOG,nflog),
593  __ADD(NETLINK_XFRM,xfrm),
594  __ADD(NETLINK_SELINUX,selinux),
595  __ADD(NETLINK_ISCSI,iscsi),
596  __ADD(NETLINK_AUDIT,audit),
597  __ADD(NETLINK_FIB_LOOKUP,fib_lookup),
598  __ADD(NETLINK_CONNECTOR,connector),
599  __ADD(NETLINK_NETFILTER,netfilter),
600  __ADD(NETLINK_IP6_FW,ip6_fw),
601  __ADD(NETLINK_DNRTMSG,dnrtmsg),
602  __ADD(NETLINK_KOBJECT_UEVENT,kobject_uevent),
603  __ADD(NETLINK_GENERIC,generic),
604  __ADD(NETLINK_SCSITRANSPORT,scsitransport),
605  __ADD(NETLINK_ECRYPTFS,ecryptfs),
606  __ADD(NETLINK_RDMA,rdma),
607  __ADD(NETLINK_CRYPTO,crypto),
608 };
609 
610 char * nl_nlfamily2str(int family, char *buf, size_t size)
611 {
612  return __type2str(family, buf, size, nlfamilies,
613  ARRAY_SIZE(nlfamilies));
614 }
615 
616 int nl_str2nlfamily(const char *name)
617 {
618  return __str2type(name, nlfamilies, ARRAY_SIZE(nlfamilies));
619 }
620 
621 /**
622  * @}
623  */
624 
625 /**
626  * @name Link Layer Protocol Translations
627  * @{
628  */
629 
630 static const struct trans_tbl llprotos[] = {
631  {0, "generic"},
632  __ADD(ARPHRD_NETROM,netrom),
633  __ADD(ARPHRD_ETHER,ether),
634  __ADD(ARPHRD_EETHER,eether),
635  __ADD(ARPHRD_AX25,ax25),
636  __ADD(ARPHRD_PRONET,pronet),
637  __ADD(ARPHRD_CHAOS,chaos),
638  __ADD(ARPHRD_IEEE802,ieee802),
639  __ADD(ARPHRD_ARCNET,arcnet),
640  __ADD(ARPHRD_APPLETLK,atalk),
641  __ADD(ARPHRD_DLCI,dlci),
642  __ADD(ARPHRD_ATM,atm),
643  __ADD(ARPHRD_METRICOM,metricom),
644  __ADD(ARPHRD_IEEE1394,ieee1394),
645  __ADD(ARPHRD_EUI64,eui64),
646  __ADD(ARPHRD_INFINIBAND,infiniband),
647  __ADD(ARPHRD_SLIP,slip),
648  __ADD(ARPHRD_CSLIP,cslip),
649  __ADD(ARPHRD_SLIP6,slip6),
650  __ADD(ARPHRD_CSLIP6,cslip6),
651  __ADD(ARPHRD_RSRVD,rsrvd),
652  __ADD(ARPHRD_ADAPT,adapt),
653  __ADD(ARPHRD_ROSE,rose),
654  __ADD(ARPHRD_X25,x25),
655  __ADD(ARPHRD_HWX25,hwx25),
656  __ADD(ARPHRD_CAN,can),
657  __ADD(ARPHRD_PPP,ppp),
658  __ADD(ARPHRD_CISCO,cisco),
659  __ADD(ARPHRD_HDLC,hdlc),
660  __ADD(ARPHRD_LAPB,lapb),
661  __ADD(ARPHRD_DDCMP,ddcmp),
662  __ADD(ARPHRD_RAWHDLC,rawhdlc),
663  __ADD(ARPHRD_TUNNEL,ipip),
664  __ADD(ARPHRD_TUNNEL6,tunnel6),
665  __ADD(ARPHRD_FRAD,frad),
666  __ADD(ARPHRD_SKIP,skip),
667  __ADD(ARPHRD_LOOPBACK,loopback),
668  __ADD(ARPHRD_LOCALTLK,localtlk),
669  __ADD(ARPHRD_FDDI,fddi),
670  __ADD(ARPHRD_BIF,bif),
671  __ADD(ARPHRD_SIT,sit),
672  __ADD(ARPHRD_IPDDP,ip/ddp),
673  __ADD(ARPHRD_IPGRE,gre),
674  __ADD(ARPHRD_PIMREG,pimreg),
675  __ADD(ARPHRD_HIPPI,hippi),
676  __ADD(ARPHRD_ASH,ash),
677  __ADD(ARPHRD_ECONET,econet),
678  __ADD(ARPHRD_IRDA,irda),
679  __ADD(ARPHRD_FCPP,fcpp),
680  __ADD(ARPHRD_FCAL,fcal),
681  __ADD(ARPHRD_FCPL,fcpl),
682  __ADD(ARPHRD_FCFABRIC,fcfb_0),
683  __ADD(ARPHRD_FCFABRIC+1,fcfb_1),
684  __ADD(ARPHRD_FCFABRIC+2,fcfb_2),
685  __ADD(ARPHRD_FCFABRIC+3,fcfb_3),
686  __ADD(ARPHRD_FCFABRIC+4,fcfb_4),
687  __ADD(ARPHRD_FCFABRIC+5,fcfb_5),
688  __ADD(ARPHRD_FCFABRIC+6,fcfb_6),
689  __ADD(ARPHRD_FCFABRIC+7,fcfb_7),
690  __ADD(ARPHRD_FCFABRIC+8,fcfb_8),
691  __ADD(ARPHRD_FCFABRIC+9,fcfb_9),
692  __ADD(ARPHRD_FCFABRIC+10,fcfb_10),
693  __ADD(ARPHRD_FCFABRIC+11,fcfb_11),
694  __ADD(ARPHRD_FCFABRIC+12,fcfb_12),
695  __ADD(ARPHRD_IEEE802_TR,tr),
696  __ADD(ARPHRD_IEEE80211,ieee802.11),
697  __ADD(ARPHRD_IEEE80211_PRISM,ieee802.11_prism),
698  __ADD(ARPHRD_IEEE80211_RADIOTAP,ieee802.11_radiotap),
699  __ADD(ARPHRD_IEEE802154,ieee802.15.4),
700  __ADD(ARPHRD_IEEE802154_MONITOR,ieee802.15.4_monitor),
701  __ADD(ARPHRD_PHONET,phonet),
702  __ADD(ARPHRD_PHONET_PIPE,phonet_pipe),
703  __ADD(ARPHRD_CAIF,caif),
704  __ADD(ARPHRD_IP6GRE,ip6gre),
705  __ADD(ARPHRD_NETLINK,netlink),
706  __ADD(ARPHRD_6LOWPAN,6lowpan),
707  __ADD(ARPHRD_VOID,void),
708  __ADD(ARPHRD_NONE,nohdr),
709 };
710 
711 char * nl_llproto2str(int llproto, char *buf, size_t len)
712 {
713  return __type2str(llproto, buf, len, llprotos, ARRAY_SIZE(llprotos));
714 }
715 
716 int nl_str2llproto(const char *name)
717 {
718  return __str2type(name, llprotos, ARRAY_SIZE(llprotos));
719 }
720 
721 /** @} */
722 
723 
724 /**
725  * @name Ethernet Protocol Translations
726  * @{
727  */
728 
729 static const struct trans_tbl ether_protos[] = {
730  __ADD(ETH_P_LOOP,loop),
731  __ADD(ETH_P_PUP,pup),
732  __ADD(ETH_P_PUPAT,pupat),
733  __ADD(ETH_P_IP,ip),
734  __ADD(ETH_P_X25,x25),
735  __ADD(ETH_P_ARP,arp),
736  __ADD(ETH_P_BPQ,bpq),
737  __ADD(ETH_P_IEEEPUP,ieeepup),
738  __ADD(ETH_P_IEEEPUPAT,ieeepupat),
739  __ADD(ETH_P_DEC,dec),
740  __ADD(ETH_P_DNA_DL,dna_dl),
741  __ADD(ETH_P_DNA_RC,dna_rc),
742  __ADD(ETH_P_DNA_RT,dna_rt),
743  __ADD(ETH_P_LAT,lat),
744  __ADD(ETH_P_DIAG,diag),
745  __ADD(ETH_P_CUST,cust),
746  __ADD(ETH_P_SCA,sca),
747  __ADD(ETH_P_TEB,teb),
748  __ADD(ETH_P_RARP,rarp),
749  __ADD(ETH_P_ATALK,atalk),
750  __ADD(ETH_P_AARP,aarp),
751 #ifdef ETH_P_8021Q
752  __ADD(ETH_P_8021Q,802.1q),
753 #endif
754  __ADD(ETH_P_IPX,ipx),
755  __ADD(ETH_P_IPV6,ipv6),
756  __ADD(ETH_P_PAUSE,pause),
757  __ADD(ETH_P_SLOW,slow),
758 #ifdef ETH_P_WCCP
759  __ADD(ETH_P_WCCP,wccp),
760 #endif
761  __ADD(ETH_P_PPP_DISC,ppp_disc),
762  __ADD(ETH_P_PPP_SES,ppp_ses),
763  __ADD(ETH_P_MPLS_UC,mpls_uc),
764  __ADD(ETH_P_MPLS_MC,mpls_mc),
765  __ADD(ETH_P_ATMMPOA,atmmpoa),
766  __ADD(ETH_P_LINK_CTL,link_ctl),
767  __ADD(ETH_P_ATMFATE,atmfate),
768  __ADD(ETH_P_PAE,pae),
769  __ADD(ETH_P_AOE,aoe),
770  __ADD(ETH_P_TIPC,tipc),
771  __ADD(ETH_P_1588,ieee1588),
772  __ADD(ETH_P_FCOE,fcoe),
773  __ADD(ETH_P_FIP,fip),
774  __ADD(ETH_P_EDSA,edsa),
775  __ADD(ETH_P_EDP2,edp2),
776  __ADD(ETH_P_802_3,802.3),
777  __ADD(ETH_P_AX25,ax25),
778  __ADD(ETH_P_ALL,all),
779  __ADD(ETH_P_802_2,802.2),
780  __ADD(ETH_P_SNAP,snap),
781  __ADD(ETH_P_DDCMP,ddcmp),
782  __ADD(ETH_P_WAN_PPP,wan_ppp),
783  __ADD(ETH_P_PPP_MP,ppp_mp),
784  __ADD(ETH_P_LOCALTALK,localtalk),
785  __ADD(ETH_P_CAN,can),
786  __ADD(ETH_P_PPPTALK,ppptalk),
787  __ADD(ETH_P_TR_802_2,tr_802.2),
788  __ADD(ETH_P_MOBITEX,mobitex),
789  __ADD(ETH_P_CONTROL,control),
790  __ADD(ETH_P_IRDA,irda),
791  __ADD(ETH_P_ECONET,econet),
792  __ADD(ETH_P_HDLC,hdlc),
793  __ADD(ETH_P_ARCNET,arcnet),
794  __ADD(ETH_P_DSA,dsa),
795  __ADD(ETH_P_TRAILER,trailer),
796  __ADD(ETH_P_PHONET,phonet),
797  __ADD(ETH_P_IEEE802154,ieee802154),
798  __ADD(ETH_P_CAIF,caif),
799 };
800 
801 char *nl_ether_proto2str(int eproto, char *buf, size_t len)
802 {
803  return __type2str(eproto, buf, len, ether_protos,
804  ARRAY_SIZE(ether_protos));
805 }
806 
807 int nl_str2ether_proto(const char *name)
808 {
809  return __str2type(name, ether_protos, ARRAY_SIZE(ether_protos));
810 }
811 
812 /** @} */
813 
814 /**
815  * @name IP Protocol Translations
816  * @{
817  */
818 
819 char *nl_ip_proto2str(int proto, char *buf, size_t len)
820 {
821  struct protoent *p = getprotobynumber(proto);
822 
823  if (p) {
824  snprintf(buf, len, "%s", p->p_name);
825  return buf;
826  }
827 
828  snprintf(buf, len, "0x%x", proto);
829  return buf;
830 }
831 
832 int nl_str2ip_proto(const char *name)
833 {
834  struct protoent *p = getprotobyname(name);
835  unsigned long l;
836  char *end;
837 
838  if (p)
839  return p->p_proto;
840 
841  l = strtoul(name, &end, 0);
842  if (l == ULONG_MAX || *end != '\0')
843  return -NLE_OBJ_NOTFOUND;
844 
845  return (int) l;
846 }
847 
848 /** @} */
849 
850 /**
851  * @name Dumping Helpers
852  * @{
853  */
854 
855 /**
856  * Handle a new line while dumping
857  * @arg params Dumping parameters
858  *
859  * This function must be called before dumping any onto a
860  * new line. It will ensure proper prefixing as specified
861  * by the dumping parameters.
862  *
863  * @note This function will NOT dump any newlines itself
864  */
865 void nl_new_line(struct nl_dump_params *params)
866 {
867  params->dp_line++;
868 
869  if (params->dp_prefix) {
870  int i;
871  for (i = 0; i < params->dp_prefix; i++) {
872  if (params->dp_fd)
873  fprintf(params->dp_fd, " ");
874  else if (params->dp_buf)
875  strncat(params->dp_buf, " ",
876  params->dp_buflen -
877  strlen(params->dp_buf) - 1);
878  }
879  }
880 
881  if (params->dp_nl_cb)
882  params->dp_nl_cb(params, params->dp_line);
883 }
884 
885 static void dump_one(struct nl_dump_params *parms, const char *fmt,
886  va_list args)
887 {
888  if (parms->dp_fd)
889  vfprintf(parms->dp_fd, fmt, args);
890  else if (parms->dp_buf || parms->dp_cb) {
891  char *buf = NULL;
892  if (vasprintf(&buf, fmt, args) >= 0) {
893  if (parms->dp_cb)
894  parms->dp_cb(parms, buf);
895  else
896  strncat(parms->dp_buf, buf,
897  parms->dp_buflen -
898  strlen(parms->dp_buf) - 1);
899  free(buf);
900  }
901  }
902 }
903 
904 
905 /**
906  * Dump a formatted character string
907  * @arg params Dumping parameters
908  * @arg fmt printf style formatting string
909  * @arg ... Arguments to formatting string
910  *
911  * Dumps a printf style formatting string to the output device
912  * as specified by the dumping parameters.
913  */
914 void nl_dump(struct nl_dump_params *params, const char *fmt, ...)
915 {
916  va_list args;
917 
918  va_start(args, fmt);
919  dump_one(params, fmt, args);
920  va_end(args);
921 }
922 
923 void nl_dump_line(struct nl_dump_params *parms, const char *fmt, ...)
924 {
925  va_list args;
926 
927  nl_new_line(parms);
928 
929  va_start(args, fmt);
930  dump_one(parms, fmt, args);
931  va_end(args);
932 }
933 
934 
935 /** @} */
936 
937 /** @cond SKIP */
938 
939 int __trans_list_add(int i, const char *a, struct nl_list_head *head)
940 {
941  struct trans_list *tl;
942 
943  tl = calloc(1, sizeof(*tl));
944  if (!tl)
945  return -NLE_NOMEM;
946 
947  tl->i = i;
948  tl->a = strdup(a);
949 
950  nl_list_add_tail(&tl->list, head);
951 
952  return 0;
953 }
954 
955 void __trans_list_clear(struct nl_list_head *head)
956 {
957  struct trans_list *tl, *next;
958 
959  nl_list_for_each_entry_safe(tl, next, head, list) {
960  free(tl->a);
961  free(tl);
962  }
963 
964  nl_init_list_head(head);
965 }
966 
967 char *__type2str(int type, char *buf, size_t len,
968  const struct trans_tbl *tbl, size_t tbl_len)
969 {
970  size_t i;
971  for (i = 0; i < tbl_len; i++) {
972  if (tbl[i].i == type) {
973  snprintf(buf, len, "%s", tbl[i].a);
974  return buf;
975  }
976  }
977 
978  snprintf(buf, len, "0x%x", type);
979  return buf;
980 }
981 
982 char *__list_type2str(int type, char *buf, size_t len,
983  struct nl_list_head *head)
984 {
985  struct trans_list *tl;
986 
987  nl_list_for_each_entry(tl, head, list) {
988  if (tl->i == type) {
989  snprintf(buf, len, "%s", tl->a);
990  return buf;
991  }
992  }
993 
994  snprintf(buf, len, "0x%x", type);
995  return buf;
996 }
997 
998 char *__flags2str(int flags, char *buf, size_t len,
999  const struct trans_tbl *tbl, size_t tbl_len)
1000 {
1001  size_t i;
1002  int tmp = flags;
1003 
1004  memset(buf, 0, len);
1005 
1006  for (i = 0; i < tbl_len; i++) {
1007  if (tbl[i].i & tmp) {
1008  tmp &= ~tbl[i].i;
1009  strncat(buf, tbl[i].a, len - strlen(buf) - 1);
1010  if ((tmp & flags))
1011  strncat(buf, ",", len - strlen(buf) - 1);
1012  }
1013  }
1014 
1015  return buf;
1016 }
1017 
1018 int __str2type(const char *buf, const struct trans_tbl *tbl, size_t tbl_len)
1019 {
1020  unsigned long l;
1021  char *end;
1022  size_t i;
1023 
1024  if (*buf == '\0')
1025  return -NLE_INVAL;
1026 
1027  for (i = 0; i < tbl_len; i++)
1028  if (!strcasecmp(tbl[i].a, buf))
1029  return tbl[i].i;
1030 
1031  l = strtoul(buf, &end, 0);
1032  if (l == ULONG_MAX || *end != '\0')
1033  return -NLE_OBJ_NOTFOUND;
1034 
1035  return (int) l;
1036 }
1037 
1038 int __list_str2type(const char *buf, struct nl_list_head *head)
1039 {
1040  struct trans_list *tl;
1041  unsigned long l;
1042  char *end;
1043 
1044  if (*buf == '\0')
1045  return -NLE_INVAL;
1046 
1047  nl_list_for_each_entry(tl, head, list) {
1048  if (!strcasecmp(tl->a, buf))
1049  return tl->i;
1050  }
1051 
1052  l = strtoul(buf, &end, 0);
1053  if (l == ULONG_MAX || *end != '\0')
1054  return -NLE_OBJ_NOTFOUND;
1055 
1056  return (int) l;
1057 }
1058 
1059 int __str2flags(const char *buf, const struct trans_tbl *tbl, size_t tbl_len)
1060 {
1061  int flags = 0;
1062  size_t i;
1063  size_t len; /* ptrdiff_t ? */
1064  char *p = (char *) buf, *t;
1065 
1066  for (;;) {
1067  if (*p == ' ')
1068  p++;
1069 
1070  t = strchr(p, ',');
1071  len = t ? t - p : strlen(p);
1072  for (i = 0; i < tbl_len; i++)
1073  if (len == strlen(tbl[i].a) &&
1074  !strncasecmp(tbl[i].a, p, len))
1075  flags |= tbl[i].i;
1076 
1077  if (!t)
1078  return flags;
1079 
1080  p = ++t;
1081  }
1082 
1083  return 0;
1084 }
1085 
1086 void dump_from_ops(struct nl_object *obj, struct nl_dump_params *params)
1087 {
1088  int type = params->dp_type;
1089 
1090  if (type < 0 || type > NL_DUMP_MAX)
1091  BUG();
1092 
1093  params->dp_line = 0;
1094 
1095  if (params->dp_dump_msgtype) {
1096 #if 0
1097  /* XXX */
1098  char buf[64];
1099 
1100  dp_dump_line(params, 0, "%s ",
1101  nl_cache_mngt_type2name(obj->ce_ops,
1102  obj->ce_ops->co_protocol,
1103  obj->ce_msgtype,
1104  buf, sizeof(buf)));
1105 #endif
1106  params->dp_pre_dump = 1;
1107  }
1108 
1109  if (obj->ce_ops->oo_dump[type])
1110  obj->ce_ops->oo_dump[type](obj, params);
1111 }
1112 
1113 /**
1114  * Check for library capabilities
1115  *
1116  * @arg capability capability identifier
1117  *
1118  * Check whether the loaded libnl library supports a certain capability.
1119  * This is useful so that applications can workaround known issues of
1120  * libnl that are fixed in newer library versions, without
1121  * having a hard dependency on the new version. It is also useful, for
1122  * capabilities that cannot easily be detected using autoconf tests.
1123  * The capabilities are integer constants with name NL_CAPABILITY_*.
1124  *
1125  * As this function is intended to detect capabilities at runtime,
1126  * you might not want to depend during compile time on the NL_CAPABILITY_*
1127  * names. Instead you can use their numeric values which are guaranteed not to
1128  * change meaning.
1129  *
1130  * @return non zero if libnl supports a certain capability, 0 otherwise.
1131  **/
1132 int nl_has_capability (int capability)
1133 {
1134  static const uint8_t caps[ ( NL_CAPABILITY_MAX + 7 ) / 8 ] = {
1135 #define _NL_ASSERT(expr) ( 0 * sizeof(struct { unsigned int x: ( (!!(expr)) ? 1 : -1 ); }) )
1136 #define _NL_SETV(i, r, v) \
1137  ( _NL_ASSERT( (v) == 0 || (i) * 8 + (r) == (v) - 1 ) + \
1138  ( (v) == 0 ? 0 : (1 << (r)) ) )
1139 #define _NL_SET(i, v0, v1, v2, v3, v4, v5, v6, v7) \
1140  [(i)] = ( \
1141  _NL_SETV((i), 0, (v0)) | _NL_SETV((i), 4, (v4)) | \
1142  _NL_SETV((i), 1, (v1)) | _NL_SETV((i), 5, (v5)) | \
1143  _NL_SETV((i), 2, (v2)) | _NL_SETV((i), 6, (v6)) | \
1144  _NL_SETV((i), 3, (v3)) | _NL_SETV((i), 7, (v7)) )
1145  _NL_SET(0,
1147  NL_CAPABILITY_ROUTE_LINK_VETH_GET_PEER_OWN_REFERENCE,
1148  NL_CAPABILITY_ROUTE_LINK_CLS_ADD_ACT_OWN_REFERENCE,
1149  NL_CAPABILITY_NL_CONNECT_RETRY_GENERATE_PORT_ON_ADDRINUSE,
1150  NL_CAPABILITY_ROUTE_LINK_GET_KERNEL_FAIL_OPNOTSUPP,
1151  NL_CAPABILITY_ROUTE_ADDR_COMPARE_CACHEINFO,
1152  NL_CAPABILITY_VERSION_3_2_26,
1153  NL_CAPABILITY_NL_RECV_FAIL_TRUNC_NO_PEEK),
1154  _NL_SET(1,
1155  NL_CAPABILITY_LINK_BUILD_CHANGE_REQUEST_SET_CHANGE,
1156  NL_CAPABILITY_RTNL_NEIGH_GET_FILTER_AF_UNSPEC_FIX,
1157  NL_CAPABILITY_VERSION_3_2_27,
1158  NL_CAPABILITY_RTNL_LINK_VLAN_PROTOCOL_SERIALZE,
1159  NL_CAPABILITY_RTNL_LINK_PARSE_GRE_REMOTE,
1160  NL_CAPABILITY_RTNL_LINK_VLAN_INGRESS_MAP_CLEAR,
1161  NL_CAPABILITY_RTNL_LINK_VXLAN_IO_COMPARE,
1162  NL_CAPABILITY_NL_OBJECT_DIFF64),
1163  _NL_SET (2,
1164  NL_CAPABILITY_XFRM_SA_KEY_SIZE,
1165  NL_CAPABILITY_RTNL_ADDR_PEER_FIX,
1166  NL_CAPABILITY_VERSION_3_2_28,
1167  0,
1168  0,
1169  0,
1170  0,
1171  0),
1172  /* IMPORTANT: these capability numbers are intended to be universal and stable
1173  * for libnl3. Don't allocate new numbers on your own that differ from upstream
1174  * libnl3.
1175  *
1176  * Instead register a capability number upstream too. We will take patches
1177  * for that. We especially take patches to register a capability number that is
1178  * only implemented in your fork of libnl3.
1179  *
1180  * If you really don't want that, use capabilities in the range 0x7000 to 0x7FFF.
1181  * (NL_CAPABILITY_IS_USER_RESERVED). Upstream libnl3 will not register conflicting
1182  * capabilities in that range.
1183  *
1184  * Obviously, only backport capability numbers to libnl versions that actually
1185  * implement that capability as well. */
1186 #undef _NL_SET
1187 #undef _NL_SETV
1188 #undef _NL_ASSERT
1189  };
1190 
1191  if (capability <= 0 || capability > NL_CAPABILITY_MAX)
1192  return 0;
1193  capability--;
1194  return (caps[capability / 8] & (1 << (capability % 8))) != 0;
1195 }
1196 
1197 /** @endcond */
1198 
1199 /** @} */
int nl_get_user_hz(void)
Return the value of HZ.
Definition: utils.c:465
void nl_new_line(struct nl_dump_params *params)
Handle a new line while dumping.
Definition: utils.c:865
char * dp_buf
Alternatively the output may be redirected into a buffer.
Definition: types.h:88
FILE * dp_fd
File descriptor the dumping output should go to.
Definition: types.h:83
void(* dp_cb)(struct nl_dump_params *, char *)
A callback invoked for output.
Definition: types.h:63
rtnl_route_build_msg() no longer guesses the route scope if explicitly set to RT_SCOPE_NOWHERE.
Definition: utils.h:90
long nl_size2int(const char *str)
Convert a character string to a size.
Definition: utils.c:264
double nl_cancel_down_bits(unsigned long long l, char **unit)
Cancel down a bit counter.
Definition: utils.c:170
enum nl_dump_type dp_type
Specifies the type of dump that is requested.
Definition: types.h:38
char * nl_msec2str(uint64_t msec, char *buf, size_t len)
Convert milliseconds to a character string.
Definition: utils.c:547
#define NL_PROB_MAX
Upper probability limit nl_dump_type.
Definition: utils.h:37
Dump all attributes but no statistics.
Definition: types.h:23
char * nl_size2str(const size_t size, char *buf, const size_t len)
Convert a size toa character string.
Definition: utils.c:327
void(* dp_nl_cb)(struct nl_dump_params *, int)
A callback invoked for every new line, can be used to customize the indentation.
Definition: types.h:73
double nl_cancel_down_bytes(unsigned long long l, char **unit)
Cancel down a byte counter.
Definition: utils.c:139
int dp_pre_dump
PRIVATE Set if a dump was performed prior to the actual dump handler.
Definition: types.h:99
double nl_cancel_down_us(uint32_t l, char **unit)
Cancel down a micro second value.
Definition: utils.c:227
int nl_get_psched_hz(void)
Return the value of packet scheduler HZ.
Definition: utils.c:473
uint32_t nl_ticks2us(uint32_t ticks)
Convert ticks to micro seconds.
Definition: utils.c:494
long nl_prob2int(const char *str)
Convert a character string to a probability.
Definition: utils.c:361
int dp_prefix
Specifies the number of whitespaces to be put in front of every new line (indentation).
Definition: types.h:44
uint32_t nl_us2ticks(uint32_t us)
Convert micro seconds to ticks.
Definition: utils.c:483
Dumping parameters.
Definition: types.h:33
size_t dp_buflen
Length of the buffer dp_buf.
Definition: types.h:93
void nl_dump(struct nl_dump_params *params, const char *fmt,...)
Dump a formatted character string.
Definition: utils.c:914
int nl_debug
Global variable indicating the desired level of debugging output.
Definition: utils.c:49
int dp_dump_msgtype
Causes each element to be prefixed with the message type.
Definition: types.h:54