usr/src/cmd/hal/hald/util.c

   1 /***************************************************************************
   2  * CVSID: $Id$
   3  *
   4  * util.c - Various utilities
   5  *
   6  * Copyright (C) 2004 David Zeuthen, <david@fubar.dk>
   7  *
   8  * Licensed under the Academic Free License version 2.1
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  23  *
  24  **************************************************************************/
  25
  26 #ifdef HAVE_CONFIG_H
  27 #  include <config.h>
  28 #endif
  29
  30 #include <stdio.h>
  31 #include <stdarg.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <time.h>
  35 #include <ctype.h>
  36 #include <stdint.h>
  37 #include <sys/stat.h>
  38 #include <unistd.h>
  39 #include <fcntl.h>
  40 #include <signal.h>
  41 #include <sys/wait.h>
  42 #include <sys/file.h>
  43
  44 #include <glib.h>
  45 #include <dbus/dbus.h>
  46 #include <dbus/dbus-glib.h>
  47
  48 #include "osspec.h"
  49 #include "logger.h"
  50 #include "hald.h"
  51 #include "hald_runner.h"
  52 #include "hald_dbus.h"
  53 #include "device_info.h"
  54
  55 #include "util.h"
  56
  57 /** Determine whether the given character is valid as the first character
  58  *  in a name.
  59  */
  60 #define VALID_INITIAL_NAME_CHARACTER(c)          \
  61         (((c) >= 'A' && (c) <= 'Z') ||           \
  62         ((c) >= 'a' && (c) <= 'z') ||            \
  63         ((c) == '_'))
  64
  65 /** Determine whether the given character is valid as a second or later
  66  *  character in a name.
  67  */
  68 #define VALID_NAME_CHARACTER(c)                  \
  69         (((c) >= '0' && (c) <= '9') ||           \
  70         ((c) >= 'A' && (c) <= 'Z') ||            \
  71         ((c) >= 'a' && (c) <= 'z') ||            \
  72         ((c) == '_'))
  73
  74 gboolean
  75 hal_util_remove_trailing_slash (gchar *path)
  76 {
  77         gchar *c = NULL;
  78
  79         if (path == NULL) {
  80                 return FALSE;
  81         }
  82
  83         c = strrchr (path, '/');
  84         if (c == NULL) {
  85                 HAL_WARNING (("Invalid path %s", path));
  86                 return 1;
  87         }
  88         if (*(c+1) == '\0')
  89                 *c = '\0';
  90
  91         return TRUE;
  92 }
  93
  94 /** Given a path, /foo/bar/bat/foobar, return the last element, e.g.
  95  *  foobar.
  96  *
  97  *  @param  path                Path
  98  *  @return                     Pointer into given string
  99  */
 100 const gchar *
 101 hal_util_get_last_element (const gchar *s)
 102 {
 103         int len;
 104         const gchar *p;
 105
 106         len = strlen (s);
 107         for (p = s + len - 1; p > s; --p) {
 108                 if ((*p) == '/')
 109                         return p + 1;
 110         }
 111
 112         return s;
 113 }
 114
 115 /** Given a path, this functions finds the path representing the
 116  *  parent directory by truncation.
 117  *
 118  *  @param  path                Path
 119  *  @return                     Path for parent or NULL. Must be freed by caller
 120  */
 121 gchar *
 122 hal_util_get_parent_path (const gchar *path)
 123 {
 124         guint i;
 125         guint len;
 126         gchar *parent_path;
 127
 128         /* Find parent device by truncating our own path */
 129         parent_path = g_strndup (path, HAL_PATH_MAX);
 130         len = strlen (parent_path);
 131         for (i = len - 1; parent_path[i] != '/'; --i) {
 132                 parent_path[i] = '\0';
 133         }
 134         parent_path[i] = '\0';
 135
 136         return parent_path;
 137 }
 138
 139 gchar *
 140 hal_util_get_normalized_path (const gchar *path1, const gchar *path2)
 141 {
 142         int len1;
 143         int len2;
 144         const gchar *p1;
 145         const gchar *p2;
 146         gchar buf[HAL_PATH_MAX];
 147
 148         len1 = strlen (path1);
 149         len2 = strlen (path2);
 150
 151         p1 = path1 + len1;
 152
 153         p2 = path2;
 154         while (p2 < path2 + len2 && strncmp (p2, "../", 3) == 0) {
 155                 p2 += 3;
 156
 157                 while (p1 >= path1 && *(--p1)!='/')
 158                         ;
 159         }
 160
 161         if ((p1-path1) < 0) {
 162                 HAL_ERROR (("Could not normalize '%s' and '%s', return 'NULL'", path1, path2));
 163                 return NULL;
 164         }
 165
 166         strncpy (buf, path1, (p1-path1));
 167         buf[p1-path1] = '\0';
 168
 169         return g_strdup_printf ("%s/%s", buf, p2);
 170 }
 171
 172 gboolean
 173 hal_util_get_int_from_file (const gchar *directory, const gchar *file, gint *result, gint base)
 174 {
 175         FILE *f;
 176         char buf[64];
 177         gchar path[HAL_PATH_MAX];
 178         gboolean ret;
 179
 180         f = NULL;
 181         ret = FALSE;
 182
 183         g_snprintf (path, sizeof (path), "%s/%s", directory, file);
 184
 185         f = fopen (path, "rb");
 186         if (f == NULL) {
 187                 HAL_ERROR (("Cannot open '%s'", path));
 188                 goto out;
 189         }
 190
 191         if (fgets (buf, sizeof (buf), f) == NULL) {
 192                 HAL_ERROR (("Cannot read from '%s'", path));
 193                 goto out;
 194         }
 195
 196         /* TODO: handle error condition */
 197         *result = strtol (buf, NULL, base);
 198         ret = TRUE;
 199
 200 out:
 201         if (f != NULL)
 202                 fclose (f);
 203
 204         return ret;
 205 }
 206
 207 gboolean
 208 hal_util_set_int_from_file (HalDevice *d, const gchar *key, const gchar *directory, const gchar *file, gint base)
 209 {
 210         gint value;
 211         gboolean ret;
 212
 213         ret = FALSE;
 214
 215         if (hal_util_get_int_from_file (directory, file, &value, base))
 216                 ret = hal_device_property_set_int (d, key, value);
 217
 218         return ret;
 219 }
 220
 221
 222 gboolean
 223 hal_util_get_uint64_from_file (const gchar *directory, const gchar *file, guint64 *result, gint base)
 224 {
 225         FILE *f;
 226         char buf[64];
 227         gchar path[HAL_PATH_MAX];
 228         gboolean ret;
 229
 230         f = NULL;
 231         ret = FALSE;
 232
 233         g_snprintf (path, sizeof (path), "%s/%s", directory, file);
 234
 235         f = fopen (path, "rb");
 236         if (f == NULL) {
 237                 HAL_ERROR (("Cannot open '%s'", path));
 238                 goto out;
 239         }
 240
 241         if (fgets (buf, sizeof (buf), f) == NULL) {
 242                 HAL_ERROR (("Cannot read from '%s'", path));
 243                 goto out;
 244         }
 245
 246         /* TODO: handle error condition */
 247         *result = strtoll (buf, NULL, base);
 248
 249         ret = TRUE;
 250
 251 out:
 252         if (f != NULL)
 253                 fclose (f);
 254
 255         return ret;
 256 }
 257
 258 gboolean
 259 hal_util_set_uint64_from_file (HalDevice *d, const gchar *key, const gchar *directory, const gchar *file, gint base)
 260 {
 261         guint64 value;
 262         gboolean ret;
 263
 264         ret = FALSE;
 265
 266         if (hal_util_get_uint64_from_file (directory, file, &value, base))
 267                 ret = hal_device_property_set_uint64 (d, key, value);
 268
 269         return ret;
 270 }
 271
 272 gboolean
 273 hal_util_get_bcd2_from_file (const gchar *directory, const gchar *file, gint *result)
 274 {
 275         FILE *f;
 276         char buf[64];
 277         gchar path[HAL_PATH_MAX];
 278         gboolean ret;
 279         gint digit;
 280         gint left, right;
 281         gboolean passed_white_space;
 282         gint num_prec;
 283         gsize len;
 284         gchar c;
 285         guint i;
 286
 287         f = NULL;
 288         ret = FALSE;
 289
 290         g_snprintf (path, sizeof (path), "%s/%s", directory, file);
 291
 292         f = fopen (path, "rb");
 293         if (f == NULL) {
 294                 HAL_ERROR (("Cannot open '%s'", path));
 295                 goto out;
 296         }
 297
 298         if (fgets (buf, sizeof (buf), f) == NULL) {
 299                 HAL_ERROR (("Cannot read from '%s'", path));
 300                 goto out;
 301         }
 302
 303         left = 0;
 304         len = strlen (buf);
 305         passed_white_space = FALSE;
 306         for (i = 0; i < len && buf[i] != '.'; i++) {
 307                 if (g_ascii_isspace (buf[i])) {
 308                         if (passed_white_space)
 309                                 break;
 310                         else
 311                                 continue;
 312                 }
 313                 passed_white_space = TRUE;
 314                 left *= 16;
 315                 c = buf[i];
 316                 digit = (int) (c - '0');
 317                 left += digit;
 318         }
 319         i++;
 320         right = 0;
 321         num_prec = 0;
 322         for (; i < len; i++) {
 323                 if (g_ascii_isspace (buf[i]))
 324                         break;
 325                 if (num_prec == 2)              /* Only care about two digits
 326                                                  * of precision */
 327                         break;
 328                 right *= 16;
 329                 c = buf[i];
 330                 digit = (int) (c - '0');
 331                 right += digit;
 332                 num_prec++;
 333         }
 334
 335         for (; num_prec < 2; num_prec++)
 336                 right *= 16;
 337
 338         *result = left * 256 + (right & 255);
 339         ret = TRUE;
 340
 341 out:
 342         if (f != NULL)
 343                 fclose (f);
 344
 345         return ret;
 346 }
 347
 348 gboolean
 349 hal_util_set_bcd2_from_file (HalDevice *d, const gchar *key, const gchar *directory, const gchar *file)
 350 {
 351         gint value;
 352         gboolean ret;
 353
 354         ret = FALSE;
 355
 356         if (hal_util_get_bcd2_from_file (directory, file, &value))
 357                 ret = hal_device_property_set_int (d, key, value);
 358
 359         return ret;
 360 }
 361
 362 gchar *
 363 hal_util_get_string_from_file (const gchar *directory, const gchar *file)
 364 {
 365         FILE *f;
 366         static gchar buf[256];
 367         gchar path[HAL_PATH_MAX];
 368         gchar *result;
 369         gsize len;
 370         gint i;
 371
 372         f = NULL;
 373         result = NULL;
 374
 375         g_snprintf (path, sizeof (path), "%s/%s", directory, file);
 376
 377         f = fopen (path, "rb");
 378         if (f == NULL) {
 379                 HAL_ERROR (("Cannot open '%s'", path));
 380                 goto out;
 381         }
 382
 383         buf[0] = '\0';
 384         if (fgets (buf, sizeof (buf), f) == NULL) {
 385                 HAL_ERROR (("Cannot read from '%s'", path));
 386                 goto out;
 387         }
 388
 389         len = strlen (buf);
 390         if (len>0)
 391                 buf[len-1] = '\0';
 392
 393         /* Clear remaining whitespace */
 394         for (i = len - 2; i >= 0; --i) {
 395                 if (!g_ascii_isspace (buf[i]))
 396                         break;
 397                 buf[i] = '\0';
 398         }
 399
 400         result = buf;
 401
 402 out:
 403         if (f != NULL)
 404                 fclose (f);
 405
 406         return result;
 407 }
 408
 409 gboolean
 410 hal_util_set_string_from_file (HalDevice *d, const gchar *key, const gchar *directory, const gchar *file)
 411 {
 412         gchar *buf;
 413         gboolean ret;
 414
 415         ret = FALSE;
 416
 417         if ((buf = hal_util_get_string_from_file (directory, file)) != NULL)
 418                 ret = hal_device_property_set_string (d, key, buf);
 419
 420         return ret;
 421 }
 422
 423 void
 424 hal_util_compute_udi (HalDeviceStore *store, gchar *dst, gsize dstsize, const gchar *format, ...)
 425 {
 426         guint i;
 427         va_list args;
 428         gchar buf[256];
 429
 430         va_start (args, format);
 431         g_vsnprintf (buf, sizeof (buf), format, args);
 432         va_end (args);
 433
 434         g_strcanon (buf,
 435                     "/_"
 436                     "abcdefghijklmnopqrstuvwxyz"
 437                     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 438                     "1234567890", '_');
 439
 440         g_strlcpy (dst, buf, dstsize);
 441         if (hal_device_store_find (store, dst) == NULL)
 442                 goto out;
 443
 444         for (i = 0; ; i++) {
 445                 g_snprintf (dst, dstsize, "%s_%d", buf, i);
 446                 if (hal_device_store_find (store, dst) == NULL)
 447                         goto out;
 448         }
 449
 450 out:
 451         ;
 452 }
 453
 454
 455 gboolean
 456 hal_util_path_ascend (gchar *path)
 457 {
 458         gchar *p;
 459
 460         if (path == NULL)
 461                 return FALSE;
 462
 463         p = strrchr (path, '/');
 464         if (p == NULL)
 465                 return FALSE;
 466
 467         *p = '\0';
 468         return TRUE;
 469 }
 470
 471 static gboolean _grep_can_reuse = FALSE;
 472
 473 void
 474 hal_util_grep_discard_existing_data (void)
 475 {
 476         _grep_can_reuse = FALSE;
 477 }
 478
 479 /** Given a directory and filename, open the file and search for the
 480  *  first line that starts with the given linestart string. Returns
 481  *  the rest of the line as a string if found.
 482  *
 483  *  @param  directory           Directory, e.g. "/proc/acpi/battery/BAT0"
 484  *  @param  file                File, e.g. "info"
 485  *  @param  linestart           Start of line, e.g. "serial number"
 486  *  @param  reuse               Whether we should reuse the file contents
 487  *                              if the file is the same; can be cleared
 488  *                              with hal_util_grep_discard_existing_data()
 489  *  @return                     NULL if not found, otherwise the remainder
 490  *                              of the line, e.g. ":           21805" if
 491  *                              the file /proc/acpi/battery/BAT0 contains
 492  *                              this line "serial number:           21805"
 493  *                              The string is only valid until the next
 494  *                              invocation of this function.
 495  */
 496 gchar *
 497 hal_util_grep_file (const gchar *directory, const gchar *file, const gchar *linestart, gboolean reuse)
 498 {
 499         static gchar buf[2048];
 500         static unsigned int bufsize;
 501         static gchar filename[HAL_PATH_MAX];
 502         static gchar oldfilename[HAL_PATH_MAX];
 503         gchar *result;
 504         gsize linestart_len;
 505         gchar *p;
 506
 507         result = NULL;
 508
 509         /* TODO: use reuse and _grep_can_reuse parameters to avoid loading
 510          *       the file again and again
 511          */
 512
 513         if (file != NULL && strlen (file) > 0)
 514                 snprintf (filename, sizeof (filename), "%s/%s", directory, file);
 515         else
 516                 strncpy (filename, directory, sizeof (filename));
 517
 518         if (_grep_can_reuse && reuse && strcmp (oldfilename, filename) == 0) {
 519                 /* just reuse old file; e.g. bufsize, buf */
 520                 /*HAL_INFO (("hal_util_grep_file: reusing buf for %s", filename));*/
 521         } else {
 522                 FILE *f;
 523
 524                 f = fopen (filename, "r");
 525                 if (f == NULL)
 526                         goto out;
 527                 bufsize = fread (buf, sizeof (char), sizeof (buf) - 1, f);
 528                 buf[bufsize] = '\0';
 529                 fclose (f);
 530
 531                 /*HAL_INFO (("hal_util_grep_file: read %s of %d bytes", filename, bufsize));*/
 532         }
 533
 534         /* book keeping */
 535         _grep_can_reuse = TRUE;
 536         strncpy (oldfilename, filename, sizeof(oldfilename));
 537
 538         linestart_len = strlen (linestart);
 539
 540         /* analyze buf */
 541         p = buf;
 542         do {
 543                 unsigned int linelen;
 544                 static char line[256];
 545
 546                 for (linelen = 0; p[linelen] != '\n' && p[linelen] != '\0'; linelen++)
 547                         ;
 548
 549                 if (linelen < sizeof (line)) {
 550
 551                         strncpy (line, p, linelen);
 552                         line[linelen] = '\0';
 553
 554                         if (strncmp (line, linestart, linestart_len) == 0) {
 555                                 result = line + linestart_len;
 556                                 goto out;
 557                         }
 558                 }
 559
 560                 p += linelen + 1;
 561
 562         } while (p < buf + bufsize);
 563
 564 out:
 565         return result;
 566 }
 567
 568 gchar *
 569 hal_util_grep_string_elem_from_file (const gchar *directory, const gchar *file,
 570                                      const gchar *linestart, guint elem, gboolean reuse)
 571 {
 572         gchar *line;
 573         gchar *res;
 574         static gchar buf[256];
 575         gchar **tokens;
 576         guint i, j;
 577
 578         res = NULL;
 579         tokens = NULL;
 580
 581         if (((line = hal_util_grep_file (directory, file, linestart, reuse)) == NULL) || (strlen (line) == 0))
 582                 goto out;
 583
 584         tokens = g_strsplit_set (line, " \t:", 0);
 585         for (i = 0, j = 0; tokens[i] != NULL; i++) {
 586                 if (strlen (tokens[i]) == 0)
 587                         continue;
 588                 if (j == elem) {
 589                         strncpy (buf, tokens[i], sizeof (buf));
 590                         res = buf;
 591                         goto out;
 592                 }
 593                 j++;
 594         }
 595
 596 out:
 597         if (tokens != NULL)
 598                 g_strfreev (tokens);
 599
 600         return res;
 601 }
 602
 603 gint
 604 hal_util_grep_int_elem_from_file (const gchar *directory, const gchar *file,
 605                                   const gchar *linestart, guint elem, guint base, gboolean reuse)
 606 {
 607         gchar *endptr;
 608         gchar *strvalue;
 609         int value;
 610
 611         value = G_MAXINT;
 612
 613         strvalue = hal_util_grep_string_elem_from_file (directory, file, linestart, elem, reuse);
 614         if (strvalue == NULL)
 615                 goto out;
 616
 617         value = strtol (strvalue, &endptr, base);
 618         if (endptr == strvalue) {
 619                 value = G_MAXINT;
 620                 goto out;
 621         }
 622
 623 out:
 624         return value;
 625 }
 626
 627 /** Get a string value from a formatted text file and assign it to
 628  *  a property on a device object.
 629  *
 630  *  Example: Given that the file /proc/acpi/battery/BAT0/info contains
 631  *  the line
 632  *
 633  *    "design voltage:          10800 mV"
 634  *
 635  *  then hal_util_set_string_elem_from_file (d, "battery.foo",
 636  *  "/proc/acpi/battery/BAT0", "info", "design voltage", 1) will assign
 637  *  the string "mV" to the property "battery.foo" on d.
 638  *
 639  *  @param  d                   Device object
 640  *  @param  key                 Property name
 641  *  @param  directory           Directory, e.g. "/proc/acpi/battery/BAT0"
 642  *  @param  file                File, e.g. "info"
 643  *  @param  linestart           Start of line, e.g. "design voltage"
 644  *  @param  elem                Element number after linestart to extract
 645  *                              excluding whitespace and ':' characters.
 646  *  @return                     TRUE, if, and only if, the value could be
 647  *                              extracted and the property was set
 648  */
 649 gboolean
 650 hal_util_set_string_elem_from_file (HalDevice *d, const gchar *key,
 651                                     const gchar *directory, const gchar *file,
 652                                     const gchar *linestart, guint elem, gboolean reuse)
 653 {
 654         gboolean res;
 655         gchar *value;
 656
 657         res = FALSE;
 658
 659         if ((value = hal_util_grep_string_elem_from_file (directory, file, linestart, elem, reuse)) == NULL)
 660                 goto out;
 661
 662         res = hal_device_property_set_string (d, key, value);
 663 out:
 664         return res;
 665 }
 666
 667 /** Get an integer value from a formatted text file and assign it to
 668  *  a property on a device object.
 669  *
 670  *  Example: Given that the file /proc/acpi/battery/BAT0/info contains
 671  *  the line
 672  *
 673  *    "design voltage:          10800 mV"
 674  *
 675  *  then hal_util_set_int_elem_from_file (d, "battery.foo",
 676  *  "/proc/acpi/battery/BAT0", "info", "design voltage", 0) will assign
 677  *  the integer 10800 to the property "battery.foo" on d.
 678  *
 679  *  @param  d                   Device object
 680  *  @param  key                 Property name
 681  *  @param  directory           Directory, e.g. "/proc/acpi/battery/BAT0"
 682  *  @param  file                File, e.g. "info"
 683  *  @param  linestart           Start of line, e.g. "design voltage"
 684  *  @param  elem                Element number after linestart to extract
 685  *                              excluding whitespace and ':' characters.
 686  *  @return                     TRUE, if, and only if, the value could be
 687  *                              extracted and the property was set
 688  */
 689 gboolean
 690 hal_util_set_int_elem_from_file (HalDevice *d, const gchar *key,
 691                                  const gchar *directory, const gchar *file,
 692                                  const gchar *linestart, guint elem, guint base, gboolean reuse)
 693 {
 694         gchar *endptr;
 695         gboolean res;
 696         gchar *strvalue;
 697         int value;
 698
 699         res = FALSE;
 700
 701         strvalue = hal_util_grep_string_elem_from_file (directory, file, linestart, elem, reuse);
 702         if (strvalue == NULL)
 703                 goto out;
 704
 705         value = strtol (strvalue, &endptr, base);
 706         if (endptr == strvalue)
 707                 goto out;
 708
 709         res = hal_device_property_set_int (d, key, value);
 710
 711 out:
 712         return res;
 713
 714 }
 715
 716 /** Get a value from a formatted text file, test it against a given
 717  *  value, and set a boolean property on a device object with the
 718  *  test result.
 719  *
 720  *  Example: Given that the file /proc/acpi/battery/BAT0/info contains
 721  *  the line
 722  *
 723  *    "present:                 yes"
 724  *
 725  *  then hal_util_set_bool_elem_from_file (d, "battery.baz",
 726  *  "/proc/acpi/battery/BAT0", "info", "present", 0, "yes") will assign
 727  *  the boolean TRUE to the property "battery.baz" on d.
 728  *
 729  *  If, instead, the line was
 730  *
 731  *    "present:                 no"
 732  *
 733  *  the value assigned will be FALSE.
 734  *
 735  *  @param  d                   Device object
 736  *  @param  key                 Property name
 737  *  @param  directory           Directory, e.g. "/proc/acpi/battery/BAT0"
 738  *  @param  file                File, e.g. "info"
 739  *  @param  linestart           Start of line, e.g. "design voltage"
 740  *  @param  elem                Element number after linestart to extract
 741  *                              excluding whitespace and ':' characters.
 742  *  @param  expected            Value to test against
 743  *  @return                     TRUE, if, and only if, the value could be
 744  *                              extracted and the property was set
 745  */
 746 gboolean
 747 hal_util_set_bool_elem_from_file (HalDevice *d, const gchar *key,
 748                                   const gchar *directory, const gchar *file,
 749                                   const gchar *linestart, guint elem, const gchar *expected, gboolean reuse)
 750 {
 751         gchar *line;
 752         gboolean res;
 753         gchar **tokens;
 754         guint i, j;
 755
 756         res = FALSE;
 757         tokens = NULL;
 758
 759         if (((line = hal_util_grep_file (directory, file, linestart, reuse)) == NULL) || (strlen (line) == 0))
 760                 goto out;
 761
 762         tokens = g_strsplit_set (line, " \t:", 0);
 763
 764         for (i = 0, j = 0; tokens[i] != NULL; i++) {
 765                 if (strlen (tokens[i]) == 0)
 766                         continue;
 767                 if (j == elem) {
 768                         hal_device_property_set_bool (d, key, strcmp (tokens[i], expected) == 0);
 769                         res = TRUE;
 770                         goto out;
 771                 }
 772                 j++;
 773         }
 774
 775
 776 out:
 777         if (tokens != NULL)
 778                 g_strfreev (tokens);
 779
 780         return res;
 781 }
 782
 783 gchar **
 784 hal_util_dup_strv_from_g_slist (GSList *strlist)
 785 {
 786         guint j;
 787         guint len;
 788         gchar **strv;
 789         GSList *i;
 790
 791         len = g_slist_length (strlist);
 792         strv = g_new (char *, len + 1);
 793
 794         for (i = strlist, j = 0; i != NULL; i = g_slist_next (i), j++) {
 795                 strv[j] = g_strdup ((const gchar *) i->data);
 796         }
 797         strv[j] = NULL;
 798
 799         return strv;
 800 }
 801
 802 /* -------------------------------------------------------------------------------------------------------------- */
 803
 804 typedef struct {
 805         HalDevice *d;
 806         gchar **programs;
 807         gchar **extra_env;
 808         guint next_program;
 809
 810         HalCalloutsDone callback;
 811         gpointer userdata1;
 812         gpointer userdata2;
 813
 814 } Callout;
 815
 816 static void callout_do_next (Callout *c);
 817
 818 static void
 819 callout_terminated (HalDevice *d, guint32 exit_type,
 820                    gint return_code, gchar **error,
 821                    gpointer data1, gpointer data2)
 822 {
 823         Callout *c;
 824
 825         c = (Callout *) data1;
 826         callout_do_next (c);
 827 }
 828
 829 static void
 830 callout_do_next (Callout *c)
 831 {
 832
 833         /* Check if we're done */
 834         if (c->programs[c->next_program] == NULL) {
 835                 HalDevice *d;
 836                 gpointer userdata1;
 837                 gpointer userdata2;
 838                 HalCalloutsDone callback;
 839
 840                 d = c->d;
 841                 userdata1 = c->userdata1;
 842                 userdata2 = c->userdata2;
 843                 callback = c->callback;
 844
 845                 g_strfreev (c->programs);
 846                 g_strfreev (c->extra_env);
 847                 g_free (c);
 848
 849                 callback (d, userdata1, userdata2);
 850
 851         } else {
 852     hald_runner_run(c->d, c->programs[c->next_program], c->extra_env,
 853                     HAL_HELPER_TIMEOUT, callout_terminated,
 854                     (gpointer)c, NULL);
 855                 c->next_program++;
 856         }
 857 }
 858
 859 static void
 860 hal_callout_device (HalDevice *d, HalCalloutsDone callback, gpointer userdata1, gpointer userdata2,
 861                     GSList *programs, gchar **extra_env)
 862 {
 863         Callout *c;
 864
 865         c = g_new0 (Callout, 1);
 866         c->d = d;
 867         c->callback = callback;
 868         c->userdata1 = userdata1;
 869         c->userdata2 = userdata2;
 870         c->programs = hal_util_dup_strv_from_g_slist (programs);
 871         c->extra_env = g_strdupv (extra_env);
 872         c->next_program = 0;
 873
 874         callout_do_next (c);
 875 }
 876
 877 void
 878 hal_util_callout_device_add (HalDevice *d, HalCalloutsDone callback, gpointer userdata1, gpointer userdata2)
 879 {
 880         GSList *programs;
 881         gchar *extra_env[2] = {"HALD_ACTION=add", NULL};
 882
 883         if ((programs = hal_device_property_get_strlist (d, "info.callouts.add")) == NULL) {
 884                 callback (d, userdata1, userdata2);
 885                 goto out;
 886         }
 887
 888         HAL_INFO (("Add callouts for udi=%s", d->udi));
 889
 890         hal_callout_device (d, callback, userdata1, userdata2, programs, extra_env);
 891 out:
 892         ;
 893 }
 894
 895 void
 896 hal_util_callout_device_remove (HalDevice *d, HalCalloutsDone callback, gpointer userdata1, gpointer userdata2)
 897 {
 898         GSList *programs;
 899         gchar *extra_env[2] = {"HALD_ACTION=remove", NULL};
 900
 901         if ((programs = hal_device_property_get_strlist (d, "info.callouts.remove")) == NULL) {
 902                 callback (d, userdata1, userdata2);
 903                 goto out;
 904         }
 905
 906         HAL_INFO (("Remove callouts for udi=%s", d->udi));
 907
 908         hal_callout_device (d, callback, userdata1, userdata2, programs, extra_env);
 909 out:
 910         ;
 911 }
 912
 913 void
 914 hal_util_callout_device_preprobe (HalDevice *d, HalCalloutsDone callback, gpointer userdata1, gpointer userdata2)
 915 {
 916         GSList *programs;
 917         gchar *extra_env[2] = {"HALD_ACTION=preprobe", NULL};
 918
 919         if ((programs = hal_device_property_get_strlist (d, "info.callouts.preprobe")) == NULL) {
 920                 callback (d, userdata1, userdata2);
 921                 goto out;
 922         }
 923
 924         HAL_INFO (("Preprobe callouts for udi=%s", d->udi));
 925
 926         hal_callout_device (d, callback, userdata1, userdata2, programs, extra_env);
 927 out:
 928         ;
 929 }
 930
 931 gchar *
 932 hal_util_strdup_valid_utf8 (const char *str)
 933 {
 934         char *endchar;
 935         char *newstr;
 936         unsigned int count = 0;
 937
 938         if (str == NULL)
 939                 return NULL;
 940
 941         newstr = g_strdup (str);
 942
 943         while (!g_utf8_validate (newstr, -1, (const char **) &endchar)) {
 944                 *endchar = '?';
 945                 count++;
 946         }
 947
 948         if (strlen(newstr) == count)
 949                 return NULL;
 950         else
 951                 return newstr;
 952 }
 953
 954 void
 955 hal_util_hexdump (const void *mem, unsigned int size)
 956 {
 957         unsigned int i;
 958         unsigned int j;
 959         unsigned int n;
 960         const char *buf = (const char *) mem;
 961
 962         n = 0;
 963         printf ("Dumping %d=0x%x bytes\n", size, size);
 964         while (n < size) {
 965
 966                 printf ("0x%04x: ", n);
 967
 968                 j = n;
 969                 for (i = 0; i < 16; i++) {
 970                         if (j >= size)
 971                                 break;
 972                         printf ("%02x ", buf[j]);
 973                         j++;
 974                 }
 975
 976                 for ( ; i < 16; i++) {
 977                         printf ("   ");
 978                 }
 979
 980                 printf ("   ");
 981
 982                 j = n;
 983                 for (i = 0; i < 16; i++) {
 984                         if (j >= size)
 985                                 break;
 986                         printf ("%c", isprint(buf[j]) ? buf[j] : '.');
 987                         j++;
 988                 }
 989
 990                 printf ("\n");
 991
 992                 n += 16;
 993         }
 994 }
 995
 996 gboolean
 997 hal_util_is_mounted_by_hald (const char *mount_point)
 998 {
 999         int i;
1000         FILE *hal_mtab;
1001         int hal_mtab_len;
1002         int num_read;
1003         char *hal_mtab_buf;
1004         char **lines;
1005         gboolean found;
1006
1007         hal_mtab = NULL;
1008         hal_mtab_buf = NULL;
1009         found = FALSE;
1010
1011         /*HAL_DEBUG (("examining /media/.hal-mtab for %s", mount_point));*/
1012
1013         hal_mtab = fopen ("/media/.hal-mtab", "r");
1014         if (hal_mtab == NULL) {
1015                 HAL_ERROR (("Cannot open /media/.hal-mtab"));
1016                 goto out;
1017         }
1018         if (fseek (hal_mtab, 0L, SEEK_END) != 0) {
1019                 HAL_ERROR (("Cannot seek to end of /media/.hal-mtab"));
1020                 goto out;
1021         }
1022         hal_mtab_len = ftell (hal_mtab);
1023         if (hal_mtab_len < 0) {
1024                 HAL_ERROR (("Cannot determine size of /media/.hal-mtab"));
1025                 goto out;
1026         }
1027         rewind (hal_mtab);
1028
1029         hal_mtab_buf = g_new0 (char, hal_mtab_len + 1);
1030         num_read = fread (hal_mtab_buf, 1, hal_mtab_len, hal_mtab);
1031         if (num_read != hal_mtab_len) {
1032                 HAL_ERROR (("Cannot read from /media/.hal-mtab"));
1033                 goto out;
1034         }
1035         fclose (hal_mtab);
1036         hal_mtab = NULL;
1037
1038         /*HAL_DEBUG (("hal_mtab = '%s'\n", hal_mtab_buf));*/
1039
1040         lines = g_strsplit (hal_mtab_buf, "\n", 0);
1041         g_free (hal_mtab_buf);
1042         hal_mtab_buf = NULL;
1043
1044         /* find the entry we're going to unmount */
1045         for (i = 0; lines[i] != NULL && !found; i++) {
1046                 char **line_elements;
1047
1048                 /*HAL_DEBUG ((" line = '%s'", lines[i]));*/
1049
1050                 if ((lines[i])[0] == '#')
1051                         continue;
1052
1053                 line_elements = g_strsplit (lines[i], "\t", 6);
1054                 if (g_strv_length (line_elements) == 6) {
1055 /*
1056                         HAL_DEBUG (("  devfile     = '%s'", line_elements[0]));
1057                         HAL_DEBUG (("  uid         = '%s'", line_elements[1]));
1058                         HAL_DEBUG (("  session id  = '%s'", line_elements[2]));
1059                         HAL_DEBUG (("  fs          = '%s'", line_elements[3]));
1060                         HAL_DEBUG (("  options     = '%s'", line_elements[4]));
1061                         HAL_DEBUG (("  mount_point = '%s'", line_elements[5]));
1062                         HAL_DEBUG (("  (comparing against '%s')", mount_point));
1063 */
1064
1065                         if (strcmp (line_elements[5], mount_point) == 0) {
1066                                 found = TRUE;
1067                                 /*HAL_INFO (("device at '%s' is indeed mounted by HAL's Mount()", mount_point));*/
1068                         }
1069
1070                 }
1071
1072                 g_strfreev (line_elements);
1073         }
1074
1075         g_strfreev (lines);
1076
1077 out:
1078         if (hal_mtab != NULL)
1079                 fclose (hal_mtab);
1080         if (hal_mtab_buf != NULL)
1081                 g_free (hal_mtab_buf);
1082
1083         return found;
1084 }
1085
1086 void
1087 hal_util_branch_claim (HalDeviceStore *store, HalDevice *root, dbus_bool_t claimed,
1088     const char *service, int uid)
1089 {
1090         GSList *children;
1091         GSList *i;
1092         HalDevice *d;
1093
1094         if (claimed) {
1095                 hal_device_property_set_bool (root, "info.claimed", claimed);
1096                 hal_device_property_set_string (root, "info.claimed.service", service);
1097                 hal_device_property_set_int (root, "info.claimed.uid", uid);
1098         } else {
1099                 hal_device_property_remove (root, "info.claimed");
1100                 hal_device_property_remove (root, "info.claimed.service");
1101                 hal_device_property_remove (root, "info.claimed.uid");
1102         }
1103
1104
1105         children = hal_device_store_match_multiple_key_value_string (store,
1106             "info.parent", root->udi);
1107
1108         for (i = children; i != NULL; i = g_slist_next (i)) {
1109                 d = HAL_DEVICE (i->data);
1110                 hal_util_branch_claim (store, d, claimed, service, uid);
1111         }
1112
1113         g_slist_free (children);
1114 }
1115
1116 /** Given an interface name, check if it is valid.
1117  *  @param  name        A given interface name
1118  *  @return             TRUE if name is valid, otherwise FALSE
1119  */
1120 gboolean
1121 is_valid_interface_name(const char *name) {
1122
1123         const char *end;
1124         const char *last_dot;
1125
1126         last_dot = NULL;
1127
1128         if (strlen(name) == 0)
1129                 return FALSE;
1130
1131         end = name + strlen(name);
1132
1133         if (*name == '.')    /* disallow starting with a . */
1134                 return FALSE;
1135         else if (!VALID_INITIAL_NAME_CHARACTER (*name))
1136                 return FALSE;
1137         else
1138                 name++;
1139
1140         while (name != end) {
1141                 if (*name == '.') {
1142                         if ((name + 1) == end)
1143                                 return FALSE;
1144                         else if (!VALID_INITIAL_NAME_CHARACTER (*(name + 1)))
1145                                 return FALSE;
1146                         last_dot = name;
1147                         name++;    /* we just validated the next char, so skip two */
1148                 } else if (!VALID_NAME_CHARACTER (*name))
1149                         return FALSE;
1150                 name++;
1151         }
1152         if (last_dot == NULL)
1153                 return FALSE;
1154
1155         return TRUE;
1156 }