dbus/dbus-sysdeps-util-unix.c

   1 /* -*- mode: C; c-file-style: "gnu" -*- */
   2 /* dbus-sysdeps-util-unix.c Would be in dbus-sysdeps-unix.c, but not used in libdbus
   3  *
   4  * Copyright (C) 2002, 2003, 2004, 2005  Red Hat, Inc.
   5  * Copyright (C) 2003 CodeFactory AB
   6  *
   7  * Licensed under the Academic Free License version 2.1
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  */
  24 #include "dbus-sysdeps.h"
  25 #include "dbus-sysdeps-unix.h"
  26 #include "dbus-internals.h"
  27 #include "dbus-protocol.h"
  28 #include "dbus-string.h"
  29 #define DBUS_USERDB_INCLUDES_PRIVATE 1
  30 #include "dbus-userdb.h"
  31 #include "dbus-test.h"
  32
  33 #include <sys/types.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <signal.h>
  37 #include <unistd.h>
  38 #include <stdio.h>
  39 #include <errno.h>
  40 #include <fcntl.h>
  41 #include <sys/stat.h>
  42 #include <grp.h>
  43 #include <sys/socket.h>
  44 #include <dirent.h>
  45 #include <sys/un.h>
  46
  47 #ifdef HAVE_SYS_SYSLIMITS_H
  48 #include <sys/syslimits.h>
  49 #endif
  50
  51 #ifndef O_BINARY
  52 #define O_BINARY 0
  53 #endif
  54
  55 /**
  56  * @addtogroup DBusInternalsUtils
  57  * @{
  58  */
  59
  60 /**
  61  * Does the chdir, fork, setsid, etc. to become a daemon process.
  62  *
  63  * @param pidfile #NULL, or pidfile to create
  64  * @param print_pid_fd file descriptor to print daemon's pid to, or -1 for none
  65  * @param error return location for errors
  66  * @returns #FALSE on failure
  67  */
  68 dbus_bool_t
  69 _dbus_become_daemon (const DBusString *pidfile,
  70                      int               print_pid_fd,
  71                      DBusError        *error)
  72 {
  73   const char *s;
  74   pid_t child_pid;
  75   int dev_null_fd;
  76
  77   _dbus_verbose ("Becoming a daemon...\n");
  78
  79   _dbus_verbose ("chdir to /\n");
  80   if (chdir ("/") < 0)
  81     {
  82       dbus_set_error (error, DBUS_ERROR_FAILED,
  83                       "Could not chdir() to root directory");
  84       return FALSE;
  85     }
  86
  87   _dbus_verbose ("forking...\n");
  88   switch ((child_pid = fork ()))
  89     {
  90     case -1:
  91       _dbus_verbose ("fork failed\n");
  92       dbus_set_error (error, _dbus_error_from_errno (errno),
  93                       "Failed to fork daemon: %s", _dbus_strerror (errno));
  94       return FALSE;
  95       break;
  96
  97     case 0:
  98       _dbus_verbose ("in child, closing std file descriptors\n");
  99
 100       /* silently ignore failures here, if someone
 101        * doesn't have /dev/null we may as well try
 102        * to continue anyhow
 103        */
 104
 105       dev_null_fd = open ("/dev/null", O_RDWR);
 106       if (dev_null_fd >= 0)
 107         {
 108           dup2 (dev_null_fd, 0);
 109           dup2 (dev_null_fd, 1);
 110
 111           s = _dbus_getenv ("DBUS_DEBUG_OUTPUT");
 112           if (s == NULL || *s == '\0')
 113             dup2 (dev_null_fd, 2);
 114           else
 115             _dbus_verbose ("keeping stderr open due to DBUS_DEBUG_OUTPUT\n");
 116         }
 117
 118       /* Get a predictable umask */
 119       _dbus_verbose ("setting umask\n");
 120       umask (022);
 121       break;
 122
 123     default:
 124       if (pidfile)
 125         {
 126           _dbus_verbose ("parent writing pid file\n");
 127           if (!_dbus_write_pid_file (pidfile,
 128                                      child_pid,
 129                                      error))
 130             {
 131               _dbus_verbose ("pid file write failed, killing child\n");
 132               kill (child_pid, SIGTERM);
 133               return FALSE;
 134             }
 135         }
 136
 137       /* Write PID if requested */
 138       if (print_pid_fd >= 0)
 139         {
 140           DBusString pid;
 141           int bytes;
 142
 143           if (!_dbus_string_init (&pid))
 144             {
 145               _DBUS_SET_OOM (error);
 146               kill (child_pid, SIGTERM);
 147               return FALSE;
 148             }
 149
 150           if (!_dbus_string_append_int (&pid, child_pid) ||
 151               !_dbus_string_append (&pid, "\n"))
 152             {
 153               _dbus_string_free (&pid);
 154               _DBUS_SET_OOM (error);
 155               kill (child_pid, SIGTERM);
 156               return FALSE;
 157             }
 158
 159           bytes = _dbus_string_get_length (&pid);
 160           if (_dbus_write_socket (print_pid_fd, &pid, 0, bytes) != bytes)
 161             {
 162               dbus_set_error (error, DBUS_ERROR_FAILED,
 163                               "Printing message bus PID: %s\n",
 164                               _dbus_strerror (errno));
 165               _dbus_string_free (&pid);
 166               kill (child_pid, SIGTERM);
 167               return FALSE;
 168             }
 169
 170           _dbus_string_free (&pid);
 171         }
 172       _dbus_verbose ("parent exiting\n");
 173       _exit (0);
 174       break;
 175     }
 176
 177   _dbus_verbose ("calling setsid()\n");
 178   if (setsid () == -1)
 179     _dbus_assert_not_reached ("setsid() failed");
 180
 181   return TRUE;
 182 }
 183
 184
 185 /**
 186  * Creates a file containing the process ID.
 187  *
 188  * @param filename the filename to write to
 189  * @param pid our process ID
 190  * @param error return location for errors
 191  * @returns #FALSE on failure
 192  */
 193 dbus_bool_t
 194 _dbus_write_pid_file (const DBusString *filename,
 195                       unsigned long     pid,
 196                       DBusError        *error)
 197 {
 198   const char *cfilename;
 199   int fd;
 200   FILE *f;
 201
 202   cfilename = _dbus_string_get_const_data (filename);
 203
 204   fd = open (cfilename, O_WRONLY|O_CREAT|O_EXCL|O_BINARY, 0644);
 205
 206   if (fd < 0)
 207     {
 208       dbus_set_error (error, _dbus_error_from_errno (errno),
 209                       "Failed to open \"%s\": %s", cfilename,
 210                       _dbus_strerror (errno));
 211       return FALSE;
 212     }
 213
 214   if ((f = fdopen (fd, "w")) == NULL)
 215     {
 216       dbus_set_error (error, _dbus_error_from_errno (errno),
 217                       "Failed to fdopen fd %d: %s", fd, _dbus_strerror (errno));
 218       _dbus_close (fd, NULL);
 219       return FALSE;
 220     }
 221
 222   if (fprintf (f, "%lu\n", pid) < 0)
 223     {
 224       dbus_set_error (error, _dbus_error_from_errno (errno),
 225                       "Failed to write to \"%s\": %s", cfilename,
 226                       _dbus_strerror (errno));
 227
 228       fclose (f);
 229       return FALSE;
 230     }
 231
 232   if (fclose (f) == EOF)
 233     {
 234       dbus_set_error (error, _dbus_error_from_errno (errno),
 235                       "Failed to close \"%s\": %s", cfilename,
 236                       _dbus_strerror (errno));
 237       return FALSE;
 238     }
 239
 240   return TRUE;
 241 }
 242
 243
 244 /**
 245  * Changes the user and group the bus is running as.
 246  *
 247  * @param uid the new user ID
 248  * @param gid the new group ID
 249  * @param error return location for errors
 250  * @returns #FALSE on failure
 251  */
 252 dbus_bool_t
 253 _dbus_change_identity  (dbus_uid_t     uid,
 254                         dbus_gid_t     gid,
 255                         DBusError     *error)
 256 {
 257   /* setgroups() only works if we are a privileged process,
 258    * so we don't return error on failure; the only possible
 259    * failure is that we don't have perms to do it.
 260    *
 261    * not sure this is right, maybe if setuid()
 262    * is going to work then setgroups() should also work.
 263    */
 264   if (setgroups (0, NULL) < 0)
 265     _dbus_warn ("Failed to drop supplementary groups: %s\n",
 266                 _dbus_strerror (errno));
 267
 268   /* Set GID first, or the setuid may remove our permission
 269    * to change the GID
 270    */
 271   if (setgid (gid) < 0)
 272     {
 273       dbus_set_error (error, _dbus_error_from_errno (errno),
 274                       "Failed to set GID to %lu: %s", gid,
 275                       _dbus_strerror (errno));
 276       return FALSE;
 277     }
 278
 279   if (setuid (uid) < 0)
 280     {
 281       dbus_set_error (error, _dbus_error_from_errno (errno),
 282                       "Failed to set UID to %lu: %s", uid,
 283                       _dbus_strerror (errno));
 284       return FALSE;
 285     }
 286
 287   return TRUE;
 288 }
 289
 290 /** Installs a UNIX signal handler
 291  *
 292  * @param sig the signal to handle
 293  * @param handler the handler
 294  */
 295 void
 296 _dbus_set_signal_handler (int               sig,
 297                           DBusSignalHandler handler)
 298 {
 299   struct sigaction act;
 300   sigset_t empty_mask;
 301
 302   sigemptyset (&empty_mask);
 303   act.sa_handler = handler;
 304   act.sa_mask    = empty_mask;
 305   act.sa_flags   = 0;
 306   sigaction (sig,  &act, NULL);
 307 }
 308
 309
 310 /**
 311  * Removes a directory; Directory must be empty
 312  *
 313  * @param filename directory filename
 314  * @param error initialized error object
 315  * @returns #TRUE on success
 316  */
 317 dbus_bool_t
 318 _dbus_delete_directory (const DBusString *filename,
 319                         DBusError        *error)
 320 {
 321   const char *filename_c;
 322
 323   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 324
 325   filename_c = _dbus_string_get_const_data (filename);
 326
 327   if (rmdir (filename_c) != 0)
 328     {
 329       dbus_set_error (error, DBUS_ERROR_FAILED,
 330                       "Failed to remove directory %s: %s\n",
 331                       filename_c, _dbus_strerror (errno));
 332       return FALSE;
 333     }
 334
 335   return TRUE;
 336 }
 337
 338 /** Checks if a file exists
 339 *
 340 * @param file full path to the file
 341 * @returns #TRUE if file exists
 342 */
 343 dbus_bool_t
 344 _dbus_file_exists (const char *file)
 345 {
 346   return (access (file, F_OK) == 0);
 347 }
 348
 349 /** Checks if user is at the console
 350 *
 351 * @param username user to check
 352 * @param error return location for errors
 353 * @returns #TRUE is the user is at the consolei and there are no errors
 354 */
 355 dbus_bool_t
 356 _dbus_user_at_console (const char *username,
 357                        DBusError  *error)
 358 {
 359
 360   DBusString f;
 361   dbus_bool_t result;
 362
 363   result = FALSE;
 364   if (!_dbus_string_init (&f))
 365     {
 366       _DBUS_SET_OOM (error);
 367       return FALSE;
 368     }
 369
 370   if (!_dbus_string_append (&f, DBUS_CONSOLE_AUTH_DIR))
 371     {
 372       _DBUS_SET_OOM (error);
 373       goto out;
 374     }
 375
 376
 377   if (!_dbus_string_append (&f, username))
 378     {
 379       _DBUS_SET_OOM (error);
 380       goto out;
 381     }
 382
 383   result = _dbus_file_exists (_dbus_string_get_const_data (&f));
 384
 385  out:
 386   _dbus_string_free (&f);
 387
 388   return result;
 389 }
 390
 391
 392 /**
 393  * Checks whether the filename is an absolute path
 394  *
 395  * @param filename the filename
 396  * @returns #TRUE if an absolute path
 397  */
 398 dbus_bool_t
 399 _dbus_path_is_absolute (const DBusString *filename)
 400 {
 401   if (_dbus_string_get_length (filename) > 0)
 402     return _dbus_string_get_byte (filename, 0) == '/';
 403   else
 404     return FALSE;
 405 }
 406
 407 /**
 408  * stat() wrapper.
 409  *
 410  * @param filename the filename to stat
 411  * @param statbuf the stat info to fill in
 412  * @param error return location for error
 413  * @returns #FALSE if error was set
 414  */
 415 dbus_bool_t
 416 _dbus_stat (const DBusString *filename,
 417             DBusStat         *statbuf,
 418             DBusError        *error)
 419 {
 420   const char *filename_c;
 421   struct stat sb;
 422
 423   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 424
 425   filename_c = _dbus_string_get_const_data (filename);
 426
 427   if (stat (filename_c, &sb) < 0)
 428     {
 429       dbus_set_error (error, _dbus_error_from_errno (errno),
 430                       "%s", _dbus_strerror (errno));
 431       return FALSE;
 432     }
 433
 434   statbuf->mode = sb.st_mode;
 435   statbuf->nlink = sb.st_nlink;
 436   statbuf->uid = sb.st_uid;
 437   statbuf->gid = sb.st_gid;
 438   statbuf->size = sb.st_size;
 439   statbuf->atime = sb.st_atime;
 440   statbuf->mtime = sb.st_mtime;
 441   statbuf->ctime = sb.st_ctime;
 442
 443   return TRUE;
 444 }
 445
 446
 447 /**
 448  * Internals of directory iterator
 449  */
 450 struct DBusDirIter
 451 {
 452   DIR *d; /**< The DIR* from opendir() */
 453
 454 };
 455
 456 /**
 457  * Open a directory to iterate over.
 458  *
 459  * @param filename the directory name
 460  * @param error exception return object or #NULL
 461  * @returns new iterator, or #NULL on error
 462  */
 463 DBusDirIter*
 464 _dbus_directory_open (const DBusString *filename,
 465                       DBusError        *error)
 466 {
 467   DIR *d;
 468   DBusDirIter *iter;
 469   const char *filename_c;
 470
 471   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 472
 473   filename_c = _dbus_string_get_const_data (filename);
 474
 475   d = opendir (filename_c);
 476   if (d == NULL)
 477     {
 478       dbus_set_error (error, _dbus_error_from_errno (errno),
 479                       "Failed to read directory \"%s\": %s",
 480                       filename_c,
 481                       _dbus_strerror (errno));
 482       return NULL;
 483     }
 484   iter = dbus_new0 (DBusDirIter, 1);
 485   if (iter == NULL)
 486     {
 487       closedir (d);
 488       dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
 489                       "Could not allocate memory for directory iterator");
 490       return NULL;
 491     }
 492
 493   iter->d = d;
 494
 495   return iter;
 496 }
 497
 498 /* Calculate the required buffer size (in bytes) for directory
 499  * entries read from the given directory handle.  Return -1 if this
 500  * this cannot be done.
 501  *
 502  * If you use autoconf, include fpathconf and dirfd in your
 503  * AC_CHECK_FUNCS list.  Otherwise use some other method to detect
 504  * and use them where available.
 505  */
 506 static dbus_bool_t
 507 dirent_buf_size(DIR * dirp, size_t *size)
 508 {
 509  long name_max;
 510 #   if defined(HAVE_FPATHCONF) && defined(_PC_NAME_MAX)
 511 #      if defined(HAVE_DIRFD)
 512           name_max = fpathconf(dirfd(dirp), _PC_NAME_MAX);
 513 #      else
 514           name_max = fpathconf(dirp->dd_fd, _PC_NAME_MAX);
 515 #      endif /* HAVE_DIRFD */
 516      if (name_max == -1)
 517 #           if defined(NAME_MAX)
 518              name_max = NAME_MAX;
 519 #           else
 520              return FALSE;
 521 #           endif
 522 #   elif defined(MAXNAMELEN)
 523      name_max = MAXNAMELEN;
 524 #   else
 525 #       if defined(NAME_MAX)
 526          name_max = NAME_MAX;
 527 #       else
 528 #           error "buffer size for readdir_r cannot be determined"
 529 #       endif
 530 #   endif
 531   if (size)
 532     *size = (size_t)offsetof(struct dirent, d_name) + name_max + 1;
 533   else
 534     return FALSE;
 535
 536   return TRUE;
 537 }
 538
 539 /**
 540  * Get next file in the directory. Will not return "." or ".."  on
 541  * UNIX. If an error occurs, the contents of "filename" are
 542  * undefined. The error is never set if the function succeeds.
 543  *
 544  * @param iter the iterator
 545  * @param filename string to be set to the next file in the dir
 546  * @param error return location for error
 547  * @returns #TRUE if filename was filled in with a new filename
 548  */
 549 dbus_bool_t
 550 _dbus_directory_get_next_file (DBusDirIter      *iter,
 551                                DBusString       *filename,
 552                                DBusError        *error)
 553 {
 554   struct dirent *d, *ent;
 555   size_t buf_size;
 556   int err;
 557
 558   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 559
 560   if (!dirent_buf_size (iter->d, &buf_size))
 561     {
 562       dbus_set_error (error, DBUS_ERROR_FAILED,
 563                       "Can't calculate buffer size when reading directory");
 564       return FALSE;
 565     }
 566
 567   d = (struct dirent *)dbus_malloc (buf_size);
 568   if (!d)
 569     {
 570       dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
 571                       "No memory to read directory entry");
 572       return FALSE;
 573     }
 574
 575  again:
 576   err = readdir_r (iter->d, d, &ent);
 577   if (err || !ent)
 578     {
 579       if (err != 0)
 580         dbus_set_error (error,
 581                         _dbus_error_from_errno (err),
 582                         "%s", _dbus_strerror (err));
 583
 584       dbus_free (d);
 585       return FALSE;
 586     }
 587   else if (ent->d_name[0] == '.' &&
 588            (ent->d_name[1] == '\0' ||
 589             (ent->d_name[1] == '.' && ent->d_name[2] == '\0')))
 590     goto again;
 591   else
 592     {
 593       _dbus_string_set_length (filename, 0);
 594       if (!_dbus_string_append (filename, ent->d_name))
 595         {
 596           dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
 597                           "No memory to read directory entry");
 598           dbus_free (d);
 599           return FALSE;
 600         }
 601       else
 602         {
 603           dbus_free (d);
 604           return TRUE;
 605         }
 606     }
 607 }
 608
 609 /**
 610  * Closes a directory iteration.
 611  */
 612 void
 613 _dbus_directory_close (DBusDirIter *iter)
 614 {
 615   closedir (iter->d);
 616   dbus_free (iter);
 617 }
 618
 619 static dbus_bool_t
 620 fill_user_info_from_group (struct group  *g,
 621                            DBusGroupInfo *info,
 622                            DBusError     *error)
 623 {
 624   _dbus_assert (g->gr_name != NULL);
 625
 626   info->gid = g->gr_gid;
 627   info->groupname = _dbus_strdup (g->gr_name);
 628
 629   /* info->members = dbus_strdupv (g->gr_mem) */
 630
 631   if (info->groupname == NULL)
 632     {
 633       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
 634       return FALSE;
 635     }
 636
 637   return TRUE;
 638 }
 639
 640 static dbus_bool_t
 641 fill_group_info (DBusGroupInfo    *info,
 642                  dbus_gid_t        gid,
 643                  const DBusString *groupname,
 644                  DBusError        *error)
 645 {
 646   const char *group_c_str;
 647
 648   _dbus_assert (groupname != NULL || gid != DBUS_GID_UNSET);
 649   _dbus_assert (groupname == NULL || gid == DBUS_GID_UNSET);
 650
 651   if (groupname)
 652     group_c_str = _dbus_string_get_const_data (groupname);
 653   else
 654     group_c_str = NULL;
 655
 656   /* For now assuming that the getgrnam() and getgrgid() flavors
 657    * always correspond to the pwnam flavors, if not we have
 658    * to add more configure checks.
 659    */
 660
 661 #if defined (HAVE_POSIX_GETPWNAM_R) || defined (HAVE_NONPOSIX_GETPWNAM_R)
 662   {
 663     struct group *g;
 664     int result;
 665     char buf[1024];
 666     struct group g_str;
 667
 668     g = NULL;
 669 #ifdef HAVE_POSIX_GETPWNAM_R
 670
 671     if (group_c_str)
 672       result = getgrnam_r (group_c_str, &g_str, buf, sizeof (buf),
 673                            &g);
 674     else
 675       result = getgrgid_r (gid, &g_str, buf, sizeof (buf),
 676                            &g);
 677 #else
 678     g = getgrnam_r (group_c_str, &g_str, buf, sizeof (buf));
 679     result = 0;
 680 #endif /* !HAVE_POSIX_GETPWNAM_R */
 681     if (result == 0 && g == &g_str)
 682       {
 683         return fill_user_info_from_group (g, info, error);
 684       }
 685     else
 686       {
 687         dbus_set_error (error, _dbus_error_from_errno (errno),
 688                         "Group %s unknown or failed to look it up\n",
 689                         group_c_str ? group_c_str : "???");
 690         return FALSE;
 691       }
 692   }
 693 #else /* ! HAVE_GETPWNAM_R */
 694   {
 695     /* I guess we're screwed on thread safety here */
 696     struct group *g;
 697
 698     g = getgrnam (group_c_str);
 699
 700     if (g != NULL)
 701       {
 702         return fill_user_info_from_group (g, info, error);
 703       }
 704     else
 705       {
 706         dbus_set_error (error, _dbus_error_from_errno (errno),
 707                         "Group %s unknown or failed to look it up\n",
 708                         group_c_str ? group_c_str : "???");
 709         return FALSE;
 710       }
 711   }
 712 #endif  /* ! HAVE_GETPWNAM_R */
 713 }
 714
 715 /**
 716  * Initializes the given DBusGroupInfo struct
 717  * with information about the given group name.
 718  *
 719  * @param info the group info struct
 720  * @param groupname name of group
 721  * @param error the error return
 722  * @returns #FALSE if error is set
 723  */
 724 dbus_bool_t
 725 _dbus_group_info_fill (DBusGroupInfo    *info,
 726                        const DBusString *groupname,
 727                        DBusError        *error)
 728 {
 729   return fill_group_info (info, DBUS_GID_UNSET,
 730                           groupname, error);
 731
 732 }
 733
 734 /**
 735  * Initializes the given DBusGroupInfo struct
 736  * with information about the given group ID.
 737  *
 738  * @param info the group info struct
 739  * @param gid group ID
 740  * @param error the error return
 741  * @returns #FALSE if error is set
 742  */
 743 dbus_bool_t
 744 _dbus_group_info_fill_gid (DBusGroupInfo *info,
 745                            dbus_gid_t     gid,
 746                            DBusError     *error)
 747 {
 748   return fill_group_info (info, gid, NULL, error);
 749 }
 750
 751 /** @} */ /* End of DBusInternalsUtils functions */
 752
 753 /**
 754  * @addtogroup DBusString
 755  *
 756  * @{
 757  */
 758 /**
 759  * Get the directory name from a complete filename
 760  * @param filename the filename
 761  * @param dirname string to append directory name to
 762  * @returns #FALSE if no memory
 763  */
 764 dbus_bool_t
 765 _dbus_string_get_dirname  (const DBusString *filename,
 766                            DBusString       *dirname)
 767 {
 768   int sep;
 769
 770   _dbus_assert (filename != dirname);
 771   _dbus_assert (filename != NULL);
 772   _dbus_assert (dirname != NULL);
 773
 774   /* Ignore any separators on the end */
 775   sep = _dbus_string_get_length (filename);
 776   if (sep == 0)
 777     return _dbus_string_append (dirname, "."); /* empty string passed in */
 778
 779   while (sep > 0 && _dbus_string_get_byte (filename, sep - 1) == '/')
 780     --sep;
 781
 782   _dbus_assert (sep >= 0);
 783
 784   if (sep == 0)
 785     return _dbus_string_append (dirname, "/");
 786
 787   /* Now find the previous separator */
 788   _dbus_string_find_byte_backward (filename, sep, '/', &sep);
 789   if (sep < 0)
 790     return _dbus_string_append (dirname, ".");
 791
 792   /* skip multiple separators */
 793   while (sep > 0 && _dbus_string_get_byte (filename, sep - 1) == '/')
 794     --sep;
 795
 796   _dbus_assert (sep >= 0);
 797
 798   if (sep == 0 &&
 799       _dbus_string_get_byte (filename, 0) == '/')
 800     return _dbus_string_append (dirname, "/");
 801   else
 802     return _dbus_string_copy_len (filename, 0, sep - 0,
 803                                   dirname, _dbus_string_get_length (dirname));
 804 }
 805 /** @} */ /* DBusString stuff */
 806