src/nm-core-utils.c

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
   2 /* NetworkManager -- Network link manager
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  *
  18  * Copyright 2004 - 2014 Red Hat, Inc.
  19  * Copyright 2005 - 2008 Novell, Inc.
  20  */
  21
  22 #include "nm-default.h"
  23
  24 #include "nm-core-utils.h"
  25
  26 #include <errno.h>
  27 #include <fcntl.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30 #include <stdlib.h>
  31 #include <resolv.h>
  32 #include <sys/types.h>
  33 #include <sys/wait.h>
  34 #include <sys/stat.h>
  35 #include <linux/if.h>
  36 #include <linux/if_infiniband.h>
  37 #include <net/ethernet.h>
  38
  39 #include "nm-utils.h"
  40 #include "nm-core-internal.h"
  41 #include "nm-setting-connection.h"
  42 #include "nm-setting-ip4-config.h"
  43 #include "nm-setting-ip6-config.h"
  44 #include "nm-setting-wireless.h"
  45 #include "nm-setting-wireless-security.h"
  46
  47 /*
  48  * Some toolchains (E.G. uClibc 0.9.33 and earlier) don't export
  49  * CLOCK_BOOTTIME even though the kernel supports it, so provide a
  50  * local definition
  51  */
  52 #ifndef CLOCK_BOOTTIME
  53 #define CLOCK_BOOTTIME 7
  54 #endif
  55
  56 G_STATIC_ASSERT (sizeof (NMUtilsTestFlags) <= sizeof (int));
  57 int _nm_utils_testing = 0;
  58
  59 gboolean
  60 nm_utils_get_testing_initialized ()
  61 {
  62         NMUtilsTestFlags flags;
  63
  64         flags = (NMUtilsTestFlags) _nm_utils_testing;
  65         if (flags == NM_UTILS_TEST_NONE)
  66                 flags = (NMUtilsTestFlags) g_atomic_int_get (&_nm_utils_testing);
  67         return flags != NM_UTILS_TEST_NONE;
  68 }
  69
  70 NMUtilsTestFlags
  71 nm_utils_get_testing ()
  72 {
  73         NMUtilsTestFlags flags;
  74
  75         flags = (NMUtilsTestFlags) _nm_utils_testing;
  76         if (flags != NM_UTILS_TEST_NONE) {
  77                 /* Flags already initialized. Return them. */
  78                 return flags & NM_UTILS_TEST_ALL;
  79         }
  80
  81         /* Accessing nm_utils_get_testing() causes us to set the flags to initialized.
  82          * Detecting running tests also based on g_test_initialized(). */
  83         flags = _NM_UTILS_TEST_INITIALIZED;
  84         if (g_test_initialized ())
  85                 flags |= _NM_UTILS_TEST_GENERAL;
  86
  87         if (g_atomic_int_compare_and_exchange (&_nm_utils_testing, 0, (int) flags)) {
  88                 /* Done. We set it. */
  89                 return flags & NM_UTILS_TEST_ALL;
  90         }
  91         /* It changed in the meantime (??). Re-read the value. */
  92         return ((NMUtilsTestFlags) _nm_utils_testing) & NM_UTILS_TEST_ALL;
  93 }
  94
  95 void
  96 _nm_utils_set_testing (NMUtilsTestFlags flags)
  97 {
  98         g_assert (!NM_FLAGS_ANY (flags, ~NM_UTILS_TEST_ALL));
  99
 100         /* mask out everything except ALL, and always set GENERAL. */
 101         flags = (flags & NM_UTILS_TEST_ALL) | (_NM_UTILS_TEST_GENERAL | _NM_UTILS_TEST_INITIALIZED);
 102
 103         if (!g_atomic_int_compare_and_exchange (&_nm_utils_testing, 0, (int) flags)) {
 104                 /* We only allow setting _nm_utils_set_testing() once, before fetching the
 105                  * value with nm_utils_get_testing(). */
 106                 g_return_if_reached ();
 107         }
 108 }
 109
 110 /*****************************************************************************/
 111
 112 G_DEFINE_QUARK (nm-utils-error-quark, nm_utils_error)
 113
 114 void
 115 nm_utils_error_set_cancelled (GError **error,
 116                               gboolean is_disposing,
 117                               const char *instance_name)
 118 {
 119         if (is_disposing) {
 120                 g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_CANCELLED_DISPOSING,
 121                              "Disposing %s instance",
 122                              instance_name && *instance_name ? instance_name : "source");
 123         } else {
 124                 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CANCELLED,
 125                                      "Request cancelled");
 126         }
 127 }
 128
 129 gboolean
 130 nm_utils_error_is_cancelled (GError *error,
 131                              gboolean consider_is_disposing)
 132 {
 133         if (error) {
 134                 if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
 135                         return TRUE;
 136                 if (   consider_is_disposing
 137                     && g_error_matches (error, NM_UTILS_ERROR, NM_UTILS_ERROR_CANCELLED_DISPOSING))
 138                         return TRUE;
 139         }
 140         return FALSE;
 141 }
 142
 143 /*****************************************************************************/
 144
 145 static GSList *_singletons = NULL;
 146 static gboolean _singletons_shutdown = FALSE;
 147
 148 static void
 149 _nm_singleton_instance_weak_cb (gpointer data,
 150                                 GObject *where_the_object_was)
 151 {
 152         _singletons = g_slist_remove (_singletons, where_the_object_was);
 153 }
 154
 155 static void __attribute__((destructor))
 156 _nm_singleton_instance_destroy (void)
 157 {
 158         _singletons_shutdown = TRUE;
 159
 160         while (_singletons) {
 161                 GObject *instance = _singletons->data;
 162
 163                 _singletons = g_slist_delete_link (_singletons, _singletons);
 164
 165                 g_object_weak_unref (instance, _nm_singleton_instance_weak_cb, NULL);
 166
 167                 if (instance->ref_count > 1)
 168                         nm_log_dbg (LOGD_CORE, "disown %s singleton (%p)", G_OBJECT_TYPE_NAME (instance), instance);
 169
 170                 g_object_unref (instance);
 171         }
 172 }
 173
 174 void
 175 _nm_singleton_instance_register_destruction (GObject *instance)
 176 {
 177         g_return_if_fail (G_IS_OBJECT (instance));
 178
 179         /* Don't allow registration after shutdown. We only destroy the singletons
 180          * once. */
 181         g_return_if_fail (!_singletons_shutdown);
 182
 183         g_object_weak_ref (instance, _nm_singleton_instance_weak_cb, NULL);
 184
 185         _singletons = g_slist_prepend (_singletons, instance);
 186 }
 187
 188 /*****************************************************************************/
 189
 190 gint
 191 nm_utils_ascii_str_to_bool (const char *str,
 192                             gint default_value)
 193 {
 194         gsize len;
 195         char *s = NULL;
 196
 197         if (!str)
 198                 return default_value;
 199
 200         while (str[0] && g_ascii_isspace (str[0]))
 201                 str++;
 202
 203         if (!str[0])
 204                 return default_value;
 205
 206         len = strlen (str);
 207         if (g_ascii_isspace (str[len - 1])) {
 208                 s = g_strdup (str);
 209                 g_strchomp (s);
 210                 str = s;
 211         }
 212
 213         if (!g_ascii_strcasecmp (str, "true") || !g_ascii_strcasecmp (str, "yes") || !g_ascii_strcasecmp (str, "on") || !g_ascii_strcasecmp (str, "1"))
 214                 default_value = TRUE;
 215         else if (!g_ascii_strcasecmp (str, "false") || !g_ascii_strcasecmp (str, "no") || !g_ascii_strcasecmp (str, "off") || !g_ascii_strcasecmp (str, "0"))
 216                 default_value = FALSE;
 217         if (s)
 218                 g_free (s);
 219         return default_value;
 220 }
 221
 222 /*****************************************************************************/
 223
 224 /*
 225  * nm_ethernet_address_is_valid:
 226  * @addr: pointer to a binary or ASCII Ethernet address
 227  * @len: length of @addr, or -1 if @addr is ASCII
 228  *
 229  * Compares an Ethernet address against known invalid addresses.
 230
 231  * Returns: %TRUE if @addr is a valid Ethernet address, %FALSE if it is not.
 232  */
 233 gboolean
 234 nm_ethernet_address_is_valid (gconstpointer addr, gssize len)
 235 {
 236         guint8 invalid_addr[4][ETH_ALEN] = {
 237             {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
 238             {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 239             {0x44, 0x44, 0x44, 0x44, 0x44, 0x44},
 240             {0x00, 0x30, 0xb4, 0x00, 0x00, 0x00}, /* prism54 dummy MAC */
 241         };
 242         guint8 addr_bin[ETH_ALEN];
 243         guint i;
 244
 245         if (!addr) {
 246                 g_return_val_if_fail (len == -1 || len == ETH_ALEN, FALSE);
 247                 return FALSE;
 248         }
 249
 250         if (len == -1) {
 251                 if (!nm_utils_hwaddr_aton (addr, addr_bin, ETH_ALEN))
 252                         return FALSE;
 253                 addr = addr_bin;
 254         } else if (len != ETH_ALEN)
 255                 g_return_val_if_reached (FALSE);
 256
 257         /* Check for multicast address */
 258         if ((((guint8 *) addr)[0]) & 0x01)
 259                 return FALSE;
 260
 261         for (i = 0; i < G_N_ELEMENTS (invalid_addr); i++) {
 262                 if (nm_utils_hwaddr_matches (addr, ETH_ALEN, invalid_addr[i], ETH_ALEN))
 263                         return FALSE;
 264         }
 265
 266         return TRUE;
 267 }
 268
 269
 270 /* nm_utils_ip4_address_clear_host_address:
 271  * @addr: source ip6 address
 272  * @plen: prefix length of network
 273  *
 274  * returns: the input address, with the host address set to 0.
 275  */
 276 in_addr_t
 277 nm_utils_ip4_address_clear_host_address (in_addr_t addr, guint8 plen)
 278 {
 279         return addr & nm_utils_ip4_prefix_to_netmask (plen);
 280 }
 281
 282 /* nm_utils_ip6_address_clear_host_address:
 283  * @dst: destination output buffer, will contain the network part of the @src address
 284  * @src: source ip6 address
 285  * @plen: prefix length of network
 286  *
 287  * Note: this function is self assignment safe, to update @src inplace, set both
 288  * @dst and @src to the same destination.
 289  */
 290 const struct in6_addr *
 291 nm_utils_ip6_address_clear_host_address (struct in6_addr *dst, const struct in6_addr *src, guint8 plen)
 292 {
 293         g_return_val_if_fail (plen <= 128, NULL);
 294         g_return_val_if_fail (src, NULL);
 295         g_return_val_if_fail (dst, NULL);
 296
 297         if (plen < 128) {
 298                 guint nbytes = plen / 8;
 299                 guint nbits = plen % 8;
 300
 301                 if (nbytes && dst != src)
 302                         memcpy (dst, src, nbytes);
 303                 if (nbits) {
 304                         dst->s6_addr[nbytes] = (src->s6_addr[nbytes] & (0xFF << (8 - nbits)));
 305                         nbytes++;
 306                 }
 307                 if (nbytes <= 15)
 308                         memset (&dst->s6_addr[nbytes], 0, 16 - nbytes);
 309         } else if (src != dst)
 310                 *dst = *src;
 311
 312         return dst;
 313 }
 314
 315 void
 316 nm_utils_array_remove_at_indexes (GArray *array, const guint *indexes_to_delete, gsize len)
 317 {
 318         gsize elt_size;
 319         guint index_to_delete;
 320         guint i_src;
 321         guint mm_src, mm_dst, mm_len;
 322         gsize i_itd;
 323         guint res_length;
 324
 325         g_return_if_fail (array);
 326         if (!len)
 327                 return;
 328         g_return_if_fail (indexes_to_delete);
 329
 330         elt_size = g_array_get_element_size (array);
 331
 332         i_itd = 0;
 333         index_to_delete = indexes_to_delete[0];
 334         if (index_to_delete >= array->len)
 335                 g_return_if_reached ();
 336
 337         res_length = array->len - 1;
 338
 339         mm_dst = index_to_delete;
 340         mm_src = index_to_delete;
 341         mm_len = 0;
 342
 343         for (i_src = index_to_delete; i_src < array->len; i_src++) {
 344                 if (i_src < index_to_delete)
 345                         mm_len++;
 346                 else {
 347                         /* we require indexes_to_delete to contain non-repeated, ascending
 348                          * indexes. Otherwise we would need to presort the indexes. */
 349                         while (TRUE) {
 350                                 guint dd;
 351
 352                                 if (i_itd + 1 >= len) {
 353                                         index_to_delete = G_MAXUINT;
 354                                         break;
 355                                 }
 356
 357                                 dd = indexes_to_delete[++i_itd];
 358                                 if (dd > index_to_delete) {
 359                                         if (dd >= array->len)
 360                                                 g_warn_if_reached ();
 361                                         else {
 362                                                 g_assert (res_length > 0);
 363                                                 res_length--;
 364                                         }
 365                                         index_to_delete = dd;
 366                                         break;
 367                                 }
 368                                 g_warn_if_reached ();
 369                         }
 370
 371                         if (mm_len) {
 372                                 memmove (&array->data[mm_dst * elt_size],
 373                                          &array->data[mm_src * elt_size],
 374                                          mm_len * elt_size);
 375                                 mm_dst += mm_len;
 376                                 mm_src += mm_len + 1;
 377                                 mm_len = 0;
 378                         } else
 379                                 mm_src++;
 380                 }
 381         }
 382         if (mm_len) {
 383                 memmove (&array->data[mm_dst * elt_size],
 384                          &array->data[mm_src * elt_size],
 385                          mm_len * elt_size);
 386         }
 387         g_array_set_size (array, res_length);
 388 }
 389
 390 int
 391 nm_spawn_process (const char *args, GError **error)
 392 {
 393         GError *local = NULL;
 394         gint num_args;
 395         char **argv = NULL;
 396         int status = -1;
 397
 398         g_return_val_if_fail (args != NULL, -1);
 399         g_return_val_if_fail (!error || !*error, -1);
 400
 401         if (g_shell_parse_argv (args, &num_args, &argv, &local)) {
 402                 g_spawn_sync ("/", argv, NULL, 0, NULL, NULL, NULL, NULL, &status, &local);
 403                 g_strfreev (argv);
 404         }
 405
 406         if (local) {
 407                 nm_log_warn (LOGD_CORE, "could not spawn process '%s': %s", args, local->message);
 408                 g_propagate_error (error, local);
 409         }
 410
 411         return status;
 412 }
 413
 414 static const char *
 415 _trunk_first_line (char *str)
 416 {
 417         char *s;
 418
 419         s = strchr (str, '\n');
 420         if (s)
 421                 s[0] = '\0';
 422         return str;
 423 }
 424
 425 int
 426 nm_utils_modprobe (GError **error, gboolean suppress_error_logging, const char *arg1, ...)
 427 {
 428         gs_unref_ptrarray GPtrArray *argv = NULL;
 429         int exit_status;
 430         gs_free char *_log_str = NULL;
 431 #define ARGV_TO_STR(argv)   (_log_str ? _log_str : (_log_str = g_strjoinv (" ", (char **) argv->pdata)))
 432         GError *local = NULL;
 433         va_list ap;
 434         NMLogLevel llevel = suppress_error_logging ? LOGL_DEBUG : LOGL_ERR;
 435         gs_free char *std_out = NULL, *std_err = NULL;
 436
 437         g_return_val_if_fail (!error || !*error, -1);
 438         g_return_val_if_fail (arg1, -1);
 439
 440         /* construct the argument list */
 441         argv = g_ptr_array_sized_new (4);
 442         g_ptr_array_add (argv, "/sbin/modprobe");
 443         g_ptr_array_add (argv, (char *) arg1);
 444
 445         va_start (ap, arg1);
 446         while ((arg1 = va_arg (ap, const char *)))
 447                 g_ptr_array_add (argv, (char *) arg1);
 448         va_end (ap);
 449
 450         g_ptr_array_add (argv, NULL);
 451
 452         nm_log_dbg (LOGD_CORE, "modprobe: '%s'", ARGV_TO_STR (argv));
 453         if (!g_spawn_sync (NULL, (char **) argv->pdata, NULL, 0, NULL, NULL, &std_out, &std_err, &exit_status, &local)) {
 454                 nm_log (llevel, LOGD_CORE, "modprobe: '%s' failed: %s", ARGV_TO_STR (argv), local->message);
 455                 g_propagate_error (error, local);
 456                 return -1;
 457         } else if (exit_status != 0) {
 458                 nm_log (llevel, LOGD_CORE, "modprobe: '%s' exited with error %d%s%s%s%s%s%s", ARGV_TO_STR (argv), exit_status,
 459                         std_out&&*std_out ? " (" : "", std_out&&*std_out ? _trunk_first_line (std_out) : "", std_out&&*std_out ? ")" : "",
 460                         std_err&&*std_err ? " (" : "", std_err&&*std_err ? _trunk_first_line (std_err) : "", std_err&&*std_err ? ")" : "");
 461         }
 462
 463         return exit_status;
 464 }
 465
 466 /**
 467  * nm_utils_get_start_time_for_pid:
 468  * @pid: the process identifier
 469  * @out_state: return the state character, like R, S, Z. See `man 5 proc`.
 470  * @out_ppid: parent process id
 471  *
 472  * Originally copied from polkit source (src/polkit/polkitunixprocess.c)
 473  * and adjusted.
 474  *
 475  * Returns: the timestamp when the process started (by parsing /proc/$PID/stat).
 476  * If an error occurs (e.g. the process does not exist), 0 is returned.
 477  *
 478  * The returned start time counts since boot, in the unit HZ (with HZ usually being (1/100) seconds)
 479  **/
 480 guint64
 481 nm_utils_get_start_time_for_pid (pid_t pid, char *out_state, pid_t *out_ppid)
 482 {
 483         guint64 start_time;
 484         char filename[256];
 485         gs_free gchar *contents = NULL;
 486         size_t length;
 487         gs_strfreev gchar **tokens = NULL;
 488         guint num_tokens;
 489         gchar *p;
 490         gchar *endp;
 491         char state = '\0';
 492         gint64 ppid = 0;
 493
 494         start_time = 0;
 495         contents = NULL;
 496
 497         g_return_val_if_fail (pid > 0, 0);
 498
 499         nm_sprintf_buf (filename, "/proc/%"G_GUINT64_FORMAT"/stat", (guint64) pid);
 500
 501         if (!g_file_get_contents (filename, &contents, &length, NULL))
 502                 goto out;
 503
 504         /* start time is the token at index 19 after the '(process name)' entry - since only this
 505          * field can contain the ')' character, search backwards for this to avoid malicious
 506          * processes trying to fool us
 507          */
 508         p = strrchr (contents, ')');
 509         if (p == NULL)
 510                 goto out;
 511         p += 2; /* skip ') ' */
 512         if (p - contents >= (int) length)
 513                 goto out;
 514
 515         state = p[0];
 516
 517         tokens = g_strsplit (p, " ", 0);
 518
 519         num_tokens = g_strv_length (tokens);
 520
 521         if (num_tokens < 20)
 522                 goto out;
 523
 524         if (out_ppid)
 525                 ppid = _nm_utils_ascii_str_to_int64 (tokens[1], 10, 1, G_MAXINT, 0);
 526
 527         errno = 0;
 528         start_time = strtoull (tokens[19], &endp, 10);
 529         if (*endp != '\0' || errno != 0)
 530                 start_time = 0;
 531
 532 out:
 533         if (out_state)
 534                 *out_state = state;
 535         if (out_ppid)
 536                 *out_ppid = ppid;
 537
 538         return start_time;
 539 }
 540
 541 /******************************************************************************************/
 542
 543 typedef struct {
 544         pid_t pid;
 545         NMLogDomain log_domain;
 546         union {
 547                 struct {
 548                         gint64 wait_start_us;
 549                         guint source_timeout_kill_id;
 550                 } async;
 551                 struct {
 552                         gboolean success;
 553                         int child_status;
 554                 } sync;
 555         };
 556         NMUtilsKillChildAsyncCb callback;
 557         void *user_data;
 558
 559         char log_name[1]; /* variable-length object, must be last element!! */
 560 } KillChildAsyncData;
 561
 562 #define LOG_NAME_FMT "kill child process '%s' (%ld)"
 563 #define LOG_NAME_PROCESS_FMT "kill process '%s' (%ld)"
 564 #define LOG_NAME_ARGS log_name,(long)pid
 565
 566 static KillChildAsyncData *
 567 _kc_async_data_alloc (pid_t pid, NMLogDomain log_domain, const char *log_name, NMUtilsKillChildAsyncCb callback, void *user_data)
 568 {
 569         KillChildAsyncData *data;
 570         size_t log_name_len;
 571
 572         /* append the name at the end of our KillChildAsyncData. */
 573         log_name_len = strlen (LOG_NAME_FMT) + 20 + strlen (log_name);
 574         data = g_malloc (sizeof (KillChildAsyncData) - 1 + log_name_len);
 575         g_snprintf (data->log_name, log_name_len, LOG_NAME_FMT, LOG_NAME_ARGS);
 576
 577         data->pid = pid;
 578         data->user_data = user_data;
 579         data->callback = callback;
 580         data->log_domain = log_domain;
 581
 582         return data;
 583 }
 584
 585 #define KC_EXIT_TO_STRING_BUF_SIZE 128
 586 static const char *
 587 _kc_exit_to_string (char *buf, int exit)
 588 #define _kc_exit_to_string(buf, exit) ( G_STATIC_ASSERT_EXPR(sizeof (buf) == KC_EXIT_TO_STRING_BUF_SIZE && sizeof ((buf)[0]) == 1), _kc_exit_to_string (buf, exit) )
 589 {
 590         if (WIFEXITED (exit))
 591                 g_snprintf (buf, KC_EXIT_TO_STRING_BUF_SIZE, "normally with status %d", WEXITSTATUS (exit));
 592         else if (WIFSIGNALED (exit))
 593                 g_snprintf (buf, KC_EXIT_TO_STRING_BUF_SIZE, "by signal %d", WTERMSIG (exit));
 594         else
 595                 g_snprintf (buf, KC_EXIT_TO_STRING_BUF_SIZE, "with unexpected status %d", exit);
 596         return buf;
 597 }
 598
 599 static const char *
 600 _kc_signal_to_string (int sig)
 601 {
 602         switch (sig) {
 603         case 0:  return "no signal (0)";
 604         case SIGKILL:  return "SIGKILL (" G_STRINGIFY (SIGKILL) ")";
 605         case SIGTERM:  return "SIGTERM (" G_STRINGIFY (SIGTERM) ")";
 606         default:
 607                 return "Unexpected signal";
 608         }
 609 }
 610
 611 #define KC_WAITED_TO_STRING 100
 612 static const char *
 613 _kc_waited_to_string (char *buf, gint64 wait_start_us)
 614 #define _kc_waited_to_string(buf, wait_start_us) ( G_STATIC_ASSERT_EXPR(sizeof (buf) == KC_WAITED_TO_STRING && sizeof ((buf)[0]) == 1), _kc_waited_to_string (buf, wait_start_us) )
 615 {
 616         g_snprintf (buf, KC_WAITED_TO_STRING, " (%ld usec elapsed)", (long) (nm_utils_get_monotonic_timestamp_us () - wait_start_us));
 617         return buf;
 618 }
 619
 620 static void
 621 _kc_cb_watch_child (GPid pid, gint status, gpointer user_data)
 622 {
 623         KillChildAsyncData *data = user_data;
 624         char buf_exit[KC_EXIT_TO_STRING_BUF_SIZE], buf_wait[KC_WAITED_TO_STRING];
 625
 626         if (data->async.source_timeout_kill_id)
 627                 g_source_remove (data->async.source_timeout_kill_id);
 628
 629         nm_log_dbg (data->log_domain, "%s: terminated %s%s",
 630                     data->log_name, _kc_exit_to_string (buf_exit, status),
 631                     _kc_waited_to_string (buf_wait, data->async.wait_start_us));
 632
 633         if (data->callback)
 634                 data->callback (pid, TRUE, status, data->user_data);
 635
 636         g_free (data);
 637 }
 638
 639 static gboolean
 640 _kc_cb_timeout_grace_period (void *user_data)
 641 {
 642         KillChildAsyncData *data = user_data;
 643         int ret, errsv;
 644
 645         data->async.source_timeout_kill_id = 0;
 646
 647         if ((ret = kill (data->pid, SIGKILL)) != 0) {
 648                 errsv = errno;
 649                 /* ESRCH means, process does not exist or is already a zombie. */
 650                 if (errsv != ESRCH) {
 651                         nm_log_err (LOGD_CORE | data->log_domain, "%s: kill(SIGKILL) returned unexpected return value %d: (%s, %d)",
 652                                     data->log_name, ret, strerror (errsv), errsv);
 653                 }
 654         } else {
 655                 nm_log_dbg (data->log_domain, "%s: process not terminated after %ld usec. Sending SIGKILL signal",
 656                             data->log_name, (long) (nm_utils_get_monotonic_timestamp_us () - data->async.wait_start_us));
 657         }
 658
 659         return G_SOURCE_REMOVE;
 660 }
 661
 662 static gboolean
 663 _kc_invoke_callback_idle (gpointer user_data)
 664 {
 665         KillChildAsyncData *data = user_data;
 666
 667         if (data->sync.success) {
 668                 char buf_exit[KC_EXIT_TO_STRING_BUF_SIZE];
 669
 670                 nm_log_dbg (data->log_domain, "%s: invoke callback: terminated %s",
 671                             data->log_name, _kc_exit_to_string (buf_exit, data->sync.child_status));
 672         } else
 673                 nm_log_dbg (data->log_domain, "%s: invoke callback: killing child failed", data->log_name);
 674
 675         data->callback (data->pid, data->sync.success, data->sync.child_status, data->user_data);
 676         g_free (data);
 677
 678         return G_SOURCE_REMOVE;
 679 }
 680
 681 static void
 682 _kc_invoke_callback (pid_t pid, NMLogDomain log_domain, const char *log_name, NMUtilsKillChildAsyncCb callback, void *user_data, gboolean success, int child_status)
 683 {
 684         KillChildAsyncData *data;
 685
 686         if (!callback)
 687                 return;
 688
 689         data = _kc_async_data_alloc (pid, log_domain, log_name, callback, user_data);
 690         data->sync.success = success;
 691         data->sync.child_status = child_status;
 692
 693         g_idle_add (_kc_invoke_callback_idle, data);
 694 }
 695
 696 /* nm_utils_kill_child_async:
 697  * @pid: the process id of the process to kill
 698  * @sig: signal to send initially. Set to 0 to send not signal.
 699  * @log_domain: the logging domain used for logging (LOGD_NONE to suppress logging)
 700  * @log_name: for logging, the name of the processes to kill
 701  * @wait_before_kill_msec: Waittime in milliseconds before sending %SIGKILL signal. Set this value
 702  * to zero, not to send %SIGKILL. If @sig is already %SIGKILL, this parameter is ignored.
 703  * @callback: (allow-none): callback after the child terminated. This function will always
 704  *   be invoked asynchronously.
 705  * @user_data: passed on to callback
 706  *
 707  * Uses g_child_watch_add(), so note the glib comment: if you obtain pid from g_spawn_async() or
 708  * g_spawn_async_with_pipes() you will need to pass %G_SPAWN_DO_NOT_REAP_CHILD as flag to the spawn
 709  * function for the child watching to work.
 710  * Also note, that you must g_source_remove() any other child watchers for @pid because glib
 711  * supports only one watcher per child.
 712  **/
 713 void
 714 nm_utils_kill_child_async (pid_t pid, int sig, NMLogDomain log_domain,
 715                            const char *log_name, guint32 wait_before_kill_msec,
 716                            NMUtilsKillChildAsyncCb callback, void *user_data)
 717 {
 718         int status = 0, errsv;
 719         pid_t ret;
 720         KillChildAsyncData *data;
 721         char buf_exit[KC_EXIT_TO_STRING_BUF_SIZE];
 722
 723         g_return_if_fail (pid > 0);
 724         g_return_if_fail (log_name != NULL);
 725
 726         /* let's see if the child already terminated... */
 727         ret = waitpid (pid, &status, WNOHANG);
 728         if (ret > 0) {
 729                 nm_log_dbg (log_domain, LOG_NAME_FMT ": process %ld already terminated %s",
 730                             LOG_NAME_ARGS, (long) ret, _kc_exit_to_string (buf_exit, status));
 731                 _kc_invoke_callback (pid, log_domain, log_name, callback, user_data, TRUE, status);
 732                 return;
 733         } else if (ret != 0) {
 734                 errsv = errno;
 735                 /* ECHILD means, the process is not a child/does not exist or it has SIGCHILD blocked. */
 736                 if (errsv != ECHILD) {
 737                         nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": unexpected error while waitpid: %s (%d)",
 738                                     LOG_NAME_ARGS, strerror (errsv), errsv);
 739                         _kc_invoke_callback (pid, log_domain, log_name, callback, user_data, FALSE, -1);
 740                         return;
 741                 }
 742         }
 743
 744         /* send the first signal. */
 745         if (kill (pid, sig) != 0) {
 746                 errsv = errno;
 747                 /* ESRCH means, process does not exist or is already a zombie. */
 748                 if (errsv != ESRCH) {
 749                         nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": unexpected error sending %s: %s (%d)",
 750                                     LOG_NAME_ARGS, _kc_signal_to_string (sig), strerror (errsv), errsv);
 751                         _kc_invoke_callback (pid, log_domain, log_name, callback, user_data, FALSE, -1);
 752                         return;
 753                 }
 754
 755                 /* let's try again with waitpid, probably there was a race... */
 756                 ret = waitpid (pid, &status, 0);
 757                 if (ret > 0) {
 758                         nm_log_dbg (log_domain, LOG_NAME_FMT ": process %ld already terminated %s",
 759                                     LOG_NAME_ARGS, (long) ret, _kc_exit_to_string (buf_exit, status));
 760                         _kc_invoke_callback (pid, log_domain, log_name, callback, user_data, TRUE, status);
 761                 } else {
 762                         errsv = errno;
 763                         nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": failed due to unexpected return value %ld by waitpid (%s, %d) after sending %s",
 764                                     LOG_NAME_ARGS, (long) ret, strerror (errsv), errsv, _kc_signal_to_string (sig));
 765                         _kc_invoke_callback (pid, log_domain, log_name, callback, user_data, FALSE, -1);
 766                 }
 767                 return;
 768         }
 769
 770         data = _kc_async_data_alloc (pid, log_domain, log_name, callback, user_data);
 771         data->async.wait_start_us = nm_utils_get_monotonic_timestamp_us ();
 772
 773         if (sig != SIGKILL && wait_before_kill_msec > 0) {
 774                 data->async.source_timeout_kill_id = g_timeout_add (wait_before_kill_msec, _kc_cb_timeout_grace_period, data);
 775                 nm_log_dbg (log_domain, "%s: wait for process to terminate after sending %s (send SIGKILL in %ld milliseconds)...",
 776                             data->log_name,  _kc_signal_to_string (sig), (long) wait_before_kill_msec);
 777         } else {
 778                 data->async.source_timeout_kill_id = 0;
 779                 nm_log_dbg (log_domain, "%s: wait for process to terminate after sending %s...",
 780                             data->log_name, _kc_signal_to_string (sig));
 781         }
 782
 783         g_child_watch_add (pid, _kc_cb_watch_child, data);
 784 }
 785
 786 static inline gulong
 787 _sleep_duration_convert_ms_to_us (guint32 sleep_duration_msec)
 788 {
 789         if (sleep_duration_msec > 0) {
 790                 guint64 x = (gint64) sleep_duration_msec * (guint64) 1000L;
 791
 792                 return x < G_MAXULONG ? (gulong) x : G_MAXULONG;
 793         }
 794         return G_USEC_PER_SEC / 20;
 795 }
 796
 797 /* nm_utils_kill_child_sync:
 798  * @pid: process id to kill
 799  * @sig: signal to sent initially. If 0, no signal is sent. If %SIGKILL, the
 800  * second %SIGKILL signal is not sent after @wait_before_kill_msec milliseconds.
 801  * @log_domain: log debug information for this domain. Errors and warnings are logged both
 802  * as %LOGD_CORE and @log_domain.
 803  * @log_name: name of the process to kill for logging.
 804  * @child_status: (out) (allow-none): return the exit status of the child, if no error occured.
 805  * @wait_before_kill_msec: Waittime in milliseconds before sending %SIGKILL signal. Set this value
 806  * to zero, not to send %SIGKILL. If @sig is already %SIGKILL, this parameter has not effect.
 807  * @sleep_duration_msec: the synchronous function sleeps repeatedly waiting for the child to terminate.
 808  * Set to zero, to use the default (meaning 20 wakeups per seconds).
 809  *
 810  * Kill a child process synchronously and wait. The function first checks if the child already terminated
 811  * and if it did, return the exit status. Otherwise send one @sig signal. @sig  will always be
 812  * sent unless the child already exited. If the child does not exit within @wait_before_kill_msec milliseconds,
 813  * the function will send %SIGKILL and waits for the child indefinitly. If @wait_before_kill_msec is zero, no
 814  * %SIGKILL signal will be sent.
 815  *
 816  * In case of error, errno is preserved to contain the last reason of failure.
 817  **/
 818 gboolean
 819 nm_utils_kill_child_sync (pid_t pid, int sig, NMLogDomain log_domain, const char *log_name,
 820                           int *child_status, guint32 wait_before_kill_msec,
 821                           guint32 sleep_duration_msec)
 822 {
 823         int status = 0, errsv = 0;
 824         pid_t ret;
 825         gboolean success = FALSE;
 826         gboolean was_waiting = FALSE, send_kill = FALSE;
 827         char buf_exit[KC_EXIT_TO_STRING_BUF_SIZE];
 828         char buf_wait[KC_WAITED_TO_STRING];
 829         gint64 wait_start_us;
 830
 831         g_return_val_if_fail (pid > 0, FALSE);
 832         g_return_val_if_fail (log_name != NULL, FALSE);
 833
 834         /* check if the child process already terminated... */
 835         ret = waitpid (pid, &status, WNOHANG);
 836         if (ret > 0) {
 837                 nm_log_dbg (log_domain, LOG_NAME_FMT ": process %ld already terminated %s",
 838                             LOG_NAME_ARGS, (long) ret, _kc_exit_to_string (buf_exit, status));
 839                 success = TRUE;
 840                 goto out;
 841         } else if (ret != 0) {
 842                 errsv = errno;
 843                 /* ECHILD means, the process is not a child/does not exist or it has SIGCHILD blocked. */
 844                 if (errsv != ECHILD) {
 845                         nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": unexpected error while waitpid: %s (%d)",
 846                                     LOG_NAME_ARGS, strerror (errsv), errsv);
 847                         goto out;
 848                 }
 849         }
 850
 851         /* send first signal @sig */
 852         if (kill (pid, sig) != 0) {
 853                 errsv = errno;
 854                 /* ESRCH means, process does not exist or is already a zombie. */
 855                 if (errsv != ESRCH) {
 856                         nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": failed to send %s: %s (%d)",
 857                                     LOG_NAME_ARGS, _kc_signal_to_string (sig), strerror (errsv), errsv);
 858                 } else {
 859                         /* let's try again with waitpid, probably there was a race... */
 860                         ret = waitpid (pid, &status, 0);
 861                         if (ret > 0) {
 862                                 nm_log_dbg (log_domain, LOG_NAME_FMT ": process %ld already terminated %s",
 863                                             LOG_NAME_ARGS, (long) ret, _kc_exit_to_string (buf_exit, status));
 864                                 success = TRUE;
 865                         } else {
 866                                 errsv = errno;
 867                                 nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": failed due to unexpected return value %ld by waitpid (%s, %d) after sending %s",
 868                                             LOG_NAME_ARGS, (long) ret, strerror (errsv), errsv, _kc_signal_to_string (sig));
 869                         }
 870                 }
 871                 goto out;
 872         }
 873
 874         wait_start_us = nm_utils_get_monotonic_timestamp_us ();
 875
 876         /* wait for the process to terminated... */
 877         if (sig != SIGKILL) {
 878                 gint64 wait_until, now;
 879                 gulong sleep_time, sleep_duration_usec;
 880                 int loop_count = 0;
 881
 882                 sleep_duration_usec = _sleep_duration_convert_ms_to_us (sleep_duration_msec);
 883                 wait_until = wait_before_kill_msec <= 0 ? 0 : wait_start_us + (((gint64) wait_before_kill_msec) * 1000L);
 884
 885                 while (TRUE) {
 886                         ret = waitpid (pid, &status, WNOHANG);
 887                         if (ret > 0) {
 888                                 nm_log_dbg (log_domain, LOG_NAME_FMT ": after sending %s, process %ld exited %s%s",
 889                                             LOG_NAME_ARGS, _kc_signal_to_string (sig), (long) ret, _kc_exit_to_string (buf_exit, status),
 890                                             was_waiting ? _kc_waited_to_string (buf_wait, wait_start_us) : "");
 891                                 success = TRUE;
 892                                 goto out;
 893                         }
 894                         if (ret == -1) {
 895                                 errsv = errno;
 896                                 /* ECHILD means, the process is not a child/does not exist or it has SIGCHILD blocked. */
 897                                 if (errsv != ECHILD) {
 898                                         nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": after sending %s, waitpid failed with %s (%d)%s",
 899                                                     LOG_NAME_ARGS, _kc_signal_to_string (sig), strerror (errsv), errsv,
 900                                                    was_waiting ? _kc_waited_to_string (buf_wait, wait_start_us) : "");
 901                                         goto out;
 902                                 }
 903                         }
 904
 905                         if (!wait_until)
 906                                 break;
 907
 908                         now = nm_utils_get_monotonic_timestamp_us ();
 909                         if (now >= wait_until)
 910                                 break;
 911
 912                         if (!was_waiting) {
 913                                 nm_log_dbg (log_domain, LOG_NAME_FMT ": waiting up to %ld milliseconds for process to terminate normally after sending %s...",
 914                                             LOG_NAME_ARGS, (long) MAX (wait_before_kill_msec, 0), _kc_signal_to_string (sig));
 915                                 was_waiting = TRUE;
 916                         }
 917
 918                         sleep_time = MIN (wait_until - now, sleep_duration_usec);
 919                         if (loop_count < 20) {
 920                                 /* At the beginning we expect the process to die fast.
 921                                  * Limit the sleep time, the limit doubles with every iteration. */
 922                                 sleep_time = MIN (sleep_time, (((guint64) 1) << loop_count) * G_USEC_PER_SEC / 2000);
 923                                 loop_count++;
 924                         }
 925                         g_usleep (sleep_time);
 926                 }
 927
 928                 /* send SIGKILL, if called with @wait_before_kill_msec > 0 */
 929                 if (wait_until) {
 930                         nm_log_dbg (log_domain, LOG_NAME_FMT ": sending SIGKILL...", LOG_NAME_ARGS);
 931
 932                         send_kill = TRUE;
 933                         if (kill (pid, SIGKILL) != 0) {
 934                                 errsv = errno;
 935                                 /* ESRCH means, process does not exist or is already a zombie. */
 936                                 if (errsv != ESRCH) {
 937                                         nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": failed to send SIGKILL (after sending %s), %s (%d)",
 938                                                                 LOG_NAME_ARGS, _kc_signal_to_string (sig), strerror (errsv), errsv);
 939                                         goto out;
 940                                 }
 941                         }
 942                 }
 943         }
 944
 945         if (!was_waiting) {
 946                 nm_log_dbg (log_domain, LOG_NAME_FMT ": waiting for process to terminate after sending %s%s...",
 947                             LOG_NAME_ARGS, _kc_signal_to_string (sig), send_kill ? " and SIGKILL" : "");
 948         }
 949
 950         /* block until the child terminates. */
 951         while ((ret = waitpid (pid, &status, 0)) <= 0) {
 952                 errsv = errno;
 953
 954                 if (errsv != EINTR) {
 955                         nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": after sending %s%s, waitpid failed with %s (%d)%s",
 956                                     LOG_NAME_ARGS, _kc_signal_to_string (sig), send_kill ? " and SIGKILL" : "", strerror (errsv), errsv,
 957                                     _kc_waited_to_string (buf_wait, wait_start_us));
 958                         goto out;
 959                 }
 960         }
 961
 962         nm_log_dbg (log_domain, LOG_NAME_FMT ": after sending %s%s, process %ld exited %s%s",
 963                     LOG_NAME_ARGS, _kc_signal_to_string (sig), send_kill ? " and SIGKILL" : "", (long) ret,
 964                     _kc_exit_to_string (buf_exit, status), _kc_waited_to_string (buf_wait, wait_start_us));
 965         success = TRUE;
 966 out:
 967         if (child_status)
 968                 *child_status = success ? status : -1;
 969         errno = success ? 0 : errsv;
 970         return success;
 971 }
 972
 973 /* nm_utils_kill_process_sync:
 974  * @pid: process id to kill
 975  * @start_time: the start time of the process to kill (as obtained by nm_utils_get_start_time_for_pid()).
 976  *   This is an optional argument, to avoid (somewhat) killing the wrong process as @pid
 977  *   might get recycled. You can pass 0, to not provide this parameter.
 978  * @sig: signal to sent initially. If 0, no signal is sent. If %SIGKILL, the
 979  *   second %SIGKILL signal is not sent after @wait_before_kill_msec milliseconds.
 980  * @log_domain: log debug information for this domain. Errors and warnings are logged both
 981  *   as %LOGD_CORE and @log_domain.
 982  * @log_name: name of the process to kill for logging.
 983  * @wait_before_kill_msec: Waittime in milliseconds before sending %SIGKILL signal. Set this value
 984  *   to zero, not to send %SIGKILL. If @sig is already %SIGKILL, this parameter has no effect.
 985  *   If @max_wait_msec is set but less then @wait_before_kill_msec, the final %SIGKILL will also
 986  *   not be send.
 987  * @sleep_duration_msec: the synchronous function sleeps repeatedly waiting for the child to terminate.
 988  *   Set to zero, to use the default (meaning 20 wakeups per seconds).
 989  * @max_wait_msec: if 0, waits indefinitely until the process is gone (or a zombie). Otherwise, this
 990  *   is the maxium wait time until returning. If @max_wait_msec is non-zero but smaller then @wait_before_kill_msec,
 991  *   we will not send a final %SIGKILL.
 992  *
 993  * Kill a non-child process synchronously and wait. This function will not return before the
 994  * process with PID @pid is gone, the process is a zombie, or @max_wait_msec expires.
 995  **/
 996 void
 997 nm_utils_kill_process_sync (pid_t pid, guint64 start_time, int sig, NMLogDomain log_domain,
 998                             const char *log_name, guint32 wait_before_kill_msec,
 999                             guint32 sleep_duration_msec, guint32 max_wait_msec)
1000 {
1001         int errsv;
1002         guint64 start_time0;
1003         gint64 wait_until_sigkill, now, wait_start_us, max_wait_until;
1004         gulong sleep_time, sleep_duration_usec;
1005         int loop_count = 0;
1006         gboolean was_waiting = FALSE;
1007         char buf_wait[KC_WAITED_TO_STRING];
1008         char p_state;
1009
1010         g_return_if_fail (pid > 0);
1011         g_return_if_fail (log_name != NULL);
1012
1013         start_time0 = nm_utils_get_start_time_for_pid (pid, &p_state, NULL);
1014         if (start_time0 == 0) {
1015                 nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": cannot kill process %ld because it seems already gone",
1016                             LOG_NAME_ARGS, (long int) pid);
1017                 return;
1018         }
1019         if (start_time != 0 && start_time != start_time0) {
1020                 nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": don't kill process %ld because the start_time is unexpectedly %lu instead of %ld",
1021                             LOG_NAME_ARGS, (long int) pid, (long unsigned) start_time0, (long unsigned) start_time);
1022                 return;
1023         }
1024
1025         switch (p_state) {
1026         case 'Z':
1027         case 'x':
1028         case 'X':
1029                 nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": cannot kill process %ld because it is already a zombie (%c)",
1030                             LOG_NAME_ARGS, (long int) pid, p_state);
1031                 return;
1032         default:
1033                 break;
1034         }
1035
1036         if (kill (pid, sig) != 0) {
1037                 errsv = errno;
1038                 /* ESRCH means, process does not exist or is already a zombie. */
1039                 if (errsv == ESRCH) {
1040                         nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": failed to send %s because process seems gone",
1041                                     LOG_NAME_ARGS, _kc_signal_to_string (sig));
1042                 } else {
1043                         nm_log_warn (LOGD_CORE | log_domain, LOG_NAME_PROCESS_FMT ": failed to send %s: %s (%d)",
1044                                      LOG_NAME_ARGS, _kc_signal_to_string (sig), strerror (errsv), errsv);
1045                 }
1046                 return;
1047         }
1048
1049         /* wait for the process to terminate... */
1050
1051         wait_start_us = nm_utils_get_monotonic_timestamp_us ();
1052
1053         sleep_duration_usec = _sleep_duration_convert_ms_to_us (sleep_duration_msec);
1054         if (sig != SIGKILL && wait_before_kill_msec)
1055                 wait_until_sigkill = wait_start_us + (((gint64) wait_before_kill_msec) * 1000L);
1056         else
1057                 wait_until_sigkill = 0;
1058         if (max_wait_msec > 0) {
1059                 max_wait_until = wait_start_us + (((gint64) max_wait_msec) * 1000L);
1060                 if (wait_until_sigkill > 0 && wait_until_sigkill > max_wait_msec)
1061                         wait_until_sigkill = 0;
1062         } else
1063                 max_wait_until = 0;
1064
1065         while (TRUE) {
1066                 start_time = nm_utils_get_start_time_for_pid (pid, &p_state, NULL);
1067
1068                 if (start_time != start_time0) {
1069                         nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": process is gone after sending signal %s%s",
1070                                     LOG_NAME_ARGS, _kc_signal_to_string (sig),
1071                                     was_waiting ? _kc_waited_to_string (buf_wait, wait_start_us) : "");
1072                         return;
1073                 }
1074                 switch (p_state) {
1075                 case 'Z':
1076                 case 'x':
1077                 case 'X':
1078                         nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": process is a zombie (%c) after sending signal %s%s",
1079                                     LOG_NAME_ARGS, p_state, _kc_signal_to_string (sig),
1080                                     was_waiting ? _kc_waited_to_string (buf_wait, wait_start_us) : "");
1081                         return;
1082                 default:
1083                         break;
1084                 }
1085
1086                 if (kill (pid, 0) != 0) {
1087                         errsv = errno;
1088                         /* ESRCH means, process does not exist or is already a zombie. */
1089                         if (errsv == ESRCH) {
1090                                 nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": process is gone or a zombie after sending signal %s%s",
1091                                             LOG_NAME_ARGS, _kc_signal_to_string (sig),
1092                                             was_waiting ? _kc_waited_to_string (buf_wait, wait_start_us) : "");
1093                         } else {
1094                                 nm_log_warn (LOGD_CORE | log_domain, LOG_NAME_PROCESS_FMT ": failed to kill(%ld, 0): %s (%d)%s",
1095                                              LOG_NAME_ARGS, (long int) pid, strerror (errsv), errsv,
1096                                              was_waiting ? _kc_waited_to_string (buf_wait, wait_start_us) : "");
1097                         }
1098                         return;
1099                 }
1100
1101                 sleep_time = sleep_duration_usec;
1102                 now = nm_utils_get_monotonic_timestamp_us ();
1103
1104                 if (   max_wait_until != 0
1105                     && now >= max_wait_until) {
1106                         if (wait_until_sigkill != 0) {
1107                                 /* wait_before_kill_msec is not larger then max_wait_until but we did not yet send
1108                                  * SIGKILL. Although we already reached our timeout, we don't want to skip sending
1109                                  * the signal. Even if we don't wait for the process to disappear. */
1110                                 nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": sending SIGKILL", LOG_NAME_ARGS);
1111                                 kill (pid, SIGKILL);
1112                         }
1113                         nm_log_warn (log_domain, LOG_NAME_PROCESS_FMT ": timeout %u msec waiting for process to disappear (after sending %s)%s",
1114                                      LOG_NAME_ARGS, (unsigned) max_wait_until, _kc_signal_to_string (sig),
1115                                      was_waiting ? _kc_waited_to_string (buf_wait, wait_start_us) : "");
1116                         return;
1117                 }
1118
1119                 if (wait_until_sigkill != 0) {
1120                         if (now >= wait_until_sigkill) {
1121                                 /* Still not dead. SIGKILL now... */
1122                                 nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": sending SIGKILL", LOG_NAME_ARGS);
1123                                 if (kill (pid, SIGKILL) != 0) {
1124                                         errsv = errno;
1125                                         /* ESRCH means, process does not exist or is already a zombie. */
1126                                         if (errsv != ESRCH) {
1127                                                 nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": process is gone or a zombie%s",
1128                                                             LOG_NAME_ARGS, _kc_waited_to_string (buf_wait, wait_start_us));
1129                                         } else {
1130                                                 nm_log_warn (LOGD_CORE | log_domain, LOG_NAME_PROCESS_FMT ": failed to send SIGKILL (after sending %s), %s (%d)%s",
1131                                                              LOG_NAME_ARGS, _kc_signal_to_string (sig), strerror (errsv), errsv,
1132                                                              _kc_waited_to_string (buf_wait, wait_start_us));
1133                                         }
1134                                         return;
1135                                 }
1136                                 sig = SIGKILL;
1137                                 wait_until_sigkill = 0;
1138                                 loop_count = 0; /* reset the loop_count. Now we really expect the process to die quickly. */
1139                         } else
1140                                 sleep_time = MIN (wait_until_sigkill - now, sleep_duration_usec);
1141                 }
1142
1143                 if (!was_waiting) {
1144                         if (wait_until_sigkill != 0) {
1145                                 nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": waiting up to %ld milliseconds for process to disappear before sending KILL signal after sending %s...",
1146                                             LOG_NAME_ARGS, (long) wait_before_kill_msec, _kc_signal_to_string (sig));
1147                         } else if (max_wait_until != 0) {
1148                                 nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": waiting up to %ld milliseconds for process to disappear after sending %s...",
1149                                             LOG_NAME_ARGS, (long) max_wait_msec, _kc_signal_to_string (sig));
1150                         } else {
1151                                 nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": waiting for process to disappear after sending %s...",
1152                                             LOG_NAME_ARGS, _kc_signal_to_string (sig));
1153                         }
1154                         was_waiting = TRUE;
1155                 }
1156
1157                 if (loop_count < 20) {
1158                         /* At the beginning we expect the process to die fast.
1159                          * Limit the sleep time, the limit doubles with every iteration. */
1160                         sleep_time = MIN (sleep_time, (((guint64) 1) << loop_count) * G_USEC_PER_SEC / 2000);
1161                         loop_count++;
1162                 }
1163                 g_usleep (sleep_time);
1164         }
1165 }
1166 #undef LOG_NAME_FMT
1167 #undef LOG_NAME_PROCESS_FMT
1168 #undef LOG_NAME_ARGS
1169
1170 const char *const NM_PATHS_DEFAULT[] = {
1171         PREFIX "/sbin/",
1172         PREFIX "/bin/",
1173         "/sbin/",
1174         "/usr/sbin/",
1175         "/usr/local/sbin/",
1176         "/bin/",
1177         "/usr/bin/",
1178         "/usr/local/bin/",
1179         NULL,
1180 };
1181
1182 const char *
1183 nm_utils_find_helper(const char *progname, const char *try_first, GError **error)
1184 {
1185         return nm_utils_file_search_in_paths (progname, try_first, NM_PATHS_DEFAULT, G_FILE_TEST_IS_EXECUTABLE, NULL, NULL, error);
1186 }
1187
1188 /******************************************************************************************/
1189
1190 #define MAC_TAG "mac:"
1191 #define INTERFACE_NAME_TAG "interface-name:"
1192 #define DEVICE_TYPE_TAG "type:"
1193 #define SUBCHAN_TAG "s390-subchannels:"
1194 #define EXCEPT_TAG "except:"
1195 #define MATCH_TAG_CONFIG_NM_VERSION             "nm-version:"
1196 #define MATCH_TAG_CONFIG_NM_VERSION_MIN         "nm-version-min:"
1197 #define MATCH_TAG_CONFIG_NM_VERSION_MAX         "nm-version-max:"
1198 #define MATCH_TAG_CONFIG_ENV                    "env:"
1199
1200 #define _spec_has_prefix(pspec, tag) \
1201         ({ \
1202                 const char **_spec = (pspec); \
1203                 gboolean _has = FALSE; \
1204                 \
1205                 if (!g_ascii_strncasecmp (*_spec, (""tag), NM_STRLEN (tag))) { \
1206                         *_spec += NM_STRLEN (tag); \
1207                         _has = TRUE; \
1208                 } \
1209                 _has; \
1210         })
1211
1212 static const char *
1213 _match_except (const char *spec_str, gboolean *out_except)
1214 {
1215         if (!g_ascii_strncasecmp (spec_str, EXCEPT_TAG, NM_STRLEN (EXCEPT_TAG))) {
1216                 spec_str += NM_STRLEN (EXCEPT_TAG);
1217                 *out_except = TRUE;
1218         } else
1219                 *out_except = FALSE;
1220         return spec_str;
1221 }
1222
1223 NMMatchSpecMatchType
1224 nm_match_spec_device_type (const GSList *specs, const char *device_type)
1225 {
1226         const GSList *iter;
1227         NMMatchSpecMatchType match = NM_MATCH_SPEC_NO_MATCH;
1228
1229         if (!device_type || !*device_type)
1230                 return NM_MATCH_SPEC_NO_MATCH;
1231
1232         for (iter = specs; iter; iter = g_slist_next (iter)) {
1233                 const char *spec_str = iter->data;
1234                 gboolean except;
1235
1236                 if (!spec_str || !*spec_str)
1237                         continue;
1238
1239                 spec_str = _match_except (spec_str, &except);
1240
1241                 if (g_ascii_strncasecmp (spec_str, DEVICE_TYPE_TAG, NM_STRLEN (DEVICE_TYPE_TAG)) != 0)
1242                         continue;
1243
1244                 spec_str += NM_STRLEN (DEVICE_TYPE_TAG);
1245                 if (strcmp (spec_str, device_type) == 0) {
1246                         if (except)
1247                                 return NM_MATCH_SPEC_NEG_MATCH;
1248                         match = NM_MATCH_SPEC_MATCH;
1249                 }
1250         }
1251         return match;
1252 }
1253
1254 NMMatchSpecMatchType
1255 nm_match_spec_hwaddr (const GSList *specs, const char *hwaddr)
1256 {
1257         const GSList *iter;
1258         NMMatchSpecMatchType match = NM_MATCH_SPEC_NO_MATCH;
1259
1260         g_return_val_if_fail (hwaddr != NULL, NM_MATCH_SPEC_NO_MATCH);
1261
1262         for (iter = specs; iter; iter = g_slist_next (iter)) {
1263                 const char *spec_str = iter->data;
1264                 gboolean except;
1265
1266                 if (!spec_str || !*spec_str)
1267                         continue;
1268
1269                 spec_str = _match_except (spec_str, &except);
1270
1271                 if (   !g_ascii_strncasecmp (spec_str, INTERFACE_NAME_TAG, NM_STRLEN (INTERFACE_NAME_TAG))
1272                     || !g_ascii_strncasecmp (spec_str, SUBCHAN_TAG, NM_STRLEN (SUBCHAN_TAG))
1273                     || !g_ascii_strncasecmp (spec_str, DEVICE_TYPE_TAG, NM_STRLEN (DEVICE_TYPE_TAG)))
1274                         continue;
1275
1276                 if (!g_ascii_strncasecmp (spec_str, MAC_TAG, NM_STRLEN (MAC_TAG)))
1277                         spec_str += NM_STRLEN (MAC_TAG);
1278                 else if (except)
1279                         continue;
1280
1281                 if (nm_utils_hwaddr_matches (spec_str, -1, hwaddr, -1)) {
1282                         if (except)
1283                                 return NM_MATCH_SPEC_NEG_MATCH;
1284                         match = NM_MATCH_SPEC_MATCH;
1285                 }
1286         }
1287         return match;
1288 }
1289
1290 NMMatchSpecMatchType
1291 nm_match_spec_interface_name (const GSList *specs, const char *interface_name)
1292 {
1293         const GSList *iter;
1294         NMMatchSpecMatchType match = NM_MATCH_SPEC_NO_MATCH;
1295
1296         g_return_val_if_fail (interface_name != NULL, NM_MATCH_SPEC_NO_MATCH);
1297
1298         for (iter = specs; iter; iter = g_slist_next (iter)) {
1299                 const char *spec_str = iter->data;
1300                 gboolean use_pattern = FALSE;
1301                 gboolean except;
1302
1303                 if (!spec_str || !*spec_str)
1304                         continue;
1305
1306                 spec_str = _match_except (spec_str, &except);
1307
1308                 if (   !g_ascii_strncasecmp (spec_str, MAC_TAG, NM_STRLEN (MAC_TAG))
1309                     || !g_ascii_strncasecmp (spec_str, SUBCHAN_TAG, NM_STRLEN (SUBCHAN_TAG))
1310                     || !g_ascii_strncasecmp (spec_str, DEVICE_TYPE_TAG, NM_STRLEN (DEVICE_TYPE_TAG)))
1311                         continue;
1312
1313                 if (!g_ascii_strncasecmp (spec_str, INTERFACE_NAME_TAG, NM_STRLEN (INTERFACE_NAME_TAG))) {
1314                         spec_str += NM_STRLEN (INTERFACE_NAME_TAG);
1315                         if (spec_str[0] == '=')
1316                                 spec_str += 1;
1317                         else {
1318                                 if (spec_str[0] == '~')
1319                                         spec_str += 1;
1320                                 use_pattern=TRUE;
1321                         }
1322                 } else if (except)
1323                         continue;
1324
1325                 if (   !strcmp (spec_str, interface_name)
1326                     || (use_pattern && g_pattern_match_simple (spec_str, interface_name))) {
1327                         if (except)
1328                                 return NM_MATCH_SPEC_NEG_MATCH;
1329                         match = NM_MATCH_SPEC_MATCH;
1330                 }
1331         }
1332         return match;
1333 }
1334
1335 #define BUFSIZE 10
1336
1337 static gboolean
1338 parse_subchannels (const char *subchannels, guint32 *a, guint32 *b, guint32 *c)
1339 {
1340         long unsigned int tmp;
1341         char buf[BUFSIZE + 1];
1342         const char *p = subchannels;
1343         int i = 0;
1344         char *pa = NULL, *pb = NULL, *pc = NULL;
1345
1346         g_return_val_if_fail (subchannels != NULL, FALSE);
1347         g_return_val_if_fail (a != NULL, FALSE);
1348         g_return_val_if_fail (*a == 0, FALSE);
1349         g_return_val_if_fail (b != NULL, FALSE);
1350         g_return_val_if_fail (*b == 0, FALSE);
1351         g_return_val_if_fail (c != NULL, FALSE);
1352         g_return_val_if_fail (*c == 0, FALSE);
1353
1354         /* sanity check */
1355         if (!g_ascii_isxdigit (subchannels[0]))
1356                 return FALSE;
1357
1358         /* Get the first channel */
1359         while (*p && (*p != ',')) {
1360                 if (!g_ascii_isxdigit (*p) && (*p != '.'))
1361                         return FALSE;  /* Invalid chars */
1362                 if (i >= BUFSIZE)
1363                         return FALSE;  /* Too long to be a subchannel */
1364                 buf[i++] = *p++;
1365         }
1366         buf[i] = '\0';
1367
1368         /* and grab each of its elements, there should be 3 */
1369         pa = &buf[0];
1370         pb = strchr (buf, '.');
1371         if (pb)
1372                 pc = strchr (pb + 1, '.');
1373         if (!pa || !pb || !pc)
1374                 return FALSE;
1375
1376         /* Split the string */
1377         *pb++ = '\0';
1378         *pc++ = '\0';
1379
1380         errno = 0;
1381         tmp = strtoul (pa, NULL, 16);
1382         if (errno)
1383                 return FALSE;
1384         *a = (guint32) tmp;
1385
1386         errno = 0;
1387         tmp = strtoul (pb, NULL, 16);
1388         if (errno)
1389                 return FALSE;
1390         *b = (guint32) tmp;
1391
1392         errno = 0;
1393         tmp = strtoul (pc, NULL, 16);
1394         if (errno)
1395                 return FALSE;
1396         *c = (guint32) tmp;
1397
1398         return TRUE;
1399 }
1400
1401 NMMatchSpecMatchType
1402 nm_match_spec_s390_subchannels (const GSList *specs, const char *subchannels)
1403 {
1404         const GSList *iter;
1405         guint32 a = 0, b = 0, c = 0;
1406         guint32 spec_a = 0, spec_b = 0, spec_c = 0;
1407         NMMatchSpecMatchType match = NM_MATCH_SPEC_NO_MATCH;
1408
1409         g_return_val_if_fail (subchannels != NULL, NM_MATCH_SPEC_NO_MATCH);
1410
1411         if (!specs)
1412                 return NM_MATCH_SPEC_NO_MATCH;
1413
1414         if (!parse_subchannels (subchannels, &a, &b, &c))
1415                 return NM_MATCH_SPEC_NO_MATCH;
1416
1417         for (iter = specs; iter; iter = g_slist_next (iter)) {
1418                 const char *spec_str = iter->data;
1419                 gboolean except;
1420
1421                 if (!spec_str || !*spec_str)
1422                         continue;
1423
1424                 spec_str = _match_except (spec_str, &except);
1425
1426                 if (!g_ascii_strncasecmp (spec_str, SUBCHAN_TAG, NM_STRLEN (SUBCHAN_TAG))) {
1427                         spec_str += NM_STRLEN (SUBCHAN_TAG);
1428                         if (parse_subchannels (spec_str, &spec_a, &spec_b, &spec_c)) {
1429                                 if (a == spec_a && b == spec_b && c == spec_c) {
1430                                         if (except)
1431                                                 return NM_MATCH_SPEC_NEG_MATCH;
1432                                         match = NM_MATCH_SPEC_MATCH;
1433                                 }
1434                         }
1435                 }
1436         }
1437         return match;
1438 }
1439
1440 static gboolean
1441 _match_config_nm_version (const char *str, const char *tag, guint cur_nm_version)
1442 {
1443         gs_free char *s_ver = NULL;
1444         gs_strfreev char **s_ver_tokens = NULL;
1445         gint v_maj = -1, v_min = -1, v_mic = -1;
1446         guint c_maj = -1, c_min = -1, c_mic = -1;
1447         guint n_tokens;
1448
1449         s_ver = g_strdup (str);
1450         g_strstrip (s_ver);
1451
1452         /* Let's be strict with the accepted format here. No funny stuff!! */
1453
1454         if (s_ver[strspn (s_ver, ".0123456789")] != '\0')
1455                 return FALSE;
1456
1457         s_ver_tokens = g_strsplit (s_ver, ".", -1);
1458         n_tokens = g_strv_length (s_ver_tokens);
1459         if (n_tokens == 0 || n_tokens > 3)
1460                 return FALSE;
1461
1462         v_maj = _nm_utils_ascii_str_to_int64 (s_ver_tokens[0], 10, 0, 0xFFFF, -1);
1463         if (v_maj < 0)
1464                 return FALSE;
1465         if (n_tokens >= 2) {
1466                 v_min = _nm_utils_ascii_str_to_int64 (s_ver_tokens[1], 10, 0, 0xFF, -1);
1467                 if (v_min < 0)
1468                         return FALSE;
1469         }
1470         if (n_tokens >= 3) {
1471                 v_mic = _nm_utils_ascii_str_to_int64 (s_ver_tokens[2], 10, 0, 0xFF, -1);
1472                 if (v_mic < 0)
1473                         return FALSE;
1474         }
1475
1476         nm_decode_version (cur_nm_version, &c_maj, &c_min, &c_mic);
1477
1478 #define CHECK_AND_RETURN_FALSE(cur, val, tag, is_last_digit) \
1479         G_STMT_START { \
1480                 if (!strcmp (tag, MATCH_TAG_CONFIG_NM_VERSION_MIN)) { \
1481                         if (cur < val) \
1482                                 return FALSE; \
1483                 } else if (!strcmp (tag, MATCH_TAG_CONFIG_NM_VERSION_MAX)) { \
1484                         if (cur > val) \
1485                                 return FALSE; \
1486                 } else { \
1487                         if (cur != val) \
1488                                 return FALSE; \
1489                 } \
1490                 if (!(is_last_digit)) { \
1491                         if (cur != val) \
1492                                 return FALSE; \
1493                 } \
1494         } G_STMT_END
1495         if (v_mic >= 0)
1496                 CHECK_AND_RETURN_FALSE (c_mic, v_mic, tag, TRUE);
1497         if (v_min >= 0)
1498                 CHECK_AND_RETURN_FALSE (c_min, v_min, tag, v_mic < 0);
1499         CHECK_AND_RETURN_FALSE (c_maj, v_maj, tag, v_min < 0);
1500         return TRUE;
1501 }
1502
1503 NMMatchSpecMatchType
1504 nm_match_spec_match_config (const GSList *specs, guint cur_nm_version, const char *env)
1505 {
1506         const GSList *iter;
1507         NMMatchSpecMatchType match = NM_MATCH_SPEC_NO_MATCH;
1508
1509         if (!specs)
1510                 return NM_MATCH_SPEC_NO_MATCH;
1511
1512         for (iter = specs; iter; iter = g_slist_next (iter)) {
1513                 const char *spec_str = iter->data;
1514                 gboolean except;
1515                 gboolean v_match;
1516
1517                 if (!spec_str || !*spec_str)
1518                         continue;
1519
1520                 spec_str = _match_except (spec_str, &except);
1521
1522                 if (_spec_has_prefix (&spec_str, MATCH_TAG_CONFIG_NM_VERSION))
1523                         v_match = _match_config_nm_version (spec_str, MATCH_TAG_CONFIG_NM_VERSION, cur_nm_version);
1524                 else if (_spec_has_prefix (&spec_str, MATCH_TAG_CONFIG_NM_VERSION_MIN))
1525                         v_match = _match_config_nm_version (spec_str, MATCH_TAG_CONFIG_NM_VERSION_MIN, cur_nm_version);
1526                 else if (_spec_has_prefix (&spec_str, MATCH_TAG_CONFIG_NM_VERSION_MAX))
1527                         v_match = _match_config_nm_version (spec_str, MATCH_TAG_CONFIG_NM_VERSION_MAX, cur_nm_version);
1528                 else if (_spec_has_prefix (&spec_str, MATCH_TAG_CONFIG_ENV))
1529                         v_match = env && env[0] && !strcmp (spec_str, env);
1530                 else
1531                         continue;
1532
1533                 if (v_match) {
1534                         if (except)
1535                                 return NM_MATCH_SPEC_NEG_MATCH;
1536                         match = NM_MATCH_SPEC_MATCH;
1537                 }
1538         }
1539         return match;
1540 }
1541
1542 /**
1543  * nm_match_spec_split:
1544  * @value: the string of device specs
1545  *
1546  * Splits the specs from the string and returns them as individual
1547  * entires in a #GSList.
1548  *
1549  * It does not validate any specs, it basically just does a special
1550  * strsplit with ',' or ';' as separators and supporting '\\' as
1551  * escape character.
1552  *
1553  * Leading and trailing spaces of each entry are removed. But the user
1554  * can preserve them by specifying "\\s has 2 leading" or "has 2 trailing \\s".
1555  *
1556  * Specs can have a qualifier like "interface-name:". We still don't strip
1557  * any whitespace after the colon, so "interface-name: X" matches an interface
1558  * named " X".
1559  *
1560  * Returns: (transfer full): the list of device specs.
1561  */
1562 GSList *
1563 nm_match_spec_split (const char *value)
1564 {
1565         char *string_value, *p, *q0, *q;
1566         GSList *pieces = NULL;
1567         int trailing_ws;
1568
1569         if (!value || !*value)
1570                 return NULL;
1571
1572         /* Copied from glibs g_key_file_parse_value_as_string() function
1573          * and adjusted. */
1574
1575         string_value = g_new (gchar, strlen (value) + 1);
1576
1577         p = (gchar *) value;
1578
1579         /* skip over leading whitespace */
1580         while (g_ascii_isspace (*p))
1581                 p++;
1582
1583         q0 = q = string_value;
1584         trailing_ws = 0;
1585         while (*p) {
1586                 if (*p == '\\') {
1587                         p++;
1588
1589                         switch (*p) {
1590                         case 's':
1591                                 *q = ' ';
1592                                 break;
1593                         case 'n':
1594                                 *q = '\n';
1595                                 break;
1596                         case 't':
1597                                 *q = '\t';
1598                                 break;
1599                         case 'r':
1600                                 *q = '\r';
1601                                 break;
1602                         case '\\':
1603                                 *q = '\\';
1604                                 break;
1605                         case '\0':
1606                                 break;
1607                         default:
1608                                 if (NM_IN_SET (*p, ',', ';'))
1609                                         *q = *p;
1610                                 else {
1611                                         *q++ = '\\';
1612                                         *q = *p;
1613                                 }
1614                                 break;
1615                         }
1616                         if (*p == '\0')
1617                                 break;
1618                         p++;
1619                         trailing_ws = 0;
1620                 } else {
1621                         *q = *p;
1622                         if (*p == '\0')
1623                                 break;
1624                         if (g_ascii_isspace (*p)) {
1625                                 trailing_ws++;
1626                                 p++;
1627                         } else if (NM_IN_SET (*p, ',', ';')) {
1628                                 if (q0 < q - trailing_ws)
1629                                         pieces = g_slist_prepend (pieces, g_strndup (q0, (q - q0) - trailing_ws));
1630                                 q0 = q + 1;
1631                                 p++;
1632                                 trailing_ws = 0;
1633                                 while (g_ascii_isspace (*p))
1634                                         p++;
1635                         } else
1636                                 p++;
1637                 }
1638                 q++;
1639         }
1640
1641         *q = '\0';
1642         if (q0 < q - trailing_ws)
1643                 pieces = g_slist_prepend (pieces, g_strndup (q0, (q - q0) - trailing_ws));
1644         g_free (string_value);
1645         return g_slist_reverse (pieces);
1646 }
1647
1648 /**
1649  * nm_match_spec_join:
1650  * @specs: the device specs to join
1651  *
1652  * This is based on g_key_file_parse_string_as_value(), analog to
1653  * nm_match_spec_split() which is based on g_key_file_parse_value_as_string().
1654  *
1655  * Returns: (transfer full): a joined list of device specs that can be
1656  *   split again with nm_match_spec_split(). Note that
1657  *   nm_match_spec_split (nm_match_spec_join (specs)) yields the original
1658  *   result (which is not true the other way around because there are multiple
1659  *   ways to encode the same joined specs string).
1660  */
1661 char *
1662 nm_match_spec_join (GSList *specs)
1663 {
1664         const char *p;
1665         GString *str;
1666
1667         str = g_string_new ("");
1668
1669         for (; specs; specs = specs->next) {
1670                 p = specs->data;
1671
1672                 if (!p || !*p)
1673                         continue;
1674
1675                 if (str->len > 0)
1676                         g_string_append_c (str, ',');
1677
1678                 /* escape leading whitespace */
1679                 switch (*p) {
1680                 case ' ':
1681                         g_string_append (str, "\\s");
1682                         p++;
1683                         break;
1684                 case '\t':
1685                         g_string_append (str, "\\t");
1686                         p++;
1687                         break;
1688                 }
1689
1690                 for (; *p; p++) {
1691                         switch (*p) {
1692                         case '\n':
1693                                 g_string_append (str, "\\n");
1694                                 break;
1695                         case '\r':
1696                                 g_string_append (str, "\\r");
1697                                 break;
1698                         case '\\':
1699                                 g_string_append (str, "\\\\");
1700                                 break;
1701                         case ',':
1702                                 g_string_append (str, "\\,");
1703                                 break;
1704                         case ';':
1705                                 g_string_append (str, "\\;");
1706                                 break;
1707                         default:
1708                                 g_string_append_c (str, *p);
1709                                 break;
1710                         }
1711                 }
1712
1713                 /* escape trailing whitespaces */
1714                 switch (str->str[str->len - 1]) {
1715                 case ' ':
1716                         g_string_overwrite (str, str->len - 1, "\\s");
1717                         break;
1718                 case '\t':
1719                         g_string_overwrite (str, str->len - 1, "\\t");
1720                         break;
1721                 }
1722         }
1723
1724         return g_string_free (str, FALSE);
1725 }
1726
1727 /*****************************************************************************/
1728
1729 char _nm_utils_to_string_buffer[];
1730
1731 void
1732 nm_utils_to_string_buffer_init (char **buf, gsize *len)
1733 {
1734         if (!*buf) {
1735                 *buf = _nm_utils_to_string_buffer;
1736                 *len = sizeof (_nm_utils_to_string_buffer);
1737         }
1738 }
1739
1740 gboolean
1741 nm_utils_to_string_buffer_init_null (gconstpointer obj, char **buf, gsize *len)
1742 {
1743         nm_utils_to_string_buffer_init (buf, len);
1744         if (!obj) {
1745                 g_strlcpy (*buf, "(null)", *len);
1746                 return FALSE;
1747         }
1748         return TRUE;
1749 }
1750
1751 void
1752 nm_utils_strbuf_append_c (char **buf, gsize *len, char c)
1753 {
1754         switch (*len) {
1755         case 0:
1756                 return;
1757         case 1:
1758                 (*buf)[0] = '\0';
1759                 *len = 0;
1760                 (*buf)++;
1761                 return;
1762         default:
1763                 (*buf)[0] = c;
1764                 (*buf)[1] = '\0';
1765                 (*len)--;
1766                 (*buf)++;
1767                 return;
1768         }
1769 }
1770
1771 void
1772 nm_utils_strbuf_append_str (char **buf, gsize *len, const char *str)
1773 {
1774         gsize src_len;
1775
1776         switch (*len) {
1777         case 0:
1778                 return;
1779         case 1:
1780                 if (!str || !*str) {
1781                         (*buf)[0] = '\0';
1782                         return;
1783                 }
1784                 (*buf)[0] = '\0';
1785                 *len = 0;
1786                 (*buf)++;
1787                 return;
1788         default:
1789                 if (!str || !*str) {
1790                         (*buf)[0] = '\0';
1791                         return;
1792                 }
1793                 src_len = g_strlcpy (*buf, str, *len);
1794                 if (src_len >= *len) {
1795                         *buf = &(*buf)[*len];
1796                         *len = 0;
1797                 } else {
1798                         *buf = &(*buf)[src_len];
1799                         *len -= src_len;
1800                 }
1801                 return;
1802         }
1803 }
1804
1805 void
1806 nm_utils_strbuf_append (char **buf, gsize *len, const char *format, ...)
1807 {
1808         char *p = *buf;
1809         va_list args;
1810         gint retval;
1811
1812         if (*len == 0)
1813                 return;
1814
1815         va_start (args, format);
1816         retval = g_vsnprintf (p, *len, format, args);
1817         va_end (args);
1818
1819         if (retval >= *len) {
1820                 *buf = &p[*len];
1821                 *len = 0;
1822         } else {
1823                 *buf = &p[retval];
1824                 *len -= retval;
1825         }
1826 }
1827
1828 const char *
1829 nm_utils_flags2str (const NMUtilsFlags2StrDesc *descs,
1830                     gsize n_descs,
1831                     unsigned flags,
1832                     char *buf,
1833                     gsize len)
1834 {
1835         gsize i;
1836         char *p;
1837
1838 #if NM_MORE_ASSERTS > 10
1839         nm_assert (descs);
1840         nm_assert (n_descs > 0);
1841         for (i = 0; i < n_descs; i++) {
1842                 gsize j;
1843
1844                 nm_assert (descs[i].flag && nm_utils_is_power_of_two (descs[i].flag));
1845                 nm_assert (descs[i].name && descs[i].name[0]);
1846                 for (j = 0; j < i; j++)
1847                         nm_assert (descs[j].flag != descs[i].flag);
1848         }
1849 #endif
1850
1851         nm_utils_to_string_buffer_init (&buf, &len);
1852
1853         if (!len)
1854                 return buf;
1855
1856         buf[0] = '\0';
1857         if (!flags) {
1858                 return buf;
1859         }
1860
1861         p = buf;
1862         for (i = 0; flags && i < n_descs; i++) {
1863                 if (NM_FLAGS_HAS (flags, descs[i].flag)) {
1864                         flags &= ~descs[i].flag;
1865
1866                         if (buf[0] != '\0')
1867                                 nm_utils_strbuf_append_c (&p, &len, ',');
1868                         nm_utils_strbuf_append_str (&p, &len, descs[i].name);
1869                 }
1870         }
1871         if (flags) {
1872                 if (buf[0] != '\0')
1873                         nm_utils_strbuf_append_c (&p, &len, ',');
1874                 nm_utils_strbuf_append (&p, &len, "0x%x", flags);
1875         }
1876         return buf;
1877 };
1878
1879 /*****************************************************************************/
1880
1881 char *
1882 nm_utils_new_vlan_name (const char *parent_iface, guint32 vlan_id)
1883 {
1884         guint id_len;
1885         gsize parent_len;
1886         char *ifname;
1887
1888         g_return_val_if_fail (parent_iface && *parent_iface, NULL);
1889
1890         if (vlan_id < 10)
1891                 id_len = 2;
1892         else if (vlan_id < 100)
1893                 id_len = 3;
1894         else if (vlan_id < 1000)
1895                 id_len = 4;
1896         else {
1897                 g_return_val_if_fail (vlan_id < 4095, NULL);
1898                 id_len = 5;
1899         }
1900
1901         ifname = g_new (char, IFNAMSIZ);
1902
1903         parent_len = strlen (parent_iface);
1904         parent_len = MIN (parent_len, IFNAMSIZ - 1 - id_len);
1905         memcpy (ifname, parent_iface, parent_len);
1906         g_snprintf (&ifname[parent_len], IFNAMSIZ - parent_len, ".%u", vlan_id);
1907
1908         return ifname;
1909 }
1910
1911 /**
1912  * nm_utils_read_resolv_conf_nameservers():
1913  * @rc_contents: contents of a resolv.conf; or %NULL to read /etc/resolv.conf
1914  *
1915  * Reads all nameservers out of @rc_contents or /etc/resolv.conf and returns
1916  * them.
1917  *
1918  * Returns: a #GPtrArray of 'char *' elements of each nameserver line from
1919  * @contents or resolv.conf
1920  */
1921 GPtrArray *
1922 nm_utils_read_resolv_conf_nameservers (const char *rc_contents)
1923 {
1924         GPtrArray *nameservers = NULL;
1925         char *contents = NULL;
1926         char **lines, **iter;
1927         char *p;
1928
1929         if (rc_contents)
1930                 contents = g_strdup (rc_contents);
1931         else {
1932                 if (!g_file_get_contents (_PATH_RESCONF, &contents, NULL, NULL))
1933                         return NULL;
1934         }
1935
1936         nameservers = g_ptr_array_new_full (3, g_free);
1937
1938         lines = g_strsplit_set (contents, "\r\n", -1);
1939         for (iter = lines; *iter; iter++) {
1940                 if (!g_str_has_prefix (*iter, "nameserver"))
1941                         continue;
1942                 p = *iter + strlen ("nameserver");
1943                 if (!g_ascii_isspace (*p++))
1944                         continue;
1945                 /* Skip intermediate whitespace */
1946                 while (g_ascii_isspace (*p))
1947                         p++;
1948                 g_strchomp (p);
1949
1950                 g_ptr_array_add (nameservers, g_strdup (p));
1951         }
1952         g_strfreev (lines);
1953         g_free (contents);
1954
1955         return nameservers;
1956 }
1957
1958 /**
1959  * nm_utils_read_resolv_conf_dns_options():
1960  * @rc_contents: contents of a resolv.conf; or %NULL to read /etc/resolv.conf
1961  *
1962  * Reads all dns options out of @rc_contents or /etc/resolv.conf and returns
1963  * them.
1964  *
1965  * Returns: a #GPtrArray of 'char *' elements of each option
1966  */
1967 GPtrArray *
1968 nm_utils_read_resolv_conf_dns_options (const char *rc_contents)
1969 {
1970         GPtrArray *options = NULL;
1971         char *contents = NULL;
1972         char **lines, **line_iter;
1973         char **tokens, **token_iter;
1974         char *p;
1975
1976         if (rc_contents)
1977                 contents = g_strdup (rc_contents);
1978         else {
1979                 if (!g_file_get_contents (_PATH_RESCONF, &contents, NULL, NULL))
1980                         return NULL;
1981         }
1982
1983         options = g_ptr_array_new_full (3, g_free);
1984
1985         lines = g_strsplit_set (contents, "\r\n", -1);
1986         for (line_iter = lines; *line_iter; line_iter++) {
1987                 if (!g_str_has_prefix (*line_iter, "options"))
1988                         continue;
1989                 p = *line_iter + strlen ("options");
1990                 if (!g_ascii_isspace (*p++))
1991                         continue;
1992
1993                 tokens = g_strsplit (p, " ", 0);
1994                 for (token_iter = tokens; token_iter && *token_iter; token_iter++) {
1995                         g_strstrip (*token_iter);
1996                         if (!*token_iter[0])
1997                                 continue;
1998                         g_ptr_array_add (options, g_strdup (*token_iter));
1999                 }
2000                 g_strfreev (tokens);
2001         }
2002         g_strfreev (lines);
2003         g_free (contents);
2004
2005         return options;
2006 }
2007
2008 int
2009 nm_utils_cmp_connection_by_autoconnect_priority (NMConnection **a, NMConnection **b)
2010 {
2011         NMSettingConnection *a_s_con, *b_s_con;
2012         gboolean a_ac, b_ac;
2013         gint a_ap, b_ap;
2014
2015         a_s_con = nm_connection_get_setting_connection (*a);
2016         b_s_con = nm_connection_get_setting_connection (*b);
2017
2018         a_ac = !!nm_setting_connection_get_autoconnect (a_s_con);
2019         b_ac = !!nm_setting_connection_get_autoconnect (b_s_con);
2020         if (a_ac != b_ac)
2021                 return ((int) b_ac) - ((int) a_ac);
2022         if (!a_ac)
2023                 return 0;
2024
2025         a_ap = nm_setting_connection_get_autoconnect_priority (a_s_con);
2026         b_ap = nm_setting_connection_get_autoconnect_priority (b_s_con);
2027         if (a_ap != b_ap)
2028                 return (a_ap > b_ap) ? -1 : 1;
2029
2030         return 0;
2031 }
2032
2033 /**************************************************************************/
2034
2035 static gint64 monotonic_timestamp_offset_sec;
2036 static int monotonic_timestamp_clock_mode = 0;
2037
2038 static void
2039 monotonic_timestamp_get (struct timespec *tp)
2040 {
2041         int clock_mode = 0;
2042         int err = 0;
2043
2044         switch (monotonic_timestamp_clock_mode) {
2045         case 0:
2046                 /* the clock is not yet initialized (first run) */
2047                 err = clock_gettime (CLOCK_BOOTTIME, tp);
2048                 if (err == -1 && errno == EINVAL) {
2049                         clock_mode = 2;
2050                         err = clock_gettime (CLOCK_MONOTONIC, tp);
2051                 } else
2052                         clock_mode = 1;
2053                 break;
2054         case 1:
2055                 /* default, return CLOCK_BOOTTIME */
2056                 err = clock_gettime (CLOCK_BOOTTIME, tp);
2057                 break;
2058         case 2:
2059                 /* fallback, return CLOCK_MONOTONIC. Kernels prior to 2.6.39
2060                  * don't support CLOCK_BOOTTIME. */
2061                 err = clock_gettime (CLOCK_MONOTONIC, tp);
2062                 break;
2063         }
2064
2065         g_assert (err == 0); (void)err;
2066         g_assert (tp->tv_nsec >= 0 && tp->tv_nsec < NM_UTILS_NS_PER_SECOND);
2067
2068         if (G_LIKELY (clock_mode == 0))
2069                 return;
2070
2071         /* Calculate an offset for the time stamp.
2072          *
2073          * We always want positive values, because then we can initialize
2074          * a timestamp with 0 and be sure, that it will be less then any
2075          * value nm_utils_get_monotonic_timestamp_*() might return.
2076          * For this to be true also for nm_utils_get_monotonic_timestamp_s() at
2077          * early boot, we have to shift the timestamp to start counting at
2078          * least from 1 second onward.
2079          *
2080          * Another advantage of shifting is, that this way we make use of the whole 31 bit
2081          * range of signed int, before the time stamp for nm_utils_get_monotonic_timestamp_s()
2082          * wraps (~68 years).
2083          **/
2084         monotonic_timestamp_offset_sec = (- ((gint64) tp->tv_sec)) + 1;
2085         monotonic_timestamp_clock_mode = clock_mode;
2086
2087         if (nm_logging_enabled (LOGL_DEBUG, LOGD_CORE)) {
2088                 time_t now = time (NULL);
2089                 struct tm tm;
2090                 char s[255];
2091
2092                 strftime (s, sizeof (s), "%Y-%m-%d %H:%M:%S", localtime_r (&now, &tm));
2093                 nm_log_dbg (LOGD_CORE, "monotonic timestamp started counting 1.%09ld seconds ago with "
2094                                        "an offset of %lld.0 seconds to %s (local time is %s)",
2095                                        tp->tv_nsec, (long long) -monotonic_timestamp_offset_sec,
2096                                        clock_mode == 1 ? "CLOCK_BOOTTIME" : "CLOCK_MONOTONIC", s);
2097         }
2098 }
2099
2100 /**
2101  * nm_utils_get_monotonic_timestamp_ns:
2102  *
2103  * Returns: a monotonically increasing time stamp in nanoseconds,
2104  * starting at an unspecified offset. See clock_gettime(), %CLOCK_BOOTTIME.
2105  *
2106  * The returned value will start counting at an undefined point
2107  * in the past and will always be positive.
2108  *
2109  * All the nm_utils_get_monotonic_timestamp_*s functions return the same
2110  * timestamp but in different scales (nsec, usec, msec, sec).
2111  **/
2112 gint64
2113 nm_utils_get_monotonic_timestamp_ns (void)
2114 {
2115         struct timespec tp = { 0 };
2116
2117         monotonic_timestamp_get (&tp);
2118
2119         /* Although the result will always be positive, we return a signed
2120          * integer, which makes it easier to calculate time differences (when
2121          * you want to subtract signed values).
2122          **/
2123         return (((gint64) tp.tv_sec) + monotonic_timestamp_offset_sec) * NM_UTILS_NS_PER_SECOND +
2124                tp.tv_nsec;
2125 }
2126
2127 /**
2128  * nm_utils_get_monotonic_timestamp_us:
2129  *
2130  * Returns: a monotonically increasing time stamp in microseconds,
2131  * starting at an unspecified offset. See clock_gettime(), %CLOCK_BOOTTIME.
2132  *
2133  * The returned value will start counting at an undefined point
2134  * in the past and will always be positive.
2135  *
2136  * All the nm_utils_get_monotonic_timestamp_*s functions return the same
2137  * timestamp but in different scales (nsec, usec, msec, sec).
2138  **/
2139 gint64
2140 nm_utils_get_monotonic_timestamp_us (void)
2141 {
2142         struct timespec tp = { 0 };
2143
2144         monotonic_timestamp_get (&tp);
2145
2146         /* Although the result will always be positive, we return a signed
2147          * integer, which makes it easier to calculate time differences (when
2148          * you want to subtract signed values).
2149          **/
2150         return (((gint64) tp.tv_sec) + monotonic_timestamp_offset_sec) * ((gint64) G_USEC_PER_SEC) +
2151                (tp.tv_nsec / (NM_UTILS_NS_PER_SECOND/G_USEC_PER_SEC));
2152 }
2153
2154 /**
2155  * nm_utils_get_monotonic_timestamp_ms:
2156  *
2157  * Returns: a monotonically increasing time stamp in milliseconds,
2158  * starting at an unspecified offset. See clock_gettime(), %CLOCK_BOOTTIME.
2159  *
2160  * The returned value will start counting at an undefined point
2161  * in the past and will always be positive.
2162  *
2163  * All the nm_utils_get_monotonic_timestamp_*s functions return the same
2164  * timestamp but in different scales (nsec, usec, msec, sec).
2165  **/
2166 gint64
2167 nm_utils_get_monotonic_timestamp_ms (void)
2168 {
2169         struct timespec tp = { 0 };
2170
2171         monotonic_timestamp_get (&tp);
2172
2173         /* Although the result will always be positive, we return a signed
2174          * integer, which makes it easier to calculate time differences (when
2175          * you want to subtract signed values).
2176          **/
2177         return (((gint64) tp.tv_sec) + monotonic_timestamp_offset_sec) * ((gint64) 1000) +
2178                (tp.tv_nsec / (NM_UTILS_NS_PER_SECOND/1000));
2179 }
2180
2181 /**
2182  * nm_utils_get_monotonic_timestamp_s:
2183  *
2184  * Returns: nm_utils_get_monotonic_timestamp_ms() in seconds (throwing
2185  * away sub second parts). The returned value will always be positive.
2186  *
2187  * This value wraps after roughly 68 years which should be fine for any
2188  * practical purpose.
2189  *
2190  * All the nm_utils_get_monotonic_timestamp_*s functions return the same
2191  * timestamp but in different scales (nsec, usec, msec, sec).
2192  **/
2193 gint32
2194 nm_utils_get_monotonic_timestamp_s (void)
2195 {
2196         struct timespec tp = { 0 };
2197
2198         monotonic_timestamp_get (&tp);
2199         return (((gint64) tp.tv_sec) + monotonic_timestamp_offset_sec);
2200 }
2201
2202 typedef struct
2203 {
2204         const char *name;
2205         NMSetting *setting;
2206         NMSetting *diff_base_setting;
2207         GHashTable *setting_diff;
2208 } LogConnectionSettingData;
2209
2210 typedef struct
2211 {
2212         const char *item_name;
2213         NMSettingDiffResult diff_result;
2214 } LogConnectionSettingItem;
2215
2216 static gint
2217 _log_connection_sort_hashes_fcn (gconstpointer a, gconstpointer b)
2218 {
2219         const LogConnectionSettingData *v1 = a;
2220         const LogConnectionSettingData *v2 = b;
2221         guint32 p1, p2;
2222         NMSetting *s1, *s2;
2223
2224         s1 = v1->setting ? v1->setting : v1->diff_base_setting;
2225         s2 = v2->setting ? v2->setting : v2->diff_base_setting;
2226
2227         g_assert (s1 && s2);
2228
2229         p1 = _nm_setting_get_setting_priority (s1);
2230         p2 = _nm_setting_get_setting_priority (s2);
2231
2232         if (p1 != p2)
2233                 return p1 > p2 ? 1 : -1;
2234
2235         return strcmp (v1->name, v2->name);
2236 }
2237
2238 static GArray *
2239 _log_connection_sort_hashes (NMConnection *connection, NMConnection *diff_base, GHashTable *connection_diff)
2240 {
2241         GHashTableIter iter;
2242         GArray *sorted_hashes;
2243         LogConnectionSettingData setting_data;
2244
2245         sorted_hashes = g_array_sized_new (TRUE, FALSE, sizeof (LogConnectionSettingData), g_hash_table_size (connection_diff));
2246
2247         g_hash_table_iter_init (&iter, connection_diff);
2248         while (g_hash_table_iter_next (&iter, (gpointer) &setting_data.name, (gpointer) &setting_data.setting_diff)) {
2249                 setting_data.setting = nm_connection_get_setting_by_name (connection, setting_data.name);
2250                 setting_data.diff_base_setting = diff_base ? nm_connection_get_setting_by_name (diff_base, setting_data.name) : NULL;
2251                 g_assert (setting_data.setting || setting_data.diff_base_setting);
2252                 g_array_append_val (sorted_hashes, setting_data);
2253         }
2254
2255         g_array_sort (sorted_hashes, _log_connection_sort_hashes_fcn);
2256         return sorted_hashes;
2257 }
2258
2259 static gint
2260 _log_connection_sort_names_fcn (gconstpointer a, gconstpointer b)
2261 {
2262         const LogConnectionSettingItem *v1 = a;
2263         const LogConnectionSettingItem *v2 = b;
2264
2265         /* we want to first show the items, that disappeared, then the one that changed and
2266          * then the ones that were added. */
2267
2268         if ((v1->diff_result & NM_SETTING_DIFF_RESULT_IN_A) != (v2->diff_result & NM_SETTING_DIFF_RESULT_IN_A))
2269                 return (v1->diff_result & NM_SETTING_DIFF_RESULT_IN_A) ? -1 : 1;
2270         if ((v1->diff_result & NM_SETTING_DIFF_RESULT_IN_B) != (v2->diff_result & NM_SETTING_DIFF_RESULT_IN_B))
2271                 return (v1->diff_result & NM_SETTING_DIFF_RESULT_IN_B) ? 1 : -1;
2272         return strcmp (v1->item_name, v2->item_name);
2273 }
2274
2275 static char *
2276 _log_connection_get_property (NMSetting *setting, const char *name)
2277 {
2278         GValue val = G_VALUE_INIT;
2279         char *s;
2280
2281         g_return_val_if_fail (setting, NULL);
2282
2283         if (   !NM_IS_SETTING_VPN (setting)
2284             && nm_setting_get_secret_flags (setting, name, NULL, NULL))
2285                 return g_strdup ("****");
2286
2287         if (!_nm_setting_get_property (setting, name, &val))
2288                 g_return_val_if_reached (FALSE);
2289
2290         if (G_VALUE_HOLDS_STRING (&val)) {
2291                 const char *val_s;
2292
2293                 val_s = g_value_get_string (&val);
2294                 if (!val_s) {
2295                         /* for NULL, we want to return the unquoted string "NULL". */
2296                         s = g_strdup ("NULL");
2297                 } else {
2298                         char *escaped = g_strescape (val_s, "'");
2299
2300                         s = g_strdup_printf ("'%s'", escaped);
2301                         g_free (escaped);
2302                 }
2303         } else {
2304                 s = g_strdup_value_contents (&val);
2305                 if (s == NULL)
2306                         s = g_strdup ("NULL");
2307                 else {
2308                         char *escaped = g_strescape (s, "'");
2309
2310                         g_free (s);
2311                         s = escaped;
2312                 }
2313         }
2314         g_value_unset(&val);
2315         return s;
2316 }
2317
2318 static void
2319 _log_connection_sort_names (LogConnectionSettingData *setting_data, GArray *sorted_names)
2320 {
2321         GHashTableIter iter;
2322         LogConnectionSettingItem item;
2323         gpointer p;
2324
2325         g_array_set_size (sorted_names, 0);
2326
2327         g_hash_table_iter_init (&iter, setting_data->setting_diff);
2328         while (g_hash_table_iter_next (&iter, (gpointer) &item.item_name, &p)) {
2329                 item.diff_result = GPOINTER_TO_UINT (p);
2330                 g_array_append_val (sorted_names, item);
2331         }
2332
2333         g_array_sort (sorted_names, _log_connection_sort_names_fcn);
2334 }
2335
2336 void
2337 nm_utils_log_connection_diff (NMConnection *connection, NMConnection *diff_base, guint32 level, guint64 domain, const char *name, const char *prefix)
2338 {
2339         GHashTable *connection_diff = NULL;
2340         GArray *sorted_hashes;
2341         GArray *sorted_names = NULL;
2342         int i, j;
2343         gboolean connection_diff_are_same;
2344         gboolean print_header = TRUE;
2345         gboolean print_setting_header;
2346         GString *str1;
2347
2348         g_return_if_fail (NM_IS_CONNECTION (connection));
2349         g_return_if_fail (!diff_base || (NM_IS_CONNECTION (diff_base) && diff_base != connection));
2350
2351         /* For VPN setting types, this is broken, because we cannot (generically) print the content of data/secrets. Bummer... */
2352
2353         if (!nm_logging_enabled (level, domain))
2354                 return;
2355
2356         if (!prefix)
2357                 prefix = "";
2358         if (!name)
2359                 name = "";
2360
2361         connection_diff_are_same = nm_connection_diff (connection, diff_base, NM_SETTING_COMPARE_FLAG_EXACT | NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT, &connection_diff);
2362         if (connection_diff_are_same) {
2363                 if (diff_base)
2364                         nm_log (level, domain, "%sconnection '%s' (%p/%s and %p/%s): no difference", prefix, name, connection, G_OBJECT_TYPE_NAME (connection), diff_base, G_OBJECT_TYPE_NAME (diff_base));
2365                 else
2366                         nm_log (level, domain, "%sconnection '%s' (%p/%s): no properties set", prefix, name, connection, G_OBJECT_TYPE_NAME (connection));
2367                 g_assert (!connection_diff);
2368                 return;
2369         }
2370
2371         /* FIXME: it doesn't nicely show the content of NMSettingVpn, becuase nm_connection_diff() does not
2372          * expand the hash values. */
2373
2374         sorted_hashes = _log_connection_sort_hashes (connection, diff_base, connection_diff);
2375         if (sorted_hashes->len <= 0)
2376                 goto out;
2377
2378         sorted_names = g_array_new (FALSE, FALSE, sizeof (LogConnectionSettingItem));
2379         str1 = g_string_new (NULL);
2380
2381         for (i = 0; i < sorted_hashes->len; i++) {
2382                 LogConnectionSettingData *setting_data = &g_array_index (sorted_hashes, LogConnectionSettingData, i);
2383
2384                 _log_connection_sort_names (setting_data, sorted_names);
2385                 print_setting_header = TRUE;
2386                 for (j = 0; j < sorted_names->len; j++) {
2387                         char *str_conn, *str_diff;
2388                         LogConnectionSettingItem *item = &g_array_index (sorted_names, LogConnectionSettingItem, j);
2389
2390                         str_conn = (item->diff_result & NM_SETTING_DIFF_RESULT_IN_A)
2391                                    ? _log_connection_get_property (setting_data->setting, item->item_name)
2392                                    : NULL;
2393                         str_diff = (item->diff_result & NM_SETTING_DIFF_RESULT_IN_B)
2394                                    ? _log_connection_get_property (setting_data->diff_base_setting, item->item_name)
2395                                    : NULL;
2396
2397                         if (print_header) {
2398                                 GError *err_verify = NULL;
2399                                 const char *path = nm_connection_get_path (connection);
2400
2401                                 if (diff_base) {
2402                                         nm_log (level, domain, "%sconnection '%s' (%p/%s < %p/%s)%s%s%s:", prefix, name, connection, G_OBJECT_TYPE_NAME (connection), diff_base, G_OBJECT_TYPE_NAME (diff_base),
2403                                                 NM_PRINT_FMT_QUOTED (path, " [", path, "]", ""));
2404                                 } else {
2405                                         nm_log (level, domain, "%sconnection '%s' (%p/%s):%s%s%s", prefix, name, connection, G_OBJECT_TYPE_NAME (connection),
2406                                                 NM_PRINT_FMT_QUOTED (path, " [", path, "]", ""));
2407                                 }
2408                                 print_header = FALSE;
2409
2410                                 if (!nm_connection_verify (connection, &err_verify)) {
2411                                         nm_log (level, domain, "%sconnection %p does not verify: %s", prefix, connection, err_verify->message);
2412                                         g_clear_error (&err_verify);
2413                                 }
2414                         }
2415 #define _NM_LOG_ALIGN "-25"
2416                         if (print_setting_header) {
2417                                 if (diff_base) {
2418                                         if (setting_data->setting && setting_data->diff_base_setting)
2419                                                 g_string_printf (str1, "%p < %p", setting_data->setting, setting_data->diff_base_setting);
2420                                         else if (setting_data->diff_base_setting)
2421                                                 g_string_printf (str1, "*missing* < %p", setting_data->diff_base_setting);
2422                                         else
2423                                                 g_string_printf (str1, "%p < *missing*", setting_data->setting);
2424                                         nm_log (level, domain, "%s%"_NM_LOG_ALIGN"s [ %s ]", prefix, setting_data->name, str1->str);
2425                                 } else
2426                                         nm_log (level, domain, "%s%"_NM_LOG_ALIGN"s [ %p ]", prefix, setting_data->name, setting_data->setting);
2427                                 print_setting_header = FALSE;
2428                         }
2429                         g_string_printf (str1, "%s.%s", setting_data->name, item->item_name);
2430                         switch (item->diff_result & (NM_SETTING_DIFF_RESULT_IN_A | NM_SETTING_DIFF_RESULT_IN_B)) {
2431                                 case NM_SETTING_DIFF_RESULT_IN_B:
2432                                         nm_log (level, domain, "%s%"_NM_LOG_ALIGN"s < %s", prefix, str1->str, str_diff ? str_diff : "NULL");
2433                                         break;
2434                                 case NM_SETTING_DIFF_RESULT_IN_A:
2435                                         nm_log (level, domain, "%s%"_NM_LOG_ALIGN"s = %s", prefix, str1->str, str_conn ? str_conn : "NULL");
2436                                         break;
2437                                 default:
2438                                         nm_log (level, domain, "%s%"_NM_LOG_ALIGN"s = %s < %s", prefix, str1->str, str_conn ? str_conn : "NULL", str_diff ? str_diff : "NULL");
2439                                         break;
2440 #undef _NM_LOG_ALIGN
2441                         }
2442                         g_free (str_conn);
2443                         g_free (str_diff);
2444                 }
2445         }
2446
2447         g_array_free (sorted_names, TRUE);
2448         g_string_free (str1, TRUE);
2449 out:
2450         g_hash_table_destroy (connection_diff);
2451         g_array_free (sorted_hashes, TRUE);
2452 }
2453
2454 /**
2455  * nm_utils_monotonic_timestamp_as_boottime:
2456  * @timestamp: the monotonic-timestamp that should be converted into CLOCK_BOOTTIME.
2457  * @timestamp_ns_per_tick: How many nano seconds make one unit of @timestamp? E.g. if
2458  * @timestamp is in unit seconds, pass %NM_UTILS_NS_PER_SECOND; @timestamp in nano
2459  * seconds, pass 1; @timestamp in milli seconds, pass %NM_UTILS_NS_PER_SECOND/1000; etc.
2460  *
2461  * Returns: the monotonic-timestamp as CLOCK_BOOTTIME, as returned by clock_gettime().
2462  * The unit is the same as the passed in @timestamp basd on @timestamp_ns_per_tick.
2463  * E.g. if you passed @timestamp in as seconds, it will return boottime in seconds.
2464  * If @timestamp is a non-positive, it returns -1. Note that a (valid) monotonic-timestamp
2465  * is always positive.
2466  *
2467  * On older kernels that don't support CLOCK_BOOTTIME, the returned time is instead CLOCK_MONOTONIC.
2468  **/
2469 gint64
2470 nm_utils_monotonic_timestamp_as_boottime (gint64 timestamp, gint64 timestamp_ns_per_tick)
2471 {
2472         gint64 offset;
2473
2474         /* only support ns-per-tick being a multiple of 10. */
2475         g_return_val_if_fail (timestamp_ns_per_tick == 1
2476                               || (timestamp_ns_per_tick > 0 &&
2477                                   timestamp_ns_per_tick <= NM_UTILS_NS_PER_SECOND &&
2478                                   timestamp_ns_per_tick % 10 == 0),
2479                               -1);
2480
2481         /* Check that the timestamp is in a valid range. */
2482         g_return_val_if_fail (timestamp >= 0, -1);
2483
2484         /* if the caller didn't yet ever fetch a monotonic-timestamp, he cannot pass any meaningful
2485          * value (because he has no idea what these timestamps would be). That would be a bug. */
2486         g_return_val_if_fail (monotonic_timestamp_clock_mode != 0, -1);
2487
2488         /* calculate the offset of monotonic-timestamp to boottime. offset_s is <= 1. */
2489         offset = monotonic_timestamp_offset_sec * (NM_UTILS_NS_PER_SECOND / timestamp_ns_per_tick);
2490
2491         /* check for overflow. */
2492         g_return_val_if_fail (offset > 0 || timestamp < G_MAXINT64 + offset, G_MAXINT64);
2493
2494         return timestamp - offset;
2495 }
2496
2497
2498 #define IPV6_PROPERTY_DIR "/proc/sys/net/ipv6/conf/"
2499 #define IPV4_PROPERTY_DIR "/proc/sys/net/ipv4/conf/"
2500 G_STATIC_ASSERT (sizeof (IPV4_PROPERTY_DIR) == sizeof (IPV6_PROPERTY_DIR));
2501
2502 static const char *
2503 _get_property_path (const char *ifname,
2504                     const char *property,
2505                     gboolean ipv6)
2506 {
2507         static char path[sizeof (IPV6_PROPERTY_DIR) + IFNAMSIZ + 32];
2508         int len;
2509
2510         ifname = NM_ASSERT_VALID_PATH_COMPONENT (ifname);
2511         property = NM_ASSERT_VALID_PATH_COMPONENT (property);
2512
2513         len = g_snprintf (path,
2514                           sizeof (path),
2515                           "%s%s/%s",
2516                           ipv6 ? IPV6_PROPERTY_DIR : IPV4_PROPERTY_DIR,
2517                           ifname,
2518                           property);
2519         g_assert (len < sizeof (path) - 1);
2520
2521         return path;
2522 }
2523
2524 /**
2525  * nm_utils_ip6_property_path:
2526  * @ifname: an interface name
2527  * @property: a property name
2528  *
2529  * Returns the path to IPv6 property @property on @ifname. Note that
2530  * this uses a static buffer.
2531  */
2532 const char *
2533 nm_utils_ip6_property_path (const char *ifname, const char *property)
2534 {
2535         return _get_property_path (ifname, property, TRUE);
2536 }
2537
2538 /**
2539  * nm_utils_ip4_property_path:
2540  * @ifname: an interface name
2541  * @property: a property name
2542  *
2543  * Returns the path to IPv4 property @property on @ifname. Note that
2544  * this uses a static buffer.
2545  */
2546 const char *
2547 nm_utils_ip4_property_path (const char *ifname, const char *property)
2548 {
2549         return _get_property_path (ifname, property, FALSE);
2550 }
2551
2552 gboolean
2553 nm_utils_is_valid_path_component (const char *name)
2554 {
2555         const char *n;
2556
2557         if (name == NULL || name[0] == '\0')
2558                 return FALSE;
2559
2560         if (name[0] == '.') {
2561                 if (name[1] == '\0')
2562                         return FALSE;
2563                 if (name[1] == '.' && name[2] == '\0')
2564                         return FALSE;
2565         }
2566         n = name;
2567         do {
2568                 if (*n == '/')
2569                         return FALSE;
2570         } while (*(++n) != '\0');
2571
2572         return TRUE;
2573 }
2574
2575 const char *
2576 NM_ASSERT_VALID_PATH_COMPONENT (const char *name)
2577 {
2578         if (G_LIKELY (nm_utils_is_valid_path_component (name)))
2579                 return name;
2580
2581         nm_log_err (LOGD_CORE, "Failed asserting path component: %s%s%s",
2582                     NM_PRINT_FMT_QUOTED (name, "\"", name, "\"", "(null)"));
2583         g_error ("FATAL: Failed asserting path component: %s%s%s",
2584                  NM_PRINT_FMT_QUOTED (name, "\"", name, "\"", "(null)"));
2585         g_assert_not_reached ();
2586 }
2587
2588 gboolean
2589 nm_utils_is_specific_hostname (const char *name)
2590 {
2591         if (!name)
2592                 return FALSE;
2593         if (   strcmp (name, "(none)")
2594             && strcmp (name, "localhost")
2595             && strcmp (name, "localhost6")
2596             && strcmp (name, "localhost.localdomain")
2597             && strcmp (name, "localhost6.localdomain6"))
2598                 return TRUE;
2599         return FALSE;
2600 }
2601
2602 /******************************************************************/
2603
2604 /* Returns the "u" (universal/local) bit value for a Modified EUI-64 */
2605 static gboolean
2606 get_gre_eui64_u_bit (guint32 addr)
2607 {
2608         static const struct {
2609                 guint32 mask;
2610                 guint32 result;
2611         } items[] = {
2612                 { 0xff000000 }, { 0x7f000000 },  /* IPv4 loopback */
2613                 { 0xf0000000 }, { 0xe0000000 },  /* IPv4 multicast */
2614                 { 0xffffff00 }, { 0xe0000000 },  /* IPv4 local multicast */
2615                 { 0xffffffff }, { INADDR_BROADCAST },  /* limited broadcast */
2616                 { 0xff000000 }, { 0x00000000 },  /* zero net */
2617                 { 0xff000000 }, { 0x0a000000 },  /* private 10 (RFC3330) */
2618                 { 0xfff00000 }, { 0xac100000 },  /* private 172 */
2619                 { 0xffff0000 }, { 0xc0a80000 },  /* private 192 */
2620                 { 0xffff0000 }, { 0xa9fe0000 },  /* IPv4 link-local */
2621                 { 0xffffff00 }, { 0xc0586300 },  /* anycast 6-to-4 */
2622                 { 0xffffff00 }, { 0xc0000200 },  /* test 192 */
2623                 { 0xfffe0000 }, { 0xc6120000 },  /* test 198 */
2624         };
2625         guint i;
2626
2627         for (i = 0; i < G_N_ELEMENTS (items); i++) {
2628                 if ((addr & htonl (items[i].mask)) == htonl (items[i].result))
2629                         return 0x00; /* "local" scope */
2630         }
2631         return 0x02; /* "universal" scope */
2632 }
2633
2634 /**
2635  * nm_utils_get_ipv6_interface_identifier:
2636  * @link_type: the hardware link type
2637  * @hwaddr: the hardware address of the interface
2638  * @hwaddr_len: the length (in bytes) of @hwaddr
2639  * @dev_id: the device identifier, if any
2640  * @out_iid: on success, filled with the interface identifier; on failure
2641  * zeroed out
2642  *
2643  * Constructs an interface identifier in "Modified EUI-64" format which is
2644  * suitable for constructing IPv6 addresses.  Note that the identifier is
2645  * not obscured in any way (eg, RFC3041).
2646  *
2647  * Returns: %TRUE if the interface identifier could be constructed, %FALSE if
2648  * if could not be constructed.
2649  */
2650 gboolean
2651 nm_utils_get_ipv6_interface_identifier (NMLinkType link_type,
2652                                         const guint8 *hwaddr,
2653                                         guint hwaddr_len,
2654                                         guint dev_id,
2655                                         NMUtilsIPv6IfaceId *out_iid)
2656 {
2657         guint32 addr;
2658
2659         g_return_val_if_fail (hwaddr != NULL, FALSE);
2660         g_return_val_if_fail (hwaddr_len > 0, FALSE);
2661         g_return_val_if_fail (out_iid != NULL, FALSE);
2662
2663         out_iid->id = 0;
2664
2665         switch (link_type) {
2666         case NM_LINK_TYPE_INFINIBAND:
2667                 /* Use the port GUID per http://tools.ietf.org/html/rfc4391#section-8,
2668                  * making sure to set the 'u' bit to 1.  The GUID is the lower 64 bits
2669                  * of the IPoIB interface's hardware address.
2670                  */
2671                 g_return_val_if_fail (hwaddr_len == INFINIBAND_ALEN, FALSE);
2672                 memcpy (out_iid->id_u8, hwaddr + INFINIBAND_ALEN - 8, 8);
2673                 out_iid->id_u8[0] |= 0x02;
2674                 return TRUE;
2675         case NM_LINK_TYPE_GRE:
2676         case NM_LINK_TYPE_GRETAP:
2677                 /* Hardware address is the network-endian IPv4 address */
2678                 g_return_val_if_fail (hwaddr_len == 4, FALSE);
2679                 addr = * (guint32 *) hwaddr;
2680                 out_iid->id_u8[0] = get_gre_eui64_u_bit (addr);
2681                 out_iid->id_u8[1] = 0x00;
2682                 out_iid->id_u8[2] = 0x5E;
2683                 out_iid->id_u8[3] = 0xFE;
2684                 memcpy (out_iid->id_u8 + 4, &addr, 4);
2685                 return TRUE;
2686         default:
2687                 if (hwaddr_len == ETH_ALEN) {
2688                         /* Translate 48-bit MAC address to a 64-bit Modified EUI-64.  See
2689                          * http://tools.ietf.org/html/rfc4291#appendix-A and the Linux
2690                          * kernel's net/ipv6/addrconf.c::ipv6_generate_eui64() function.
2691                          */
2692                         out_iid->id_u8[0] = hwaddr[0];
2693                         out_iid->id_u8[1] = hwaddr[1];
2694                         out_iid->id_u8[2] = hwaddr[2];
2695                         if (dev_id) {
2696                                 out_iid->id_u8[3] = (dev_id >> 8) & 0xff;
2697                                 out_iid->id_u8[4] = dev_id & 0xff;
2698                         } else {
2699                                 out_iid->id_u8[0] ^= 0x02;
2700                                 out_iid->id_u8[3] = 0xff;
2701                                 out_iid->id_u8[4] = 0xfe;
2702                         }
2703                         out_iid->id_u8[5] = hwaddr[3];
2704                         out_iid->id_u8[6] = hwaddr[4];
2705                         out_iid->id_u8[7] = hwaddr[5];
2706                         return TRUE;
2707                 }
2708                 break;
2709         }
2710         return FALSE;
2711 }
2712 void
2713 nm_utils_ipv6_addr_set_interface_identfier (struct in6_addr *addr,
2714                                             const NMUtilsIPv6IfaceId iid)
2715 {
2716         memcpy (addr->s6_addr + 8, &iid.id_u8, 8);
2717 }
2718
2719 void
2720 nm_utils_ipv6_interface_identfier_get_from_addr (NMUtilsIPv6IfaceId *iid,
2721                                                  const struct in6_addr *addr)
2722 {
2723         memcpy (iid, addr->s6_addr + 8, 8);
2724 }
2725
2726 static gboolean
2727 _set_stable_privacy (struct in6_addr *addr,
2728                      const char *ifname,
2729                      const char *uuid,
2730                      guint dad_counter,
2731                      gchar *secret_key,
2732                      gsize key_len,
2733                      GError **error)
2734 {
2735         GChecksum *sum;
2736         guint8 digest[32];
2737         guint32 tmp[2];
2738         gsize len = sizeof (digest);
2739
2740         g_return_val_if_fail (key_len, FALSE);
2741
2742         /* Documentation suggests that this can fail.
2743          * Maybe in case of a missing algorithm in crypto library? */
2744         sum = g_checksum_new (G_CHECKSUM_SHA256);
2745         if (!sum) {
2746                 g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN,
2747                                      "Can't create a SHA256 hash");
2748                 return FALSE;
2749         }
2750
2751         key_len = MIN (key_len, G_MAXUINT32);
2752
2753         g_checksum_update (sum, addr->s6_addr, 8);
2754         g_checksum_update (sum, (const guchar *) ifname, strlen (ifname) + 1);
2755         if (!uuid)
2756                 uuid = "";
2757         g_checksum_update (sum, (const guchar *) uuid, strlen (uuid) + 1);
2758         tmp[0] = htonl (dad_counter);
2759         tmp[1] = htonl (key_len);
2760         g_checksum_update (sum, (const guchar *) tmp, sizeof (tmp));
2761         g_checksum_update (sum, (const guchar *) secret_key, key_len);
2762
2763         g_checksum_get_digest (sum, digest, &len);
2764         g_checksum_free (sum);
2765
2766         g_return_val_if_fail (len == 32, FALSE);
2767
2768         memcpy (addr->s6_addr + 8, &digest[0], 8);
2769
2770         return TRUE;
2771 }
2772
2773 #define RFC7217_IDGEN_RETRIES 3
2774 /**
2775  * nm_utils_ipv6_addr_set_stable_privacy:
2776  *
2777  * Extend the address prefix with an interface identifier using the
2778  * RFC 7217 Stable Privacy mechanism.
2779  *
2780  * Returns: %TRUE on success, %FALSE if the address could not be generated.
2781  */
2782 gboolean
2783 nm_utils_ipv6_addr_set_stable_privacy (struct in6_addr *addr,
2784                                        const char *ifname,
2785                                        const char *uuid,
2786                                        guint dad_counter,
2787                                        GError **error)
2788 {
2789         gchar *secret_key = NULL;
2790         gsize key_len = 0;
2791         gboolean success = FALSE;
2792
2793         if (dad_counter >= RFC7217_IDGEN_RETRIES) {
2794                 g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN,
2795                                      "Too many DAD collisions");
2796                 return FALSE;
2797         }
2798
2799         /* Let's try to load a saved secret key first. */
2800         if (g_file_get_contents (NMSTATEDIR "/secret_key", &secret_key, &key_len, NULL)) {
2801                 if (key_len < 16) {
2802                         g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN,
2803                                              "Key is too short to be usable");
2804                         key_len = 0;
2805                 }
2806         } else {
2807                 int urandom = open ("/dev/urandom", O_RDONLY);
2808                 mode_t key_mask;
2809
2810                 if (urandom == -1) {
2811                         g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN,
2812                                      "Can't open /dev/urandom: %s", strerror (errno));
2813                         return FALSE;
2814                 }
2815
2816                 /* RFC7217 mandates the key SHOULD be at least 128 bits.
2817                  * Let's use twice as much. */
2818                 key_len = 32;
2819                 secret_key = g_malloc (key_len);
2820
2821                 key_mask = umask (0077);
2822                 if (read (urandom, secret_key, key_len) == key_len) {
2823                         if (!g_file_set_contents (NMSTATEDIR "/secret_key", secret_key, key_len, error)) {
2824                                 g_prefix_error (error, "Can't write " NMSTATEDIR "/secret_key");
2825                                 key_len = 0;
2826                         }
2827                 } else {
2828                         g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN,
2829                                              "Could not obtain a secret");
2830                         key_len = 0;
2831                 }
2832                 umask (key_mask);
2833                 close (urandom);
2834         }
2835
2836         if (key_len) {
2837                 success = _set_stable_privacy (addr, ifname, uuid, dad_counter,
2838                                                secret_key, key_len, error);
2839         }
2840
2841         g_free (secret_key);
2842         return success;
2843 }
2844
2845 /**
2846  * nm_utils_setpgid:
2847  * @unused: unused
2848  *
2849  * This can be passed as a child setup function to the g_spawn*() family
2850  * of functions, to ensure that the child is in its own process group
2851  * (and thus, in some situations, will not be killed when NetworkManager
2852  * is killed).
2853  */
2854 void
2855 nm_utils_setpgid (gpointer unused G_GNUC_UNUSED)
2856 {
2857         pid_t pid;
2858
2859         pid = getpid ();
2860         setpgid (pid, pid);
2861 }
2862
2863 /**
2864  * nm_utils_g_value_set_strv:
2865  * @value: a #GValue, initialized to store a #G_TYPE_STRV
2866  * @strings: a #GPtrArray of strings
2867  *
2868  * Converts @strings to a #GStrv and stores it in @value.
2869  */
2870 void
2871 nm_utils_g_value_set_strv (GValue *value, GPtrArray *strings)
2872 {
2873         char **strv;
2874         int i;
2875
2876         strv = g_new (char *, strings->len + 1);
2877         for (i = 0; i < strings->len; i++)
2878                 strv[i] = g_strdup (strings->pdata[i]);
2879         strv[i] = NULL;
2880
2881         g_value_take_boxed (value, strv);
2882 }
2883
2884 /*****************************************************************************/
2885
2886 static gboolean
2887 debug_key_matches (const gchar *key,
2888                    const gchar *token,
2889                    guint        length)
2890 {
2891         /* may not call GLib functions: see note in g_parse_debug_string() */
2892         for (; length; length--, key++, token++) {
2893                 char k = (*key   == '_') ? '-' : g_ascii_tolower (*key  );
2894                 char t = (*token == '_') ? '-' : g_ascii_tolower (*token);
2895
2896                 if (k != t)
2897                         return FALSE;
2898         }
2899
2900         return *key == '\0';
2901 }
2902
2903 /**
2904  * nm_utils_parse_debug_string:
2905  * @string: the string to parse
2906  * @keys: the debug keys
2907  * @nkeys: number of entires in @keys
2908  *
2909  * Similar to g_parse_debug_string(), but does not special
2910  * case "help" or "all".
2911  *
2912  * Returns: the flags
2913  */
2914 guint
2915 nm_utils_parse_debug_string (const char *string,
2916                              const GDebugKey *keys,
2917                              guint nkeys)
2918 {
2919         guint i;
2920         guint result = 0;
2921         const char *q;
2922
2923         if (string == NULL)
2924                 return 0;
2925
2926         while (*string) {
2927                 q = strpbrk (string, ":;, \t");
2928                 if (!q)
2929                         q = string + strlen (string);
2930
2931                 for (i = 0; i < nkeys; i++) {
2932                         if (debug_key_matches (keys[i].key, string, q - string))
2933                                 result |= keys[i].value;
2934                 }
2935
2936                 string = q;
2937                 if (*string)
2938                         string++;
2939         }
2940
2941         return result;
2942 }
2943
2944 /*****************************************************************************/
2945
2946 void
2947 nm_utils_ifname_cpy (char *dst, const char *name)
2948 {
2949         g_return_if_fail (dst);
2950         g_return_if_fail (name && name[0]);
2951
2952         nm_assert (nm_utils_iface_valid_name (name));
2953
2954         if (g_strlcpy (dst, name, IFNAMSIZ) >= IFNAMSIZ)
2955                 g_return_if_reached ();
2956 }
2957
2958 /*****************************************************************************/
2959
2960 #define IPV4LL_NETWORK (htonl (0xA9FE0000L))
2961 #define IPV4LL_NETMASK (htonl (0xFFFF0000L))
2962
2963 gboolean
2964 nm_utils_ip4_address_is_link_local (in_addr_t addr)
2965 {
2966         return (addr & IPV4LL_NETMASK) == IPV4LL_NETWORK;
2967 }
2968
2969 /*****************************************************************************/
2970
2971 /**
2972  * Takes a pair @timestamp and @duration, and returns the remaining duration based
2973  * on the new timestamp @now.
2974  */
2975 guint32
2976 nm_utils_lifetime_rebase_relative_time_on_now (guint32 timestamp,
2977                                                guint32 duration,
2978                                                gint32 now)
2979 {
2980         gint64 t;
2981
2982         nm_assert (now >= 0);
2983
2984         if (duration == NM_PLATFORM_LIFETIME_PERMANENT)
2985                 return NM_PLATFORM_LIFETIME_PERMANENT;
2986
2987         if (timestamp == 0) {
2988                 /* if the @timestamp is zero, assume it was just left unset and that the relative
2989                  * @duration starts counting from @now. This is convenient to construct an address
2990                  * and print it in nm_platform_ip4_address_to_string().
2991                  *
2992                  * In general it does not make sense to set the @duration without anchoring at
2993                  * @timestamp because you don't know the absolute expiration time when looking
2994                  * at the address at a later moment. */
2995                 timestamp = now;
2996         }
2997
2998         /* For timestamp > now, just accept it and calculate the expected(?) result. */
2999         t = (gint64) timestamp + (gint64) duration - (gint64) now;
3000
3001         if (t <= 0)
3002                 return 0;
3003         if (t >= NM_PLATFORM_LIFETIME_PERMANENT)
3004                 return NM_PLATFORM_LIFETIME_PERMANENT - 1;
3005         return t;
3006 }
3007
3008 gboolean
3009 nm_utils_lifetime_get (guint32 timestamp,
3010                        guint32 lifetime,
3011                        guint32 preferred,
3012                        gint32 now,
3013                        guint32 *out_lifetime,
3014                        guint32 *out_preferred)
3015 {
3016         guint32 t_lifetime, t_preferred;
3017
3018         nm_assert (now >= 0);
3019
3020         if (lifetime == 0) {
3021                 *out_lifetime = NM_PLATFORM_LIFETIME_PERMANENT;
3022                 *out_preferred = NM_PLATFORM_LIFETIME_PERMANENT;
3023
3024                 /* We treat lifetime==0 as permanent addresses to allow easy creation of such addresses
3025                  * (without requiring to set the lifetime fields to NM_PLATFORM_LIFETIME_PERMANENT).
3026                  * In that case we also expect that the other fields (timestamp and preferred) are left unset. */
3027                 g_return_val_if_fail (timestamp == 0 && preferred == 0, TRUE);
3028         } else {
3029                 if (now <= 0)
3030                         now = nm_utils_get_monotonic_timestamp_s ();
3031                 t_lifetime = nm_utils_lifetime_rebase_relative_time_on_now (timestamp, lifetime, now);
3032                 if (!t_lifetime) {
3033                         *out_lifetime = 0;
3034                         *out_preferred = 0;
3035                         return FALSE;
3036                 }
3037                 t_preferred = nm_utils_lifetime_rebase_relative_time_on_now (timestamp, preferred, now);
3038
3039                 *out_lifetime = t_lifetime;
3040                 *out_preferred = MIN (t_preferred, t_lifetime);
3041
3042                 /* Assert that non-permanent addresses have a (positive) @timestamp. nm_utils_lifetime_rebase_relative_time_on_now()
3043                  * treats addresses with timestamp 0 as *now*. Addresses passed to _address_get_lifetime() always
3044                  * should have a valid @timestamp, otherwise on every re-sync, their lifetime will be extended anew.
3045                  */
3046                 g_return_val_if_fail (   timestamp != 0
3047                                       || (   lifetime  == NM_PLATFORM_LIFETIME_PERMANENT
3048                                           && preferred == NM_PLATFORM_LIFETIME_PERMANENT), TRUE);
3049                 g_return_val_if_fail (t_preferred <= t_lifetime, TRUE);
3050         }
3051         return TRUE;
3052 }
3053