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

/* dbus-sysdeps-unix.c Wrappers around UNIX system/libc features (internal to D-Bus implementation)

 * 

 * Copyright (C) 2002, 2003, 2006  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 <stdio.h> 

#include "dbus-internals.h"

#include "dbus-sysdeps.h"

#include "dbus-sysdeps-unix.h"

#include "dbus-threads.h"

#include "dbus-protocol.h"

#include "dbus-transport.h"

#include "dbus-string.h"

#include "dbus-userdb.h"

#include "dbus-list.h"

#include <sys/types.h>

#include <stdlib.h>

#include <string.h>

#ifndef __SYMBIAN32__

#include <signal.h>

#endif

#include <unistd.h>

#include <fcntl.h>

#include <sys/socket.h>

#include <dirent.h>

#ifndef __SYMBIAN32__

#include <sys/un.h>

#endif

#include <pwd.h>

#include <time.h>

#include <locale.h>

#include <sys/time.h>

#include <sys/stat.h>

#include <sys/wait.h>

#include <netinet/in.h>

#include <netdb.h>

#include <grp.h>

#ifdef __SYMBIAN32__

#include "config.h"

#include "dbus-sysdeps-unix-helper.h"

#endif //__SYMBIAN32__

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#ifdef HAVE_WRITEV

#include <sys/uio.h>

#endif

#ifdef HAVE_POLL

#include <sys/poll.h>

#endif

#ifdef HAVE_BACKTRACE

#include <execinfo.h>

#endif

#ifdef HAVE_GETPEERUCRED

#include <ucred.h>

#endif

#ifdef __SYMBIAN32__

#include <sys/select.h>

#include "libdbus_wsd_solution.h"

#endif

#ifndef O_BINARY

#define O_BINARY 0

#endif

#ifndef HAVE_SOCKLEN_T

#define socklen_t int

#endif

static dbus_bool_t

_dbus_open_socket (int              *fd,

                   int               domain,

                   int               type,

                   int               protocol,

                   DBusError        *error)

{

  *fd = socket (domain, type, protocol);

  if (*fd >= 0)

    {

      return TRUE;

    }

  else

    {

      dbus_set_error(error,

                     _dbus_error_from_errno (errno),

                     "Failed to open socket: %s",

                     _dbus_strerror (errno));

      return FALSE;

    }

}

dbus_bool_t

_dbus_open_tcp_socket (int              *fd,

                       DBusError        *error)

{

  return _dbus_open_socket(fd, AF_INET, SOCK_STREAM, 0, error);

}

/**

 * Opens a UNIX domain socket (as in the socket() call).

 * Does not bind the socket.

 * @param fd return location for socket descriptor

 * @param error return location for an error

 * @returns #FALSE if error is set

 */

dbus_bool_t

_dbus_open_unix_socket (int              *fd,

                        DBusError        *error)

{

  return _dbus_open_socket(fd, PF_UNIX, SOCK_STREAM, 0, error);

}

/**

 * Closes a socket. Should not be used on non-socket

 * file descriptors or handles.

 *

 * @param fd the socket

 * @param error return location for an error

 * @returns #FALSE if error is set

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

dbus_bool_t 

_dbus_close_socket (int               fd,

                    DBusError        *error)

{

  return _dbus_close (fd, error);

}

/**

 * Like _dbus_read(), but only works on sockets so is

 * available on Windows.

 *

 * @param fd the socket

 * @param buffer string to append data to

 * @param count max amount of data to read

 * @returns number of bytes appended to the string

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

int

_dbus_read_socket (int               fd,

                   DBusString       *buffer,

                   int               count)

{

  return _dbus_read (fd, buffer, count);

}

/**

 * Like _dbus_write(), but only supports sockets

 * and is thus available on Windows.

 *

 * @param fd the file descriptor to write

 * @param buffer the buffer to write data from

 * @param start the first byte in the buffer to write

 * @param len the number of bytes to try to write

 * @returns the number of bytes written or -1 on error

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

int

_dbus_write_socket (int               fd,

                    const DBusString *buffer,

                    int               start,

                    int               len)

{

  return _dbus_write (fd, buffer, start, len);

}

/**

 * Like _dbus_write_two() but only works on sockets and is thus

 * available on Windows.

 * 

 * @param fd the file descriptor

 * @param buffer1 first buffer

 * @param start1 first byte to write in first buffer

 * @param len1 number of bytes to write from first buffer

 * @param buffer2 second buffer, or #NULL

 * @param start2 first byte to write in second buffer

 * @param len2 number of bytes to write in second buffer

 * @returns total bytes written from both buffers, or -1 on error

 */

int

_dbus_write_socket_two (int               fd,

                        const DBusString *buffer1,

                        int               start1,

                        int               len1,

                        const DBusString *buffer2,

                        int               start2,

                        int               len2)

{

  return _dbus_write_two (fd, buffer1, start1, len1,

                          buffer2, start2, len2);

}

/**

 * Thin wrapper around the read() system call that appends

 * the data it reads to the DBusString buffer. It appends

 * up to the given count, and returns the same value

 * and same errno as read(). The only exception is that

 * _dbus_read() handles EINTR for you. Also, _dbus_read() can

 * return ENOMEM, even though regular UNIX read doesn't.

 *

 * Unlike _dbus_read_socket(), _dbus_read() is not available

 * on Windows.

 * 

 * @param fd the file descriptor to read from

 * @param buffer the buffer to append data to

 * @param count the amount of data to read

 * @returns the number of bytes read or -1

 */

int

_dbus_read (int               fd,

            DBusString       *buffer,

            int               count)

{

  int bytes_read;

  int start;

  char *data;

  _dbus_assert (count >= 0);

  start = _dbus_string_get_length (buffer);

  if (!_dbus_string_lengthen (buffer, count))

    {

      errno = ENOMEM;

      return -1;

    }

  data = _dbus_string_get_data_len (buffer, start, count);

 again:

  bytes_read = read (fd, data, count);

  if (bytes_read < 0)

    {

      if (errno == EINTR)

        goto again;

      else

        {

          /* put length back (note that this doesn't actually realloc anything) */

          _dbus_string_set_length (buffer, start);

          return -1;

        }

    }

  else

    {

      /* put length back (doesn't actually realloc) */

      _dbus_string_set_length (buffer, start + bytes_read);

#if 0

      if (bytes_read > 0)

        _dbus_verbose_bytes_of_string (buffer, start, bytes_read);

#endif

      return bytes_read;

    }

}

/**

 * Thin wrapper around the write() system call that writes a part of a

 * DBusString and handles EINTR for you.

 * 

 * @param fd the file descriptor to write

 * @param buffer the buffer to write data from

 * @param start the first byte in the buffer to write

 * @param len the number of bytes to try to write

 * @returns the number of bytes written or -1 on error

 */

int

_dbus_write (int               fd,

             const DBusString *buffer,

             int               start,

             int               len)

{

  const char *data;

  int bytes_written;

  data = _dbus_string_get_const_data_len (buffer, start, len);

 again:

  bytes_written = write (fd, data, len);

  if (bytes_written < 0 && errno == EINTR)

    goto again;

#if 0

  if (bytes_written > 0)

    _dbus_verbose_bytes_of_string (buffer, start, bytes_written);

#endif

  return bytes_written;

}

/**

 * Like _dbus_write() but will use writev() if possible

 * to write both buffers in sequence. The return value

 * is the number of bytes written in the first buffer,

 * plus the number written in the second. If the first

 * buffer is written successfully and an error occurs

 * writing the second, the number of bytes in the first

 * is returned (i.e. the error is ignored), on systems that

 * don't have writev. Handles EINTR for you.

 * The second buffer may be #NULL.

 *

 * @param fd the file descriptor

 * @param buffer1 first buffer

 * @param start1 first byte to write in first buffer

 * @param len1 number of bytes to write from first buffer

 * @param buffer2 second buffer, or #NULL

 * @param start2 first byte to write in second buffer

 * @param len2 number of bytes to write in second buffer

 * @returns total bytes written from both buffers, or -1 on error

 */

int

_dbus_write_two (int               fd,

                 const DBusString *buffer1,

                 int               start1,

                 int               len1,

                 const DBusString *buffer2,

                 int               start2,

                 int               len2)

{

  _dbus_assert (buffer1 != NULL);

  _dbus_assert (start1 >= 0);

  _dbus_assert (start2 >= 0);

  _dbus_assert (len1 >= 0);

  _dbus_assert (len2 >= 0);

#ifndef HAVE_WRITEV

  {

    struct iovec vectors[2];

    const char *data1;

    const char *data2;

    int bytes_written;

    data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);

    if (buffer2 != NULL)

      data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);

    else

      {

        data2 = NULL;

        start2 = 0;

        len2 = 0;

      }

    vectors[0].iov_base = (char*) data1;

    vectors[0].iov_len = len1;

    vectors[1].iov_base = (char*) data2;

    vectors[1].iov_len = len2;

  again:

    bytes_written = writev (fd,

                            vectors,

                            data2 ? 2 : 1);

    if (bytes_written < 0 && errno == EINTR)

      goto again;

    return bytes_written;

  }

#else /* HAVE_WRITEV */

  {

    int ret1;

 // NOTE

 // Corrected here, bacause this is real error

 #ifdef __SYMBIAN32__

    int ret2;

 #else

  // NOTE

 // Folowing line addded and corrected here, bacause this is real error

    int ret2;

 #endif   

    ret1 = _dbus_write (fd, buffer1, start1, len1);

    if (ret1 == len1 && buffer2 != NULL)

      {

        ret2 = _dbus_write (fd, buffer2, start2, len2);

        if (ret2 < 0)

          ret2 = 0; /* we can't report an error as the first write was OK */

        return ret1 + ret2;

      }

    else

      return ret1;

  }

#endif /* !HAVE_WRITEV */   

}

#define _DBUS_MAX_SUN_PATH_LENGTH 99

/**

 * @def _DBUS_MAX_SUN_PATH_LENGTH

 *

 * Maximum length of the path to a UNIX domain socket,

 * sockaddr_un::sun_path member. POSIX requires that all systems

 * support at least 100 bytes here, including the nul termination.

 * We use 99 for the max value to allow for the nul.

 *

 * We could probably also do sizeof (addr.sun_path)

 * but this way we are the same on all platforms

 * which is probably a good idea.

 */

/**

 * Creates a socket and connects it to the UNIX domain socket at the

 * given path.  The connection fd is returned, and is set up as

 * nonblocking.

 * 

 * Uses abstract sockets instead of filesystem-linked sockets if

 * requested (it's possible only on Linux; see "man 7 unix" on Linux).

 * On non-Linux abstract socket usage always fails.

 *

 * @param path the path to UNIX domain socket

 * @param abstract #TRUE to use abstract namespace

 * @param error return location for error code

 * @returns connection file descriptor or -1 on error

 */

int

_dbus_connect_unix_socket (const char     *path,

                           dbus_bool_t     abstract,

                           DBusError      *error)

{

#ifdef __SYMBIAN32__

  return -1;

#else

  int fd;

  size_t path_len;

  struct sockaddr_un addr;  

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  _dbus_verbose ("connecting to unix socket %s abstract=%d\n",

                 path, abstract);

  if (!_dbus_open_unix_socket (&fd, error))

    {

      _DBUS_ASSERT_ERROR_IS_SET(error);

      return -1;

    }

  _DBUS_ASSERT_ERROR_IS_CLEAR(error);

  _DBUS_ZERO (addr);

  addr.sun_family = AF_UNIX;

  path_len = strlen (path);

  if (abstract)

    {

#ifdef HAVE_ABSTRACT_SOCKETS

      addr.sun_path[0] = '\0'; /* this is what says "use abstract" */

      path_len++; /* Account for the extra nul byte added to the start of sun_path */

      if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)

        {

          dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,

                      "Abstract socket name too long\n");

          _dbus_close (fd, NULL);

          return -1;

	}

      strncpy (&addr.sun_path[1], path, path_len);

      /* _dbus_verbose_bytes (addr.sun_path, sizeof (addr.sun_path)); */

#else /* HAVE_ABSTRACT_SOCKETS */

      dbus_set_error (error, DBUS_ERROR_NOT_SUPPORTED,

                      "Operating system does not support abstract socket namespace\n");

      _dbus_close (fd, NULL);

      return -1;

#endif /* ! HAVE_ABSTRACT_SOCKETS */

    }

  else

    {

      if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)

        {

          dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,

                      "Socket name too long\n");

          _dbus_close (fd, NULL);

          return -1;

	}

      strncpy (addr.sun_path, path, path_len);

    }

  if (connect (fd, (struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (struct sockaddr_un, sun_path) + path_len) < 0)

    {      

      dbus_set_error (error,

                      _dbus_error_from_errno (errno),

                      "Failed to connect to socket %s: %s",

                      path, _dbus_strerror (errno));

      _dbus_close (fd, NULL);

      fd = -1;

      return -1;

    }

  if (!_dbus_set_fd_nonblocking (fd, error))