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