/* -*- mode: C; c-file-style: "gnu" -*- */

/* dbus-sysdeps-util-unix.c Would be in dbus-sysdeps-unix.c, but not used in libdbus

 * 

 * Copyright (C) 2002, 2003, 2004, 2005  Red Hat, Inc.

 * Copyright (C) 2003 CodeFactory AB

 * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 * Licensed under the Academic Free License version 2.1

 * 

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#include "dbus-sysdeps.h"

#include "dbus-sysdeps-unix.h"

#include "dbus-internals.h"

#include "dbus-protocol.h"

#include "dbus-string.h"

#define DBUS_USERDB_INCLUDES_PRIVATE 1

#include "dbus-userdb.h"

#include "dbus-test.h"

#include <sys/types.h>

#include <stdlib.h>

#include <string.h>

#ifndef __SYMBIAN32__

#include <signal.h>

#endif

#include <unistd.h>

#include <stdio.h>

#include <errno.h>

#include <fcntl.h>

#include <sys/stat.h>

#include <grp.h>

#include <sys/socket.h>

#include <dirent.h>

#ifndef __SYMBIAN32__

#include <sys/un.h>

#endif

#ifdef HAVE_SYS_SYSLIMITS_H

#include <sys/syslimits.h>

#endif

#ifndef O_BINARY

#define O_BINARY 0

#endif

/**

 * @addtogroup DBusInternalsUtils

 * @{

 */

/**

 * Does the chdir, fork, setsid, etc. to become a daemon process.

 *

 * @param pidfile #NULL, or pidfile to create

 * @param print_pid_fd file descriptor to print daemon's pid to, or -1 for none

 * @param error return location for errors

 * @returns #FALSE on failure

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

dbus_bool_t

_dbus_become_daemon (const DBusString *pidfile,

		     int               print_pid_fd,

                     DBusError        *error)

{

  const char *s;

  pid_t child_pid;

  int dev_null_fd;

  _dbus_verbose ("Becoming a daemon...\n");

#ifndef __SYMBIAN32__

  _dbus_verbose ("chdir to /\n");

  if (chdir ("/") < 0)

    {

      dbus_set_error (error, DBUS_ERROR_FAILED,

                      "Could not chdir() to root directory");

      return FALSE;

    }

  _dbus_verbose ("forking...\n");

  switch ((child_pid = fork ()))

    {

    case -1:

      _dbus_verbose ("fork failed\n");

      dbus_set_error (error, _dbus_error_from_errno (errno),

                      "Failed to fork daemon: %s", _dbus_strerror (errno));

      return FALSE;

      break;

    case 0:

      _dbus_verbose ("in child, closing std file descriptors\n");

      /* silently ignore failures here, if someone

       * doesn't have /dev/null we may as well try

       * to continue anyhow

       */

      dev_null_fd = open ("/dev/null", O_RDWR);

      if (dev_null_fd >= 0)

        {

          dup2 (dev_null_fd, 0);

          dup2 (dev_null_fd, 1);

          s = _dbus_getenv ("DBUS_DEBUG_OUTPUT");

          if (s == NULL || *s == '\0')

            dup2 (dev_null_fd, 2);

          else

            _dbus_verbose ("keeping stderr open due to DBUS_DEBUG_OUTPUT\n");

        }

      /* Get a predictable umask */

      _dbus_verbose ("setting umask\n");

      umask (022);

      break;

    default:

      if (pidfile)

        {

          _dbus_verbose ("parent writing pid file\n");

          if (!_dbus_write_pid_file (pidfile,

                                     child_pid,

                                     error))

            {

              _dbus_verbose ("pid file write failed, killing child\n");

#ifndef __SYMBIAN32__              

              kill (child_pid, SIGTERM);

#endif              

              return FALSE;

            }

        }

      /* Write PID if requested */

      if (print_pid_fd >= 0)

	{

	  DBusString pid;

	  int bytes;

	  if (!_dbus_string_init (&pid))

	    {

	      _DBUS_SET_OOM (error);

#ifndef __SYMBIAN32__	      

              kill (child_pid, SIGTERM);

#endif              

	      return FALSE;

	    }

	  if (!_dbus_string_append_int (&pid, child_pid) ||

	      !_dbus_string_append (&pid, "\n"))

	    {

	      _dbus_string_free (&pid);

	      _DBUS_SET_OOM (error);

#ifndef __SYMBIAN32__	      

              kill (child_pid, SIGTERM);

#endif              

	      return FALSE;

	    }

	  bytes = _dbus_string_get_length (&pid);

	  if (_dbus_write_socket (print_pid_fd, &pid, 0, bytes) != bytes)

	    {

	      dbus_set_error (error, DBUS_ERROR_FAILED,

			      "Printing message bus PID: %s\n",

			      _dbus_strerror (errno));

	      _dbus_string_free (&pid);

#ifndef __SYMBIAN32__	      

              kill (child_pid, SIGTERM);

#endif              

	      return FALSE;

	    }

	  _dbus_string_free (&pid);

	}

      _dbus_verbose ("parent exiting\n");

      _exit (0);

      break;

    }

  _dbus_verbose ("calling setsid()\n");

  if (setsid () == -1)

    _dbus_assert_not_reached ("setsid() failed");

  #endif

  return TRUE;

}

/**

 * Creates a file containing the process ID.

 *

 * @param filename the filename to write to

 * @param pid our process ID

 * @param error return location for errors

 * @returns #FALSE on failure

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

dbus_bool_t

_dbus_write_pid_file (const DBusString *filename,

                      unsigned long     pid,

		      DBusError        *error)

{

  const char *cfilename;

  int fd;

  FILE *f;

  cfilename = _dbus_string_get_const_data (filename);

  fd = open (cfilename, O_WRONLY|O_CREAT|O_EXCL|O_BINARY, 0644);

  if (fd < 0)

    {

      dbus_set_error (error, _dbus_error_from_errno (errno),

                      "Failed to open \"%s\": %s", cfilename,

                      _dbus_strerror (errno));

      return FALSE;

    }

  if ((f = fdopen (fd, "w")) == NULL)

    {

      dbus_set_error (error, _dbus_error_from_errno (errno),

                      "Failed to fdopen fd %d: %s", fd, _dbus_strerror (errno));

      _dbus_close (fd, NULL);

      return FALSE;

    }

  if (fprintf (f, "%lu\n", pid) < 0)

    {

      dbus_set_error (error, _dbus_error_from_errno (errno),

                      "Failed to write to \"%s\": %s", cfilename,

                      _dbus_strerror (errno));

      fclose (f);

      return FALSE;

    }

  if (fclose (f) == EOF)

    {

      dbus_set_error (error, _dbus_error_from_errno (errno),

                      "Failed to close \"%s\": %s", cfilename,

                      _dbus_strerror (errno));

      return FALSE;

    }

  return TRUE;

}

/**

 * Changes the user and group the bus is running as.

 *

 * @param uid the new user ID

 * @param gid the new group ID

 * @param error return location for errors

 * @returns #FALSE on failure

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

dbus_bool_t

_dbus_change_identity  (dbus_uid_t     uid,

                        dbus_gid_t     gid,

                        DBusError     *error)

{

  /* setgroups() only works if we are a privileged process,

   * so we don't return error on failure; the only possible

   * failure is that we don't have perms to do it.

   *

   * not sure this is right, maybe if setuid()

   * is going to work then setgroups() should also work.

   */

#ifndef __SYMBIAN32__

  if (setgroups (0, NULL) < 0)

    _dbus_warn ("Failed to drop supplementary groups: %s\n",

                _dbus_strerror (errno));

  /* Set GID first, or the setuid may remove our permission

   * to change the GID

   */

  if (setgid (gid) < 0)

    {

      dbus_set_error (error, _dbus_error_from_errno (errno),

                      "Failed to set GID to %lu: %s", gid,

                      _dbus_strerror (errno));

      return FALSE;

    }

  if (setuid (uid) < 0)

    {

      dbus_set_error (error, _dbus_error_from_errno (errno),

                      "Failed to set UID to %lu: %s", uid,

                      _dbus_strerror (errno));

      return FALSE;

    }

#endif

  return TRUE;

}

/** Installs a UNIX signal handler

 *

 * @param sig the signal to handle

 * @param handler the handler

 */

void

_dbus_set_signal_handler (int               sig,

                          DBusSignalHandler handler)

{

#ifndef __SYMBIAN32__  

  struct sigaction act;

  sigset_t empty_mask;

  sigemptyset (&empty_mask);

  act.sa_handler = handler;

  act.sa_mask    = empty_mask;

  act.sa_flags   = 0;

  sigaction (sig,  &act, NULL);

#endif  

}

/**

 * Removes a directory; Directory must be empty

 * 

 * @param filename directory filename

 * @param error initialized error object

 * @returns #TRUE on success

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

dbus_bool_t

_dbus_delete_directory (const DBusString *filename,

			DBusError        *error)

{

  const char *filename_c;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  filename_c = _dbus_string_get_const_data (filename);

  if (rmdir (filename_c) != 0)

    {

      dbus_set_error (error, DBUS_ERROR_FAILED,

		      "Failed to remove directory %s: %s\n",

		      filename_c, _dbus_strerror (errno));

      return FALSE;

    }

  return TRUE;

}

/** Checks if a file exists

*

* @param file full path to the file

* @returns #TRUE if file exists

*/

#ifdef __SYMBIAN32__

EXPORT_C

#endif

dbus_bool_t 

_dbus_file_exists (const char *file)

{

  return (access (file, F_OK) == 0);

}

/** Checks if user is at the console

*

* @param username user to check

* @param error return location for errors

* @returns #TRUE is the user is at the consolei and there are no errors

*/

dbus_bool_t 

_dbus_user_at_console (const char *username,

                       DBusError  *error)

{

#ifdef __SYMBIAN32__

   return FALSE;

#else

  DBusString f;

  dbus_bool_t result;

  result = FALSE;

  if (!_dbus_string_init (&f))

    {

      _DBUS_SET_OOM (error);

      return FALSE;

    }

  if (!_dbus_string_append (&f, DBUS_CONSOLE_AUTH_DIR))

    {

      _DBUS_SET_OOM (error);

      goto out;

    }

  if (!_dbus_string_append (&f, username))

    {

      _DBUS_SET_OOM (error);

      goto out;

    }

  result = _dbus_file_exists (_dbus_string_get_const_data (&f));

 out:

  _dbus_string_free (&f);

  return result;

#endif  

}

/**

 * Checks whether the filename is an absolute path

 *

 * @param filename the filename

 * @returns #TRUE if an absolute path

 */

 #ifdef __SYMBIAN32__

EXPORT_C

#endif

dbus_bool_t

_dbus_path_is_absolute (const DBusString *filename)

{

  if (_dbus_string_get_length (filename) > 0)

    return _dbus_string_get_byte (filename, 0) == '/';

  else

    return FALSE;

}

/**

 * stat() wrapper.

 *

 * @param filename the filename to stat

 * @param statbuf the stat info to fill in

 * @param error return location for error

 * @returns #FALSE if error was set

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

dbus_bool_t

_dbus_stat (const DBusString *filename,

            DBusStat         *statbuf,

            DBusError        *error)

{

  const char *filename_c;

  struct stat sb;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  filename_c = _dbus_string_get_const_data (filename);

  if (stat (filename_c, &sb) < 0)

    {

      dbus_set_error (error, _dbus_error_from_errno (errno),

                      "%s", _dbus_strerror (errno));

      return FALSE;

    }

  statbuf->mode = sb.st_mode;

  statbuf->nlink = sb.st_nlink;

  statbuf->uid = sb.st_uid;

  statbuf->gid = sb.st_gid;

  statbuf->size = sb.st_size;

  statbuf->atime = sb.st_atime;

  statbuf->mtime = sb.st_mtime;

  statbuf->ctime = sb.st_ctime;

  return TRUE;

}

/**

 * Internals of directory iterator

 */

struct DBusDirIter

{

  DIR *d; /**< The DIR* from opendir() */

};

/**

 * Open a directory to iterate over.

 *

 * @param filename the directory name

 * @param error exception return object or #NULL

 * @returns new iterator, or #NULL on error

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

DBusDirIter*

_dbus_directory_open (const DBusString *filename,

                      DBusError        *error)

{

  DIR *d;

  DBusDirIter *iter;

  const char *filename_c;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  filename_c = _dbus_string_get_const_data (filename);

  d = opendir (filename_c);

  if (d == NULL)

    {

      dbus_set_error (error, _dbus_error_from_errno (errno),

                      "Failed to read directory \"%s\": %s",

                      filename_c,

                      _dbus_strerror (errno));

      return NULL;

    }

  iter = dbus_new0 (DBusDirIter, 1);

  if (iter == NULL)