dbus/dbus-sysdeps-win.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2 /* dbus-sysdeps.c Wrappers around system/libc features (internal to D-BUS implementation)
   3  *
   4  * Copyright (C) 2002, 2003  Red Hat, Inc.
   5  * Copyright (C) 2003 CodeFactory AB
   6  * Copyright (C) 2005 Novell, Inc.
   7  * Copyright (C) 2006 Ralf Habacker <ralf.habacker@freenet.de>
   8  * Copyright (C) 2006 Peter Kümmel  <syntheticpp@gmx.net>
   9  * Copyright (C) 2006 Christian Ehrlicher <ch.ehrlicher@gmx.de>
  10  *
  11  * Licensed under the Academic Free License version 2.1
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  26  *
  27  */
  28
  29 #undef open
  30
  31 #define STRSAFE_NO_DEPRECATE
  32
  33 #ifndef DBUS_WINCE
  34 #ifndef _WIN32_WINNT
  35 #define _WIN32_WINNT 0x0501
  36 #endif
  37 #endif
  38
  39 #include "dbus-internals.h"
  40 #include "dbus-sysdeps.h"
  41 #include "dbus-threads.h"
  42 #include "dbus-protocol.h"
  43 #include "dbus-string.h"
  44 #include "dbus-sysdeps-win.h"
  45 #include "dbus-protocol.h"
  46 #include "dbus-hash.h"
  47 #include "dbus-sockets-win.h"
  48 #include "dbus-list.h"
  49 #include "dbus-credentials.h"
  50
  51 #include <windows.h>
  52 #include <ws2tcpip.h>
  53 #include <fcntl.h>
  54
  55 #include <process.h>
  56 #include <stdio.h>
  57 #include <sys/stat.h>
  58 #include <sys/types.h>
  59
  60 #ifdef HAVE_WSPIAPI_H
  61 // needed for w2k compatibility (getaddrinfo/freeaddrinfo/getnameinfo)
  62 #ifdef __GNUC__
  63 #define _inline
  64 #include "wspiapi.h"
  65 #else
  66 #include <wspiapi.h>
  67 #endif
  68 #endif // HAVE_WSPIAPI_H
  69
  70 #ifndef O_BINARY
  71 #define O_BINARY 0
  72 #endif
  73
  74 #ifndef HAVE_SOCKLEN_T
  75 #define socklen_t int
  76 #endif
  77
  78 /**
  79  * File interface
  80  *
  81  */
  82 dbus_bool_t
  83 _dbus_file_open (DBusFile   *file,
  84                  const char *filename,
  85                  int         oflag,
  86                  int         pmode)
  87 {
  88   if (pmode!=-1)
  89     file->FDATA = _open (filename, oflag, pmode);
  90   else
  91     file->FDATA = _open (filename, oflag);
  92   if (file->FDATA >= 0)
  93     return TRUE;
  94   else
  95     {
  96       file->FDATA = -1;
  97       return FALSE;
  98     }
  99 }
 100
 101 dbus_bool_t
 102 _dbus_file_close (DBusFile  *file,
 103                   DBusError *error)
 104 {
 105   const int fd = file->FDATA;
 106
 107   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 108
 109   _dbus_assert (fd >= 0);
 110
 111   if (_close (fd) == -1)
 112     {
 113       dbus_set_error (error, _dbus_error_from_errno (errno),
 114                       "Could not close fd %d: %s", fd,
 115                       _dbus_strerror (errno));
 116       return FALSE;
 117     }
 118
 119   file->FDATA = -1;
 120   _dbus_verbose ("closed C file descriptor %d:\n",fd);
 121
 122   return TRUE;
 123 }
 124
 125 int
 126 _dbus_file_read(DBusFile   *file,
 127                 DBusString *buffer,
 128                 int         count)
 129 {
 130   const int fd = file->FDATA;
 131   int bytes_read;
 132   int start;
 133   char *data;
 134   _dbus_assert (count >= 0);
 135
 136   start = _dbus_string_get_length (buffer);
 137
 138   if (!_dbus_string_lengthen (buffer, count))
 139     {
 140       errno = ENOMEM;
 141       return -1;
 142     }
 143
 144   data = _dbus_string_get_data_len (buffer, start, count);
 145
 146   _dbus_assert (fd >= 0);
 147
 148   _dbus_verbose ("read: count=%d fd=%d\n", count, fd);
 149   bytes_read = read (fd, data, count);
 150
 151   if (bytes_read == -1)
 152     _dbus_verbose ("read: failed: %s\n", _dbus_strerror (errno));
 153   else
 154     _dbus_verbose ("read: = %d\n", bytes_read);
 155
 156   if (bytes_read < 0)
 157     {
 158       /* put length back (note that this doesn't actually realloc anything) */
 159       _dbus_string_set_length (buffer, start);
 160       return -1;
 161     }
 162   else
 163     {
 164       /* put length back (doesn't actually realloc) */
 165       _dbus_string_set_length (buffer, start + bytes_read);
 166
 167 #if 0
 168
 169       if (bytes_read > 0)
 170         _dbus_verbose_bytes_of_string (buffer, start, bytes_read);
 171 #endif
 172
 173       return bytes_read;
 174     }
 175 }
 176
 177 int
 178 _dbus_file_write (DBusFile         *file,
 179                   const DBusString *buffer,
 180                   int               start,
 181                   int               len)
 182 {
 183   const int fd = file->FDATA;
 184   const char *data;
 185   int bytes_written;
 186
 187   data = _dbus_string_get_const_data_len (buffer, start, len);
 188
 189   _dbus_assert (fd >= 0);
 190
 191   _dbus_verbose ("write: len=%d fd=%d\n", len, fd);
 192   bytes_written = write (fd, data, len);
 193
 194   if (bytes_written == -1)
 195     _dbus_verbose ("write: failed: %s\n", _dbus_strerror (errno));
 196   else
 197     _dbus_verbose ("write: = %d\n", bytes_written);
 198
 199 #if 0
 200
 201   if (bytes_written > 0)
 202     _dbus_verbose_bytes_of_string (buffer, start, bytes_written);
 203 #endif
 204
 205   return bytes_written;
 206 }
 207
 208 dbus_bool_t
 209 _dbus_is_valid_file (DBusFile* file)
 210 {
 211   return file->FDATA >= 0;
 212 }
 213
 214 dbus_bool_t _dbus_fstat (DBusFile    *file,
 215                          struct stat *sb)
 216 {
 217   return fstat(file->FDATA, sb) >= 0;
 218 }
 219
 220 /**
 221  * write data to a pipe.
 222  *
 223  * @param pipe the pipe instance
 224  * @param buffer the buffer to write data from
 225  * @param start the first byte in the buffer to write
 226  * @param len the number of bytes to try to write
 227  * @param error error return
 228  * @returns the number of bytes written or -1 on error
 229  */
 230 int
 231 _dbus_pipe_write (DBusPipe         *pipe,
 232                   const DBusString *buffer,
 233                   int               start,
 234                   int               len,
 235                   DBusError        *error)
 236 {
 237   int written;
 238   DBusFile file;
 239   file.FDATA = pipe->fd_or_handle;
 240   written = _dbus_file_write (&file, buffer, start, len);
 241   if (written < 0)
 242     {
 243       dbus_set_error (error, DBUS_ERROR_FAILED,
 244                       "Writing to pipe: %s\n",
 245                       _dbus_strerror (errno));
 246     }
 247   return written;
 248 }
 249
 250 /**
 251  * close a pipe.
 252  *
 253  * @param pipe the pipe instance
 254  * @param error return location for an error
 255  * @returns #FALSE if error is set
 256  */
 257 int
 258 _dbus_pipe_close  (DBusPipe         *pipe,
 259                    DBusError        *error)
 260 {
 261   DBusFile file;
 262   file.FDATA = pipe->fd_or_handle;
 263   if (_dbus_file_close (&file, error) < 0)
 264     {
 265       return -1;
 266     }
 267   else
 268     {
 269       _dbus_pipe_invalidate (pipe);
 270       return 0;
 271     }
 272 }
 273
 274 #undef FDATA
 275
 276 /**
 277  * Socket interface
 278  *
 279  */
 280
 281 /**
 282  * Thin wrapper around the read() system call that appends
 283  * the data it reads to the DBusString buffer. It appends
 284  * up to the given count, and returns the same value
 285  * and same errno as read(). The only exception is that
 286  * _dbus_read() handles EINTR for you. _dbus_read() can
 287  * return ENOMEM, even though regular UNIX read doesn't.
 288  *
 289  * @param fd the file descriptor to read from
 290  * @param buffer the buffer to append data to
 291  * @param count the amount of data to read
 292  * @returns the number of bytes read or -1
 293  */
 294 int
 295 _dbus_read_socket (int               fd,
 296                    DBusString       *buffer,
 297                    int               count)
 298 {
 299   int bytes_read;
 300   int start;
 301   char *data;
 302
 303   _dbus_assert (count >= 0);
 304
 305   start = _dbus_string_get_length (buffer);
 306
 307   if (!_dbus_string_lengthen (buffer, count))
 308     {
 309       errno = ENOMEM;
 310       return -1;
 311     }
 312
 313   data = _dbus_string_get_data_len (buffer, start, count);
 314
 315  again:
 316
 317   _dbus_verbose ("recv: count=%d fd=%d\n", count, fd);
 318   bytes_read = recv (fd, data, count, 0);
 319
 320   if (bytes_read == SOCKET_ERROR)
 321         {
 322           DBUS_SOCKET_SET_ERRNO();
 323           _dbus_verbose ("recv: failed: %s\n", _dbus_strerror (errno));
 324           bytes_read = -1;
 325         }
 326         else
 327           _dbus_verbose ("recv: = %d\n", bytes_read);
 328
 329   if (bytes_read < 0)
 330     {
 331       if (errno == EINTR)
 332         goto again;
 333       else
 334         {
 335           /* put length back (note that this doesn't actually realloc anything) */
 336           _dbus_string_set_length (buffer, start);
 337           return -1;
 338         }
 339     }
 340   else
 341     {
 342       /* put length back (doesn't actually realloc) */
 343       _dbus_string_set_length (buffer, start + bytes_read);
 344
 345 #if 0
 346       if (bytes_read > 0)
 347         _dbus_verbose_bytes_of_string (buffer, start, bytes_read);
 348 #endif
 349
 350       return bytes_read;
 351     }
 352 }
 353
 354 /**
 355  * Thin wrapper around the write() system call that writes a part of a
 356  * DBusString and handles EINTR for you.
 357  *
 358  * @param fd the file descriptor to write
 359  * @param buffer the buffer to write data from
 360  * @param start the first byte in the buffer to write
 361  * @param len the number of bytes to try to write
 362  * @returns the number of bytes written or -1 on error
 363  */
 364 int
 365 _dbus_write_socket (int               fd,
 366                     const DBusString *buffer,
 367                     int               start,
 368                     int               len)
 369 {
 370   const char *data;
 371   int bytes_written;
 372
 373   data = _dbus_string_get_const_data_len (buffer, start, len);
 374
 375  again:
 376
 377   _dbus_verbose ("send: len=%d fd=%d\n", len, fd);
 378   bytes_written = send (fd, data, len, 0);
 379
 380   if (bytes_written == SOCKET_ERROR)
 381     {
 382       DBUS_SOCKET_SET_ERRNO();
 383       _dbus_verbose ("send: failed: %s\n", _dbus_strerror (errno));
 384       bytes_written = -1;
 385     }
 386     else
 387       _dbus_verbose ("send: = %d\n", bytes_written);
 388
 389   if (bytes_written < 0 && errno == EINTR)
 390     goto again;
 391
 392 #if 0
 393   if (bytes_written > 0)
 394     _dbus_verbose_bytes_of_string (buffer, start, bytes_written);
 395 #endif
 396
 397   return bytes_written;
 398 }
 399
 400
 401 /**
 402  * Closes a file descriptor.
 403  *
 404  * @param fd the file descriptor
 405  * @param error error object
 406  * @returns #FALSE if error set
 407  */
 408 dbus_bool_t
 409 _dbus_close_socket (int        fd,
 410                     DBusError *error)
 411 {
 412   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 413
 414  again:
 415   if (closesocket (fd) == SOCKET_ERROR)
 416     {
 417       DBUS_SOCKET_SET_ERRNO ();
 418
 419       if (errno == EINTR)
 420         goto again;
 421
 422       dbus_set_error (error, _dbus_error_from_errno (errno),
 423                       "Could not close socket: socket=%d, , %s",
 424                       fd, _dbus_strerror (errno));
 425       return FALSE;
 426     }
 427   _dbus_verbose ("_dbus_close_socket: socket=%d, \n", fd);
 428
 429   return TRUE;
 430 }
 431
 432 /**
 433  * Sets the file descriptor to be close
 434  * on exec. Should be called for all file
 435  * descriptors in D-Bus code.
 436  *
 437  * @param fd the file descriptor
 438  */
 439 void
 440 _dbus_fd_set_close_on_exec (int handle)
 441 {
 442 #ifdef ENABLE_DBUSSOCKET
 443   DBusSocket *s;
 444   if (handle < 0)
 445     return;
 446
 447   _dbus_lock_sockets();
 448
 449   _dbus_handle_to_socket_unlocked (handle, &s);
 450   s->close_on_exec = TRUE;
 451
 452   _dbus_unlock_sockets();
 453 #else
 454   /* TODO unic code.
 455   int val;
 456
 457   val = fcntl (fd, F_GETFD, 0);
 458
 459   if (val < 0)
 460     return;
 461
 462   val |= FD_CLOEXEC;
 463
 464   fcntl (fd, F_SETFD, val);
 465   */
 466 #endif
 467 }
 468
 469 /**
 470  * Sets a file descriptor to be nonblocking.
 471  *
 472  * @param fd the file descriptor.
 473  * @param error address of error location.
 474  * @returns #TRUE on success.
 475  */
 476 dbus_bool_t
 477 _dbus_set_fd_nonblocking (int             handle,
 478                           DBusError      *error)
 479 {
 480   u_long one = 1;
 481
 482   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 483
 484   if (ioctlsocket (handle, FIONBIO, &one) == SOCKET_ERROR)
 485     {
 486       dbus_set_error (error, _dbus_error_from_errno (WSAGetLastError ()),
 487                       "Failed to set socket %d:%d to nonblocking: %s", handle,
 488                       _dbus_strerror (WSAGetLastError ()));
 489       return FALSE;
 490     }
 491
 492   return TRUE;
 493 }
 494
 495
 496 /**
 497  * Like _dbus_write() but will use writev() if possible
 498  * to write both buffers in sequence. The return value
 499  * is the number of bytes written in the first buffer,
 500  * plus the number written in the second. If the first
 501  * buffer is written successfully and an error occurs
 502  * writing the second, the number of bytes in the first
 503  * is returned (i.e. the error is ignored), on systems that
 504  * don't have writev. Handles EINTR for you.
 505  * The second buffer may be #NULL.
 506  *
 507  * @param fd the file descriptor
 508  * @param buffer1 first buffer
 509  * @param start1 first byte to write in first buffer
 510  * @param len1 number of bytes to write from first buffer
 511  * @param buffer2 second buffer, or #NULL
 512  * @param start2 first byte to write in second buffer
 513  * @param len2 number of bytes to write in second buffer
 514  * @returns total bytes written from both buffers, or -1 on error
 515  */
 516 int
 517 _dbus_write_socket_two (int               fd,
 518                         const DBusString *buffer1,
 519                         int               start1,
 520                         int               len1,
 521                         const DBusString *buffer2,
 522                         int               start2,
 523                         int               len2)
 524 {
 525   WSABUF vectors[2];
 526   const char *data1;
 527   const char *data2;
 528   int rc;
 529   DWORD bytes_written;
 530   int ret1;
 531
 532   _dbus_assert (buffer1 != NULL);
 533   _dbus_assert (start1 >= 0);
 534   _dbus_assert (start2 >= 0);
 535   _dbus_assert (len1 >= 0);
 536   _dbus_assert (len2 >= 0);
 537
 538
 539   data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
 540
 541   if (buffer2 != NULL)
 542     data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
 543   else
 544     {
 545       data2 = NULL;
 546       start2 = 0;
 547       len2 = 0;
 548     }
 549
 550   vectors[0].buf = (char*) data1;
 551   vectors[0].len = len1;
 552   vectors[1].buf = (char*) data2;
 553   vectors[1].len = len2;
 554
 555  again:
 556
 557   _dbus_verbose ("WSASend: len1+2=%d+%d fd=%d\n", len1, len2, fd);
 558   rc = WSASend (fd,
 559                 vectors,
 560                 data2 ? 2 : 1,
 561                 &bytes_written,
 562                 0,
 563                 NULL,
 564                 NULL);
 565
 566   if (rc < 0)
 567     {
 568       DBUS_SOCKET_SET_ERRNO ();
 569       _dbus_verbose ("WSASend: failed: %s\n", _dbus_strerror (errno));
 570       bytes_written = -1;
 571     }
 572   else
 573     _dbus_verbose ("WSASend: = %ld\n", bytes_written);
 574
 575   if (bytes_written < 0 && errno == EINTR)
 576     goto again;
 577
 578   return bytes_written;
 579 }
 580
 581 #if 0
 582
 583 /**
 584  * Opens the client side of a Windows named pipe. The connection D-BUS
 585  * file descriptor index is returned. It is set up as nonblocking.
 586  *
 587  * @param path the path to named pipe socket
 588  * @param error return location for error code
 589  * @returns connection D-BUS file descriptor or -1 on error
 590  */
 591 int
 592 _dbus_connect_named_pipe (const char     *path,
 593                           DBusError      *error)
 594 {
 595   _dbus_assert_not_reached ("not implemented");
 596 }
 597
 598 #endif
 599
 600
 601
 602 void
 603 _dbus_win_startup_winsock (void)
 604 {
 605   /* Straight from MSDN, deuglified */
 606
 607   static dbus_bool_t beenhere = FALSE;
 608
 609   WORD wVersionRequested;
 610   WSADATA wsaData;
 611   int err;
 612
 613   if (beenhere)
 614     return;
 615
 616   wVersionRequested = MAKEWORD (2, 0);
 617
 618   err = WSAStartup (wVersionRequested, &wsaData);
 619   if (err != 0)
 620     {
 621       _dbus_assert_not_reached ("Could not initialize WinSock");
 622       _dbus_abort ();
 623     }
 624
 625   /* Confirm that the WinSock DLL supports 2.0.  Note that if the DLL
 626    * supports versions greater than 2.0 in addition to 2.0, it will
 627    * still return 2.0 in wVersion since that is the version we
 628    * requested.
 629    */
 630   if (LOBYTE (wsaData.wVersion) != 2 ||
 631       HIBYTE (wsaData.wVersion) != 0)
 632     {
 633       _dbus_assert_not_reached ("No usable WinSock found");
 634       _dbus_abort ();
 635     }
 636
 637   beenhere = TRUE;
 638 }
 639
 640
 641
 642
 643
 644
 645
 646
 647
 648 /************************************************************************
 649
 650  UTF / string code
 651
 652  ************************************************************************/
 653
 654 /**
 655  * Measure the message length without terminating nul
 656  */
 657 int _dbus_printf_string_upper_bound (const char *format,
 658                                      va_list args)
 659 {
 660   /* MSVCRT's vsnprintf semantics are a bit different */
 661   /* The C library source in the Platform SDK indicates that this
 662    * would work, but alas, it doesn't. At least not on Windows
 663    * 2000. Presumably those sources correspond to the C library on
 664    * some newer or even future Windows version.
 665    *
 666     len = _vsnprintf (NULL, _DBUS_INT_MAX, format, args);
 667    */
 668   char p[1024];
 669   int len;
 670   len = _vsnprintf (p, sizeof(p)-1, format, args);
 671   if (len == -1) // try again
 672     {
 673       char *p;
 674       p = malloc (strlen(format)*3);
 675       len = _vsnprintf (p, sizeof(p)-1, format, args);
 676       free(p);
 677     }
 678   return len;
 679 }
 680
 681
 682 /**
 683  * Returns the UTF-16 form of a UTF-8 string. The result should be
 684  * freed with dbus_free() when no longer needed.
 685  *
 686  * @param str the UTF-8 string
 687  * @param error return location for error code
 688  */
 689 wchar_t *
 690 _dbus_win_utf8_to_utf16 (const char *str,
 691                          DBusError  *error)
 692 {
 693   DBusString s;
 694   int n;
 695   wchar_t *retval;
 696
 697   _dbus_string_init_const (&s, str);
 698
 699   if (!_dbus_string_validate_utf8 (&s, 0, _dbus_string_get_length (&s)))
 700     {
 701       dbus_set_error_const (error, DBUS_ERROR_FAILED, "Invalid UTF-8");
 702       return NULL;
 703     }
 704
 705   n = MultiByteToWideChar (CP_UTF8, 0, str, -1, NULL, 0);
 706
 707   if (n == 0)
 708     {
 709       _dbus_win_set_error_from_win_error (error, GetLastError ());
 710       return NULL;
 711     }
 712
 713   retval = dbus_new (wchar_t, n);
 714
 715   if (!retval)
 716     {
 717       _DBUS_SET_OOM (error);
 718       return NULL;
 719     }
 720
 721   if (MultiByteToWideChar (CP_UTF8, 0, str, -1, retval, n) != n)
 722     {
 723       dbus_free (retval);
 724       dbus_set_error_const (error, DBUS_ERROR_FAILED, "MultiByteToWideChar inconsistency");
 725       return NULL;
 726     }
 727
 728   return retval;
 729 }
 730
 731 /**
 732  * Returns the UTF-8 form of a UTF-16 string. The result should be
 733  * freed with dbus_free() when no longer needed.
 734  *
 735  * @param str the UTF-16 string
 736  * @param error return location for error code
 737  */
 738 char *
 739 _dbus_win_utf16_to_utf8 (const wchar_t *str,
 740                          DBusError     *error)
 741 {
 742   int n;
 743   char *retval;
 744
 745   n = WideCharToMultiByte (CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL);
 746
 747   if (n == 0)
 748     {
 749       _dbus_win_set_error_from_win_error (error, GetLastError ());
 750       return NULL;
 751     }
 752
 753   retval = dbus_malloc (n);
 754
 755   if (!retval)
 756     {
 757       _DBUS_SET_OOM (error);
 758       return NULL;
 759     }
 760
 761   if (WideCharToMultiByte (CP_UTF8, 0, str, -1, retval, n, NULL, NULL) != n)
 762     {
 763       dbus_free (retval);
 764       dbus_set_error_const (error, DBUS_ERROR_FAILED, "WideCharToMultiByte inconsistency");
 765       return NULL;
 766     }
 767
 768   return retval;
 769 }
 770
 771
 772
 773
 774
 775
 776 /************************************************************************
 777
 778
 779  ************************************************************************/
 780
 781 dbus_bool_t
 782 _dbus_win_account_to_sid (const wchar_t *waccount,
 783                           void           **ppsid,
 784                           DBusError       *error)
 785 {
 786   dbus_bool_t retval = FALSE;
 787   DWORD sid_length, wdomain_length;
 788   SID_NAME_USE use;
 789   wchar_t *wdomain;
 790
 791   *ppsid = NULL;
 792
 793   sid_length = 0;
 794   wdomain_length = 0;
 795   if (!LookupAccountNameW (NULL, waccount, NULL, &sid_length,
 796                            NULL, &wdomain_length, &use) &&
 797       GetLastError () != ERROR_INSUFFICIENT_BUFFER)
 798     {
 799       _dbus_win_set_error_from_win_error (error, GetLastError ());
 800       return FALSE;
 801     }
 802
 803   *ppsid = dbus_malloc (sid_length);
 804   if (!*ppsid)
 805     {
 806       _DBUS_SET_OOM (error);
 807       return FALSE;
 808     }
 809
 810   wdomain = dbus_new (wchar_t, wdomain_length);
 811   if (!wdomain)
 812     {
 813       _DBUS_SET_OOM (error);
 814       goto out1;
 815     }
 816
 817   if (!LookupAccountNameW (NULL, waccount, (PSID) *ppsid, &sid_length,
 818                            wdomain, &wdomain_length, &use))
 819     {
 820       _dbus_win_set_error_from_win_error (error, GetLastError ());
 821       goto out2;
 822     }
 823
 824   if (!IsValidSid ((PSID) *ppsid))
 825     {
 826       dbus_set_error_const (error, DBUS_ERROR_FAILED, "Invalid SID");
 827       goto out2;
 828     }
 829
 830   retval = TRUE;
 831
 832 out2:
 833   dbus_free (wdomain);
 834 out1:
 835   if (!retval)
 836     {
 837       dbus_free (*ppsid);
 838       *ppsid = NULL;
 839     }
 840
 841   return retval;
 842 }
 843
 844 /** @} end of sysdeps-win */
 845
 846
 847 /** Gets our UID
 848  * @returns process UID
 849  */
 850 dbus_uid_t
 851 _dbus_getuid (void)
 852 {
 853         return DBUS_UID_UNSET;
 854 }
 855
 856 /**
 857  * The only reason this is separate from _dbus_getpid() is to allow it
 858  * on Windows for logging but not for other purposes.
 859  *
 860  * @returns process ID to put in log messages
 861  */
 862 unsigned long
 863 _dbus_pid_for_log (void)
 864 {
 865   return _dbus_getpid ();
 866 }
 867
 868 /** Gets our SID
 869  * @param points to sid buffer, need to be freed with LocalFree()
 870  * @returns process sid
 871  */
 872 dbus_bool_t
 873 _dbus_getsid(char **sid)
 874 {
 875   HANDLE process_token = NULL;
 876   TOKEN_USER *token_user = NULL;
 877   DWORD n;
 878   PSID psid;
 879   int retval = FALSE;
 880
 881   if (!OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY, &process_token))
 882     {
 883       _dbus_win_warn_win_error ("OpenProcessToken failed", GetLastError ());
 884       goto failed;
 885     }
 886   if ((!GetTokenInformation (process_token, TokenUser, NULL, 0, &n)
 887             && GetLastError () != ERROR_INSUFFICIENT_BUFFER)
 888            || (token_user = alloca (n)) == NULL
 889            || !GetTokenInformation (process_token, TokenUser, token_user, n, &n))
 890     {
 891       _dbus_win_warn_win_error ("GetTokenInformation failed", GetLastError ());
 892       goto failed;
 893     }
 894   psid = token_user->User.Sid;
 895   if (!IsValidSid (psid))
 896     {
 897       _dbus_verbose("%s invalid sid\n",__FUNCTION__);
 898       goto failed;
 899     }
 900   if (!ConvertSidToStringSidA (psid, sid))
 901     {
 902       _dbus_verbose("%s invalid sid\n",__FUNCTION__);
 903       goto failed;
 904     }
 905 //okay:
 906   retval = TRUE;
 907
 908 failed:
 909   if (process_token != NULL)
 910     CloseHandle (process_token);
 911
 912   _dbus_verbose("_dbus_getsid() returns %d\n",retval);
 913   return retval;
 914 }
 915
 916
 917 #ifdef DBUS_BUILD_TESTS
 918 /** Gets our GID
 919  * @returns process GID
 920  */
 921 dbus_gid_t
 922 _dbus_getgid (void)
 923 {
 924         return DBUS_GID_UNSET;
 925 }
 926
 927 #if 0
 928 dbus_bool_t
 929 _dbus_domain_test (const char *test_data_dir)
 930 {
 931   if (!_dbus_test_oom_handling ("spawn_nonexistent",
 932                                 check_spawn_nonexistent,
 933                                 NULL))
 934     return FALSE;
 935 }
 936
 937 #endif
 938
 939 #endif //DBUS_BUILD_TESTS
 940
 941 /************************************************************************
 942
 943  pipes
 944
 945  ************************************************************************/
 946
 947 /**
 948  * Creates a full-duplex pipe (as in socketpair()).
 949  * Sets both ends of the pipe nonblocking.
 950  *
 951  * @todo libdbus only uses this for the debug-pipe server, so in
 952  * principle it could be in dbus-sysdeps-util.c, except that
 953  * dbus-sysdeps-util.c isn't in libdbus when tests are enabled and the
 954  * debug-pipe server is used.
 955  *
 956  * @param fd1 return location for one end
 957  * @param fd2 return location for the other end
 958  * @param blocking #TRUE if pipe should be blocking
 959  * @param error error return
 960  * @returns #FALSE on failure (if error is set)
 961  */
 962 dbus_bool_t
 963 _dbus_full_duplex_pipe (int        *fd1,
 964                         int        *fd2,
 965                         dbus_bool_t blocking,
 966                         DBusError  *error)
 967 {
 968   SOCKET temp, socket1 = -1, socket2 = -1;
 969   struct sockaddr_in saddr;
 970   int len;
 971   u_long arg;
 972   fd_set read_set, write_set;
 973   struct timeval tv;
 974
 975   _dbus_win_startup_winsock ();
 976
 977   temp = socket (AF_INET, SOCK_STREAM, 0);
 978   if (temp == INVALID_SOCKET)
 979     {
 980       DBUS_SOCKET_SET_ERRNO ();
 981       goto out0;
 982     }
 983
 984   arg = 1;
 985   if (ioctlsocket (temp, FIONBIO, &arg) == SOCKET_ERROR)
 986     {
 987       DBUS_SOCKET_SET_ERRNO ();
 988       goto out0;
 989     }
 990
 991   _DBUS_ZERO (saddr);
 992   saddr.sin_family = AF_INET;
 993   saddr.sin_port = 0;
 994   saddr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
 995
 996   if (bind (temp, (struct sockaddr *)&saddr, sizeof (saddr)))
 997     {
 998       DBUS_SOCKET_SET_ERRNO ();
 999       goto out0;
1000     }
1001
1002   if (listen (temp, 1) == SOCKET_ERROR)
1003     {
1004       DBUS_SOCKET_SET_ERRNO ();
1005       goto out0;
1006     }
1007
1008   len = sizeof (saddr);
1009   if (getsockname (temp, (struct sockaddr *)&saddr, &len))
1010     {
1011       DBUS_SOCKET_SET_ERRNO ();
1012       goto out0;
1013     }
1014
1015   socket1 = socket (AF_INET, SOCK_STREAM, 0);
1016   if (socket1 == INVALID_SOCKET)
1017     {
1018       DBUS_SOCKET_SET_ERRNO ();
1019       goto out0;
1020     }
1021
1022   arg = 1;
1023   if (ioctlsocket (socket1, FIONBIO, &arg) == SOCKET_ERROR)
1024     {
1025       DBUS_SOCKET_SET_ERRNO ();
1026       goto out1;
1027     }
1028
1029   if (connect (socket1, (struct sockaddr  *)&saddr, len) != SOCKET_ERROR ||
1030       WSAGetLastError () != WSAEWOULDBLOCK)
1031     {
1032       DBUS_SOCKET_SET_ERRNO ();
1033       goto out1;
1034     }
1035
1036   FD_ZERO (&read_set);
1037   FD_SET (temp, &read_set);
1038
1039   tv.tv_sec = 0;
1040   tv.tv_usec = 0;
1041
1042   if (select (0, &read_set, NULL, NULL, NULL) == SOCKET_ERROR)
1043     {
1044       DBUS_SOCKET_SET_ERRNO ();
1045       goto out1;
1046     }
1047
1048   _dbus_assert (FD_ISSET (temp, &read_set));
1049
1050   socket2 = accept (temp, (struct sockaddr *) &saddr, &len);
1051   if (socket2 == INVALID_SOCKET)
1052     {
1053       DBUS_SOCKET_SET_ERRNO ();
1054       goto out1;
1055     }
1056
1057   FD_ZERO (&write_set);
1058   FD_SET (socket1, &write_set);
1059
1060   tv.tv_sec = 0;
1061   tv.tv_usec = 0;
1062
1063   if (select (0, NULL, &write_set, NULL, NULL) == SOCKET_ERROR)
1064     {
1065       DBUS_SOCKET_SET_ERRNO ();
1066       goto out2;
1067     }
1068
1069   _dbus_assert (FD_ISSET (socket1, &write_set));
1070
1071   if (blocking)
1072     {
1073       arg = 0;
1074       if (ioctlsocket (socket1, FIONBIO, &arg) == SOCKET_ERROR)
1075         {
1076           DBUS_SOCKET_SET_ERRNO ();
1077           goto out2;
1078         }
1079
1080       arg = 0;
1081       if (ioctlsocket (socket2, FIONBIO, &arg) == SOCKET_ERROR)
1082         {
1083           DBUS_SOCKET_SET_ERRNO ();
1084           goto out2;
1085         }
1086     }
1087   else
1088     {
1089       arg = 1;
1090       if (ioctlsocket (socket2, FIONBIO, &arg) == SOCKET_ERROR)
1091         {
1092           DBUS_SOCKET_SET_ERRNO ();
1093           goto out2;
1094         }
1095     }
1096
1097   *fd1 = socket1;
1098   *fd2 = socket2;
1099
1100   _dbus_verbose ("full-duplex pipe %d:%d <-> %d:%d\n",
1101                  *fd1, socket1, *fd2, socket2);
1102
1103   closesocket (temp);
1104
1105   return TRUE;
1106
1107 out2:
1108   closesocket (socket2);
1109 out1:
1110   closesocket (socket1);
1111 out0:
1112   closesocket (temp);
1113
1114   dbus_set_error (error, _dbus_error_from_errno (errno),
1115                   "Could not setup socket pair: %s",
1116                   _dbus_strerror (errno));
1117
1118   return FALSE;
1119 }
1120
1121 /**
1122  * Wrapper for poll().
1123  *
1124  * @param fds the file descriptors to poll
1125  * @param n_fds number of descriptors in the array
1126  * @param timeout_milliseconds timeout or -1 for infinite
1127  * @returns numbers of fds with revents, or <0 on error
1128  */
1129 #define USE_CHRIS_IMPL 0
1130 #if USE_CHRIS_IMPL
1131 int
1132 _dbus_poll (DBusPollFD *fds,
1133             int         n_fds,
1134             int         timeout_milliseconds)
1135 {
1136 #define DBUS_POLL_CHAR_BUFFER_SIZE 2000
1137   char msg[DBUS_POLL_CHAR_BUFFER_SIZE];
1138   char *msgp;
1139
1140   int ret = 0;
1141   int i;
1142   struct timeval tv;
1143   int ready;
1144
1145 #define DBUS_STACK_WSAEVENTS 256
1146   WSAEVENT eventsOnStack[DBUS_STACK_WSAEVENTS];
1147   WSAEVENT *pEvents = NULL;
1148   if (n_fds > DBUS_STACK_WSAEVENTS)
1149     pEvents = calloc(sizeof(WSAEVENT), n_fds);
1150   else
1151     pEvents = eventsOnStack;
1152
1153
1154 #ifdef DBUS_ENABLE_VERBOSE_MODE
1155   msgp = msg;
1156   msgp += sprintf (msgp, "WSAEventSelect: to=%d\n\t", timeout_milliseconds);
1157   for (i = 0; i < n_fds; i++)
1158     {
1159       static dbus_bool_t warned = FALSE;
1160       DBusPollFD *fdp = &fds[i];
1161
1162
1163       if (fdp->events & _DBUS_POLLIN)
1164         msgp += sprintf (msgp, "R:%d ", fdp->fd);
1165
1166       if (fdp->events & _DBUS_POLLOUT)
1167         msgp += sprintf (msgp, "W:%d ", fdp->fd);
1168
1169       msgp += sprintf (msgp, "E:%d\n\t", fdp->fd);
1170
1171       // FIXME: more robust code for long  msg
1172       //        create on heap when msg[] becomes too small
1173       if (msgp >= msg + DBUS_POLL_CHAR_BUFFER_SIZE)
1174         {
1175           _dbus_assert_not_reached ("buffer overflow in _dbus_poll");
1176         }
1177     }
1178
1179   msgp += sprintf (msgp, "\n");
1180   _dbus_verbose ("%s",msg);
1181 #endif
1182   for (i = 0; i < n_fds; i++)
1183     {
1184       DBusPollFD *fdp = &fds[i];
1185       WSAEVENT ev;
1186       long lNetworkEvents = FD_OOB;
1187
1188       ev = WSACreateEvent();
1189
1190       if (fdp->events & _DBUS_POLLIN)
1191         lNetworkEvents |= FD_READ | FD_ACCEPT | FD_CLOSE;
1192
1193       if (fdp->events & _DBUS_POLLOUT)
1194         lNetworkEvents |= FD_WRITE | FD_CONNECT;
1195
1196       WSAEventSelect(fdp->fd, ev, lNetworkEvents);
1197
1198       pEvents[i] = ev;
1199     }
1200
1201
1202   ready = WSAWaitForMultipleEvents (n_fds, pEvents, FALSE, timeout_milliseconds, FALSE);
1203
1204   if (DBUS_SOCKET_API_RETURNS_ERROR (ready))
1205     {
1206       DBUS_SOCKET_SET_ERRNO ();
1207       if (errno != EWOULDBLOCK)
1208         _dbus_verbose ("WSAWaitForMultipleEvents: failed: %s\n", _dbus_strerror (errno));
1209       ret = -1;
1210     }
1211   else if (ready == WSA_WAIT_TIMEOUT)
1212     {
1213       _dbus_verbose ("WSAWaitForMultipleEvents: WSA_WAIT_TIMEOUT\n");
1214       ret = 0;
1215     }
1216   else if (ready >= WSA_WAIT_EVENT_0 && ready < (int)(WSA_WAIT_EVENT_0 + n_fds))
1217     {
1218       msgp = msg;
1219       msgp += sprintf (msgp, "WSAWaitForMultipleEvents: =%d\n\t", ready);
1220
1221       for (i = 0; i < n_fds; i++)
1222         {
1223           DBusPollFD *fdp = &fds[i];
1224           WSANETWORKEVENTS ne;
1225
1226           fdp->revents = 0;
1227
1228           WSAEnumNetworkEvents(fdp->fd, pEvents[i], &ne);
1229
1230           if (ne.lNetworkEvents & (FD_READ | FD_ACCEPT | FD_CLOSE))
1231             fdp->revents |= _DBUS_POLLIN;
1232
1233           if (ne.lNetworkEvents & (FD_WRITE | FD_CONNECT))
1234             fdp->revents |= _DBUS_POLLOUT;
1235
1236           if (ne.lNetworkEvents & (FD_OOB))
1237             fdp->revents |= _DBUS_POLLERR;
1238
1239           if (ne.lNetworkEvents & (FD_READ | FD_ACCEPT | FD_CLOSE))
1240               msgp += sprintf (msgp, "R:%d ", fdp->fd);
1241
1242           if (ne.lNetworkEvents & (FD_WRITE | FD_CONNECT))
1243               msgp += sprintf (msgp, "W:%d ", fdp->fd);
1244
1245           if (ne.lNetworkEvents & (FD_OOB))
1246               msgp += sprintf (msgp, "E:%d ", fdp->fd);
1247
1248           msgp += sprintf (msgp, "lNetworkEvents:%d ", ne.lNetworkEvents);
1249
1250           if(ne.lNetworkEvents)
1251             ret++;
1252
1253           WSAEventSelect(fdp->fd, pEvents[i], 0);
1254         }
1255
1256       msgp += sprintf (msgp, "\n");
1257       _dbus_verbose ("%s",msg);
1258     }
1259   else
1260     {
1261       _dbus_verbose ("WSAWaitForMultipleEvents: failed for unknown reason!");
1262       ret = -1;
1263     }
1264
1265   for(i = 0; i < n_fds; i++)
1266     {
1267       WSACloseEvent(pEvents[i]);
1268     }
1269
1270   if (n_fds > DBUS_STACK_WSAEVENTS)
1271     free(pEvents);
1272
1273   return ret;
1274 }
1275
1276 #else   // USE_CHRIS_IMPL
1277
1278 int
1279 _dbus_poll (DBusPollFD *fds,
1280             int         n_fds,
1281             int         timeout_milliseconds)
1282 {
1283 #define DBUS_POLL_CHAR_BUFFER_SIZE 2000
1284   char msg[DBUS_POLL_CHAR_BUFFER_SIZE];
1285   char *msgp;
1286
1287   fd_set read_set, write_set, err_set;
1288   int max_fd = 0;
1289   int i;
1290   struct timeval tv;
1291   int ready;
1292
1293   FD_ZERO (&read_set);
1294   FD_ZERO (&write_set);
1295   FD_ZERO (&err_set);
1296
1297
1298 #ifdef DBUS_ENABLE_VERBOSE_MODE
1299   msgp = msg;
1300   msgp += sprintf (msgp, "select: to=%d\n\t", timeout_milliseconds);
1301   for (i = 0; i < n_fds; i++)
1302     {
1303       static dbus_bool_t warned = FALSE;
1304       DBusPollFD *fdp = &fds[i];
1305
1306
1307       if (fdp->events & _DBUS_POLLIN)
1308         msgp += sprintf (msgp, "R:%d ", fdp->fd);
1309
1310       if (fdp->events & _DBUS_POLLOUT)
1311         msgp += sprintf (msgp, "W:%d ", fdp->fd);
1312
1313       msgp += sprintf (msgp, "E:%d\n\t", fdp->fd);
1314
1315       // FIXME: more robust code for long  msg
1316       //        create on heap when msg[] becomes too small
1317       if (msgp >= msg + DBUS_POLL_CHAR_BUFFER_SIZE)
1318         {
1319           _dbus_assert_not_reached ("buffer overflow in _dbus_poll");
1320         }
1321     }
1322
1323   msgp += sprintf (msgp, "\n");
1324   _dbus_verbose ("%s",msg);
1325 #endif
1326   for (i = 0; i < n_fds; i++)
1327     {
1328       DBusPollFD *fdp = &fds[i];
1329
1330       if (fdp->events & _DBUS_POLLIN)
1331         FD_SET (fdp->fd, &read_set);
1332
1333       if (fdp->events & _DBUS_POLLOUT)
1334         FD_SET (fdp->fd, &write_set);
1335
1336       FD_SET (fdp->fd, &err_set);
1337
1338       max_fd = MAX (max_fd, fdp->fd);
1339     }
1340
1341
1342   tv.tv_sec = timeout_milliseconds / 1000;
1343   tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
1344
1345   ready = select (max_fd + 1, &read_set, &write_set, &err_set,
1346                   timeout_milliseconds < 0 ? NULL : &tv);
1347
1348   if (DBUS_SOCKET_API_RETURNS_ERROR (ready))
1349     {
1350       DBUS_SOCKET_SET_ERRNO ();
1351       if (errno != EWOULDBLOCK)
1352         _dbus_verbose ("select: failed: %s\n", _dbus_strerror (errno));
1353     }
1354   else if (ready == 0)
1355     _dbus_verbose ("select: = 0\n");
1356   else
1357     if (ready > 0)
1358       {
1359 #ifdef DBUS_ENABLE_VERBOSE_MODE
1360         msgp = msg;
1361         msgp += sprintf (msgp, "select: = %d:\n\t", ready);
1362
1363         for (i = 0; i < n_fds; i++)
1364           {
1365             DBusPollFD *fdp = &fds[i];
1366
1367             if (FD_ISSET (fdp->fd, &read_set))
1368               msgp += sprintf (msgp, "R:%d ", fdp->fd);
1369
1370             if (FD_ISSET (fdp->fd, &write_set))
1371               msgp += sprintf (msgp, "W:%d ", fdp->fd);
1372
1373             if (FD_ISSET (fdp->fd, &err_set))
1374               msgp += sprintf (msgp, "E:%d\n\t", fdp->fd);
1375           }
1376         msgp += sprintf (msgp, "\n");
1377         _dbus_verbose ("%s",msg);
1378 #endif
1379
1380         for (i = 0; i < n_fds; i++)
1381           {
1382             DBusPollFD *fdp = &fds[i];
1383
1384             fdp->revents = 0;
1385
1386             if (FD_ISSET (fdp->fd, &read_set))
1387               fdp->revents |= _DBUS_POLLIN;
1388
1389             if (FD_ISSET (fdp->fd, &write_set))
1390               fdp->revents |= _DBUS_POLLOUT;
1391
1392             if (FD_ISSET (fdp->fd, &err_set))
1393               fdp->revents |= _DBUS_POLLERR;
1394           }
1395       }
1396   return ready;
1397 }
1398
1399 #endif  // USE_CHRIS_IMPL
1400
1401
1402
1403
1404 /******************************************************************************
1405
1406 Original CVS version of dbus-sysdeps.c
1407
1408 ******************************************************************************/
1409 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
1410 /* dbus-sysdeps.c Wrappers around system/libc features (internal to D-Bus implementation)
1411  *
1412  * Copyright (C) 2002, 2003  Red Hat, Inc.
1413  * Copyright (C) 2003 CodeFactory AB
1414  * Copyright (C) 2005 Novell, Inc.
1415  *
1416  * Licensed under the Academic Free License version 2.1
1417  *
1418  * This program is free software; you can redistribute it and/or modify
1419  * it under the terms of the GNU General Public License as published by
1420  * the Free Software Foundation; either version 2 of the License, or
1421  * (at your option) any later version.
1422  *
1423  * This program is distributed in the hope that it will be useful,
1424  * but WITHOUT ANY WARRANTY; without even the implied warranty of
1425  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1426  * GNU General Public License for more details.
1427  *
1428  * You should have received a copy of the GNU General Public License
1429  * along with this program; if not, write to the Free Software
1430  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
1431  *
1432  */
1433
1434
1435 /**
1436  * Exit the process, returning the given value.
1437  *
1438  * @param code the exit code
1439  */
1440 void
1441 _dbus_exit (int code)
1442 {
1443   _exit (code);
1444 }
1445
1446 /**
1447  * Creates a socket and connects to a socket at the given host
1448  * and port. The connection fd is returned, and is set up as
1449  * nonblocking.
1450  *
1451  * @param host the host name to connect to
1452  * @param port the port to connect to
1453  * @param family the address family to listen on, NULL for all
1454  * @param error return location for error code
1455  * @returns connection file descriptor or -1 on error
1456  */
1457 int
1458 _dbus_connect_tcp_socket (const char     *host,
1459                           const char     *port,
1460                           const char     *family,
1461                           DBusError      *error)
1462 {
1463   int fd = -1, res;
1464   struct addrinfo hints;
1465   struct addrinfo *ai, *tmp;
1466
1467   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1468
1469   _dbus_win_startup_winsock ();
1470
1471   fd = socket (AF_INET, SOCK_STREAM, 0);
1472
1473   if (DBUS_SOCKET_IS_INVALID (fd))
1474     {
1475       DBUS_SOCKET_SET_ERRNO ();
1476       dbus_set_error (error,
1477                       _dbus_error_from_errno (errno),
1478                       "Failed to create socket: %s",
1479                       _dbus_strerror (errno));
1480
1481       return -1;
1482     }
1483
1484   _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1485
1486   _DBUS_ZERO (hints);
1487
1488   if (!family)
1489     hints.ai_family = AF_UNSPEC;
1490   else if (!strcmp(family, "ipv4"))
1491     hints.ai_family = AF_INET;
1492   else if (!strcmp(family, "ipv6"))
1493     hints.ai_family = AF_INET6;
1494   else
1495     {
1496       dbus_set_error (error,
1497                       _dbus_error_from_errno (errno),
1498                       "Unknown address family %s", family);
1499       return -1;
1500     }
1501   hints.ai_protocol = IPPROTO_TCP;
1502   hints.ai_socktype = SOCK_STREAM;
1503 #ifdef AI_ADDRCONFIG
1504   hints.ai_flags = AI_ADDRCONFIG;
1505 #else
1506   hints.ai_flags = 0;
1507 #endif
1508
1509   if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
1510     {
1511       dbus_set_error (error,
1512                       _dbus_error_from_errno (errno),
1513                       "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1514                       host, port, gai_strerror(res), res);
1515       closesocket (fd);
1516       return -1;
1517     }
1518
1519   tmp = ai;
1520   while (tmp)
1521     {
1522       if ((fd = socket (tmp->ai_family, SOCK_STREAM, 0)) < 0)
1523         {
1524           freeaddrinfo(ai);
1525       dbus_set_error (error,
1526                       _dbus_error_from_errno (errno),
1527                          "Failed to open socket: %s",
1528                          _dbus_strerror (errno));
1529           return -1;
1530         }
1531       _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1532
1533       if (connect (fd, (struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1534         {
1535           closesocket(fd);
1536       fd = -1;
1537           tmp = tmp->ai_next;
1538           continue;
1539         }
1540
1541       break;
1542     }
1543   freeaddrinfo(ai);
1544
1545   if (fd == -1)
1546     {
1547       dbus_set_error (error,
1548                       _dbus_error_from_errno (errno),
1549                       "Failed to connect to socket \"%s:%s\" %s",
1550                       host, port, _dbus_strerror(errno));
1551       return -1;
1552     }
1553
1554
1555   if (!_dbus_set_fd_nonblocking (fd, error))
1556     {
1557       closesocket (fd);
1558       fd = -1;
1559
1560       return -1;
1561     }
1562
1563   return fd;
1564 }
1565
1566
1567 void
1568 _dbus_daemon_init(const char *host, dbus_uint32_t port);
1569
1570 /**
1571  * Creates a socket and binds it to the given path, then listens on
1572  * the socket. The socket is set to be nonblocking.  In case of port=0
1573  * a random free port is used and returned in the port parameter.
1574  * If inaddr_any is specified, the hostname is ignored.
1575  *
1576  * @param host the host name to listen on
1577  * @param port the port to listen on, if zero a free port will be used
1578  * @param family the address family to listen on, NULL for all
1579  * @param retport string to return the actual port listened on
1580  * @param fds_p location to store returned file descriptors
1581  * @param error return location for errors
1582  * @returns the number of listening file descriptors or -1 on error
1583  */
1584
1585 int
1586 _dbus_listen_tcp_socket (const char     *host,
1587                          const char     *port,
1588                          const char     *family,
1589                          DBusString     *retport,
1590                          int           **fds_p,
1591                          DBusError      *error)
1592 {
1593   int nlisten_fd = 0, *listen_fd = NULL, res, i, port_num = -1;
1594   struct addrinfo hints;
1595   struct addrinfo *ai, *tmp;
1596
1597   *fds_p = NULL;
1598   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1599
1600   _dbus_win_startup_winsock ();
1601
1602   _DBUS_ZERO (hints);
1603
1604   if (!family)
1605     hints.ai_family = AF_UNSPEC;
1606   else if (!strcmp(family, "ipv4"))
1607     hints.ai_family = AF_INET;
1608   else if (!strcmp(family, "ipv6"))
1609     hints.ai_family = AF_INET6;
1610   else
1611     {
1612       dbus_set_error (error,
1613                       _dbus_error_from_errno (errno),
1614                       "Unknown address family %s", family);
1615       return -1;
1616     }
1617
1618   hints.ai_protocol = IPPROTO_TCP;
1619   hints.ai_socktype = SOCK_STREAM;
1620 #ifdef AI_ADDRCONFIG
1621   hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
1622 #else
1623   hints.ai_flags = AI_PASSIVE;
1624 #endif
1625
1626  redo_lookup_with_port:
1627   if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
1628     {
1629       dbus_set_error (error,
1630                       _dbus_error_from_errno (errno),
1631                       "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1632                       host ? host : "*", port, gai_strerror(res), res);
1633       return -1;
1634     }
1635
1636   tmp = ai;
1637   while (tmp)
1638     {
1639       int fd = -1, *newlisten_fd;
1640       if ((fd = socket (tmp->ai_family, SOCK_STREAM, 0)) < 0)
1641         {
1642           dbus_set_error (error,
1643                           _dbus_error_from_errno (errno),
1644                          "Failed to open socket: %s",
1645                          _dbus_strerror (errno));
1646           goto failed;
1647         }
1648       _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1649
1650       if (bind (fd, (struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) == SOCKET_ERROR)
1651         {
1652           closesocket (fd);
1653           dbus_set_error (error, _dbus_error_from_errno (errno),
1654                           "Failed to bind socket \"%s:%s\": %s",
1655                           host ? host : "*", port, _dbus_strerror (errno));
1656           goto failed;
1657     }
1658
1659       if (listen (fd, 30 /* backlog */) == SOCKET_ERROR)
1660         {
1661           closesocket (fd);
1662           dbus_set_error (error, _dbus_error_from_errno (errno),
1663                           "Failed to listen on socket \"%s:%s\": %s",
1664                           host ? host : "*", port, _dbus_strerror (errno));
1665           goto failed;
1666         }
1667
1668       newlisten_fd = dbus_realloc(listen_fd, sizeof(int)*(nlisten_fd+1));
1669       if (!newlisten_fd)
1670     {
1671           closesocket (fd);
1672       dbus_set_error (error, _dbus_error_from_errno (errno),
1673                           "Failed to allocate file handle array: %s",
1674                           _dbus_strerror (errno));
1675           goto failed;
1676     }
1677       listen_fd = newlisten_fd;
1678       listen_fd[nlisten_fd] = fd;
1679       nlisten_fd++;
1680
1681       if (!_dbus_string_get_length(retport))
1682         {
1683           /* If the user didn't specify a port, or used 0, then
1684              the kernel chooses a port. After the first address
1685              is bound to, we need to force all remaining addresses
1686              to use the same port */
1687           if (!port || !strcmp(port, "0"))
1688             {
1689               sockaddr_gen addr;
1690               socklen_t addrlen = sizeof(addr);
1691               char portbuf[10];
1692
1693               if ((res = getsockname(fd, &addr.Address, &addrlen)) != 0)
1694     {
1695       dbus_set_error (error, _dbus_error_from_errno (errno),
1696                                   "Failed to resolve port \"%s:%s\": %s (%d)",
1697                                   host ? host : "*", port, gai_strerror(res), res);
1698                   goto failed;
1699                 }
1700               snprintf( portbuf, sizeof( portbuf ) - 1, "%d", addr.AddressIn.sin_port );
1701               if (!_dbus_string_append(retport, portbuf))
1702                 {
1703                   dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1704                   goto failed;
1705     }
1706
1707               /* Release current address list & redo lookup */
1708               port = _dbus_string_get_const_data(retport);
1709               freeaddrinfo(ai);
1710               goto redo_lookup_with_port;
1711             }
1712           else
1713             {
1714               if (!_dbus_string_append(retport, port))
1715                 {
1716                     dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1717                     goto failed;
1718                 }
1719             }
1720         }
1721
1722       tmp = tmp->ai_next;
1723     }
1724   freeaddrinfo(ai);
1725   ai = NULL;
1726
1727   if (!nlisten_fd)
1728     {
1729       errno = WSAEADDRINUSE;
1730       dbus_set_error (error, _dbus_error_from_errno (errno),
1731                       "Failed to bind socket \"%s:%s\": %s",
1732                       host ? host : "*", port, _dbus_strerror (errno));
1733       return -1;
1734     }
1735
1736   sscanf(_dbus_string_get_const_data(retport), "%d", &port_num);
1737   _dbus_daemon_init(host, port_num);
1738
1739   for (i = 0 ; i < nlisten_fd ; i++)
1740     {
1741       if (!_dbus_set_fd_nonblocking (listen_fd[i], error))
1742         {
1743           goto failed;
1744         }
1745     }
1746
1747   *fds_p = listen_fd;
1748
1749   return nlisten_fd;
1750
1751  failed:
1752   if (ai)
1753     freeaddrinfo(ai);
1754   for (i = 0 ; i < nlisten_fd ; i++)
1755     closesocket (listen_fd[i]);
1756   dbus_free(listen_fd);
1757   return -1;
1758 }
1759
1760
1761 /**
1762  * Accepts a connection on a listening socket.
1763  * Handles EINTR for you.
1764  *
1765  * @param listen_fd the listen file descriptor
1766  * @returns the connection fd of the client, or -1 on error
1767  */
1768 int
1769 _dbus_accept  (int listen_fd)
1770 {
1771   int client_fd;
1772
1773  retry:
1774   client_fd = accept (listen_fd, NULL, NULL);
1775
1776   if (DBUS_SOCKET_IS_INVALID (client_fd))
1777     {
1778       DBUS_SOCKET_SET_ERRNO ();
1779       if (errno == EINTR)
1780         goto retry;
1781     }
1782
1783   _dbus_verbose ("client fd %d accepted\n", client_fd);
1784
1785   return client_fd;
1786 }
1787
1788
1789
1790
1791 dbus_bool_t
1792 _dbus_send_credentials_socket (int            handle,
1793                         DBusError      *error)
1794 {
1795 /* FIXME: for the session bus credentials shouldn't matter (?), but
1796  * for the system bus they are presumably essential. A rough outline
1797  * of a way to implement the credential transfer would be this:
1798  *
1799  * client waits to *read* a byte.
1800  *
1801  * server creates a named pipe with a random name, sends a byte
1802  * contining its length, and its name.
1803  *
1804  * client reads the name, connects to it (using Win32 API).
1805  *
1806  * server waits for connection to the named pipe, then calls
1807  * ImpersonateNamedPipeClient(), notes its now-current credentials,
1808  * calls RevertToSelf(), closes its handles to the named pipe, and
1809  * is done. (Maybe there is some other way to get the SID of a named
1810  * pipe client without having to use impersonation?)
1811  *
1812  * client closes its handles and is done.
1813  *
1814  * Ralf: Why not sending credentials over the given this connection ?
1815  * Using named pipes makes it impossible to be connected from a unix client.
1816  *
1817  */
1818   int bytes_written;
1819   DBusString buf;
1820
1821   _dbus_string_init_const_len (&buf, "\0", 1);
1822 again:
1823   bytes_written = _dbus_write_socket (handle, &buf, 0, 1 );
1824
1825   if (bytes_written < 0 && errno == EINTR)
1826     goto again;
1827
1828   if (bytes_written < 0)
1829     {
1830       dbus_set_error (error, _dbus_error_from_errno (errno),
1831                       "Failed to write credentials byte: %s",
1832                      _dbus_strerror (errno));
1833       return FALSE;
1834     }
1835   else if (bytes_written == 0)
1836     {
1837       dbus_set_error (error, DBUS_ERROR_IO_ERROR,
1838                       "wrote zero bytes writing credentials byte");
1839       return FALSE;
1840     }
1841   else
1842     {
1843       _dbus_assert (bytes_written == 1);
1844       _dbus_verbose ("wrote 1 zero byte, credential sending isn't implemented yet\n");
1845       return TRUE;
1846     }
1847   return TRUE;
1848 }
1849
1850 /**
1851  * Reads a single byte which must be nul (an error occurs otherwise),
1852  * and reads unix credentials if available. Fills in pid/uid/gid with
1853  * -1 if no credentials are available. Return value indicates whether
1854  * a byte was read, not whether we got valid credentials. On some
1855  * systems, such as Linux, reading/writing the byte isn't actually
1856  * required, but we do it anyway just to avoid multiple codepaths.
1857  *
1858  * Fails if no byte is available, so you must select() first.
1859  *
1860  * The point of the byte is that on some systems we have to
1861  * use sendmsg()/recvmsg() to transmit credentials.
1862  *
1863  * @param client_fd the client file descriptor
1864  * @param credentials struct to fill with credentials of client
1865  * @param error location to store error code
1866  * @returns #TRUE on success
1867  */
1868 dbus_bool_t
1869 _dbus_read_credentials_socket  (int              handle,
1870                                 DBusCredentials *credentials,
1871                                 DBusError       *error)
1872 {
1873   int bytes_read = 0;
1874   DBusString buf;
1875
1876   // could fail due too OOM
1877   if (_dbus_string_init(&buf))
1878     {
1879       bytes_read = _dbus_read_socket(handle, &buf, 1 );
1880
1881       if (bytes_read > 0)
1882         _dbus_verbose("got one zero byte from server");
1883
1884       _dbus_string_free(&buf);
1885     }
1886
1887   _dbus_credentials_add_from_current_process (credentials);
1888   _dbus_verbose("FIXME: get faked credentials from current process");
1889
1890   return TRUE;
1891 }
1892
1893 /**
1894 * Checks to make sure the given directory is
1895 * private to the user
1896 *
1897 * @param dir the name of the directory
1898 * @param error error return
1899 * @returns #FALSE on failure
1900 **/
1901 dbus_bool_t
1902 _dbus_check_dir_is_private_to_user (DBusString *dir, DBusError *error)
1903 {
1904   const char *directory;
1905   struct stat sb;
1906
1907   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1908
1909   return TRUE;
1910 }
1911
1912
1913 /**
1914  * Appends the given filename to the given directory.
1915  *
1916  * @todo it might be cute to collapse multiple '/' such as "foo//"
1917  * concat "//bar"
1918  *
1919  * @param dir the directory name
1920  * @param next_component the filename
1921  * @returns #TRUE on success
1922  */
1923 dbus_bool_t
1924 _dbus_concat_dir_and_file (DBusString       *dir,
1925                            const DBusString *next_component)
1926 {
1927   dbus_bool_t dir_ends_in_slash;
1928   dbus_bool_t file_starts_with_slash;
1929
1930   if (_dbus_string_get_length (dir) == 0 ||
1931       _dbus_string_get_length (next_component) == 0)
1932     return TRUE;
1933
1934   dir_ends_in_slash =
1935     ('/' == _dbus_string_get_byte (dir, _dbus_string_get_length (dir) - 1) ||
1936      '\\' == _dbus_string_get_byte (dir, _dbus_string_get_length (dir) - 1));
1937
1938   file_starts_with_slash =
1939     ('/' == _dbus_string_get_byte (next_component, 0) ||
1940      '\\' == _dbus_string_get_byte (next_component, 0));
1941
1942   if (dir_ends_in_slash && file_starts_with_slash)
1943     {
1944       _dbus_string_shorten (dir, 1);
1945     }
1946   else if (!(dir_ends_in_slash || file_starts_with_slash))
1947     {
1948       if (!_dbus_string_append_byte (dir, '\\'))
1949         return FALSE;
1950     }
1951
1952   return _dbus_string_copy (next_component, 0, dir,
1953                             _dbus_string_get_length (dir));
1954 }
1955
1956 /*---------------- DBusCredentials ----------------------------------
1957
1958 /**
1959  * Adds the credentials corresponding to the given username.
1960  *
1961  * @param credentials credentials to fill in
1962  * @param username the username
1963  * @returns #TRUE if the username existed and we got some credentials
1964  */
1965 dbus_bool_t
1966 _dbus_credentials_add_from_user (DBusCredentials  *credentials,
1967                                      const DBusString *username)
1968 {
1969   return _dbus_credentials_add_windows_sid (credentials,
1970                     _dbus_string_get_const_data(username));
1971 }
1972
1973 /**
1974  * Adds the credentials of the current process to the
1975  * passed-in credentials object.
1976  *
1977  * @param credentials credentials to add to
1978  * @returns #FALSE if no memory; does not properly roll back on failure, so only some credentials may have been added
1979  */
1980
1981 dbus_bool_t
1982 _dbus_credentials_add_from_current_process (DBusCredentials *credentials)
1983 {
1984   dbus_bool_t retval = FALSE;
1985   char *sid = NULL;
1986
1987   if (!_dbus_getsid(&sid))
1988     goto failed;
1989
1990   if (!_dbus_credentials_add_unix_pid(credentials, _dbus_getpid()))
1991     goto failed;
1992
1993   if (!_dbus_credentials_add_windows_sid (credentials,sid))
1994     goto failed;
1995
1996   retval = TRUE;
1997   goto end;
1998 failed:
1999   retval = FALSE;
2000 end:
2001   if (sid)
2002     LocalFree(sid);
2003
2004   return retval;
2005 }
2006
2007 /**
2008  * Append to the string the identity we would like to have when we
2009  * authenticate, on UNIX this is the current process UID and on
2010  * Windows something else, probably a Windows SID string.  No escaping
2011  * is required, that is done in dbus-auth.c. The username here
2012  * need not be anything human-readable, it can be the machine-readable
2013  * form i.e. a user id.
2014  *
2015  * @param str the string to append to
2016  * @returns #FALSE on no memory
2017  * @todo to which class belongs this
2018  */
2019 dbus_bool_t
2020 _dbus_append_user_from_current_process (DBusString *str)
2021 {
2022   dbus_bool_t retval = FALSE;
2023   char *sid = NULL;
2024
2025   if (!_dbus_getsid(&sid))
2026     return FALSE;
2027
2028   retval = _dbus_string_append (str,sid);
2029
2030   LocalFree(sid);
2031   return retval;
2032 }
2033
2034 /**
2035  * Gets our process ID
2036  * @returns process ID
2037  */
2038 unsigned long
2039 _dbus_getpid (void)
2040 {
2041   return GetCurrentProcessId ();
2042 }
2043
2044 /** nanoseconds in a second */
2045 #define NANOSECONDS_PER_SECOND       1000000000
2046 /** microseconds in a second */
2047 #define MICROSECONDS_PER_SECOND      1000000
2048 /** milliseconds in a second */
2049 #define MILLISECONDS_PER_SECOND      1000
2050 /** nanoseconds in a millisecond */
2051 #define NANOSECONDS_PER_MILLISECOND  1000000
2052 /** microseconds in a millisecond */
2053 #define MICROSECONDS_PER_MILLISECOND 1000
2054
2055 /**
2056  * Sleeps the given number of milliseconds.
2057  * @param milliseconds number of milliseconds
2058  */
2059 void
2060 _dbus_sleep_milliseconds (int milliseconds)
2061 {
2062   Sleep (milliseconds);
2063 }
2064
2065
2066 /**
2067  * Get current time, as in gettimeofday().
2068  *
2069  * @param tv_sec return location for number of seconds
2070  * @param tv_usec return location for number of microseconds
2071  */
2072 void
2073 _dbus_get_current_time (long *tv_sec,
2074                         long *tv_usec)
2075 {
2076   FILETIME ft;
2077   dbus_uint64_t *time64 = (dbus_uint64_t *) &ft;
2078
2079   GetSystemTimeAsFileTime (&ft);
2080
2081   /* Convert from 100s of nanoseconds since 1601-01-01
2082   * to Unix epoch. Yes, this is Y2038 unsafe.
2083   */
2084   *time64 -= DBUS_INT64_CONSTANT (116444736000000000);
2085   *time64 /= 10;
2086
2087   if (tv_sec)
2088     *tv_sec = *time64 / 1000000;
2089
2090   if (tv_usec)
2091     *tv_usec = *time64 % 1000000;
2092 }
2093
2094
2095 /**
2096  * signal (SIGPIPE, SIG_IGN);
2097  */
2098 void
2099 _dbus_disable_sigpipe (void)
2100 {
2101     _dbus_verbose("FIXME: implement _dbus_disable_sigpipe (void)\n");
2102 }
2103
2104
2105 /**
2106  * Appends the contents of the given file to the string,
2107  * returning error code. At the moment, won't open a file
2108  * more than a megabyte in size.
2109  *
2110  * @param str the string to append to
2111  * @param filename filename to load
2112  * @param error place to set an error
2113  * @returns #FALSE if error was set
2114  */
2115 dbus_bool_t
2116 _dbus_file_get_contents (DBusString       *str,
2117                          const DBusString *filename,
2118                          DBusError        *error)
2119 {
2120   DBusFile file;
2121   struct stat sb;
2122   int orig_len;
2123   int total;
2124   const char *filename_c;
2125
2126   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2127
2128   filename_c = _dbus_string_get_const_data (filename);
2129
2130   /* O_BINARY useful on Cygwin and Win32 */
2131   if (!_dbus_file_open (&file, filename_c, O_RDONLY | O_BINARY, -1))
2132     {
2133       dbus_set_error (error, _dbus_error_from_errno (errno),
2134                       "Failed to open \"%s\": %s",
2135                       filename_c,
2136                       _dbus_strerror (errno));
2137       return FALSE;
2138     }
2139
2140   if (!_dbus_fstat (&file, &sb))
2141     {
2142       dbus_set_error (error, _dbus_error_from_errno (errno),
2143                       "Failed to stat \"%s\": %s",
2144                       filename_c,
2145                       _dbus_strerror (errno));
2146
2147       _dbus_verbose ("fstat() failed: %s",
2148                      _dbus_strerror (errno));
2149
2150       _dbus_file_close (&file, NULL);
2151
2152       return FALSE;
2153     }
2154
2155   if (sb.st_size > _DBUS_ONE_MEGABYTE)
2156     {
2157       dbus_set_error (error, DBUS_ERROR_FAILED,
2158                       "File size %lu of \"%s\" is too large.",
2159                       (unsigned long) sb.st_size, filename_c);
2160       _dbus_file_close (&file, NULL);
2161       return FALSE;
2162     }
2163
2164   total = 0;
2165   orig_len = _dbus_string_get_length (str);
2166   if (sb.st_size > 0 && S_ISREG (sb.st_mode))
2167     {
2168       int bytes_read;
2169
2170       while (total < (int) sb.st_size)
2171         {
2172           bytes_read = _dbus_file_read (&file, str,
2173                                         sb.st_size - total);
2174           if (bytes_read <= 0)
2175             {
2176               dbus_set_error (error, _dbus_error_from_errno (errno),
2177                               "Error reading \"%s\": %s",
2178                               filename_c,
2179                               _dbus_strerror (errno));
2180
2181               _dbus_verbose ("read() failed: %s",
2182                              _dbus_strerror (errno));
2183
2184               _dbus_file_close (&file, NULL);
2185               _dbus_string_set_length (str, orig_len);
2186               return FALSE;
2187             }
2188           else
2189             total += bytes_read;
2190         }
2191
2192       _dbus_file_close (&file, NULL);
2193       return TRUE;
2194     }
2195   else if (sb.st_size != 0)
2196     {
2197       _dbus_verbose ("Can only open regular files at the moment.\n");
2198       dbus_set_error (error, DBUS_ERROR_FAILED,
2199                       "\"%s\" is not a regular file",
2200                       filename_c);
2201       _dbus_file_close (&file, NULL);
2202       return FALSE;
2203     }
2204   else
2205     {
2206       _dbus_file_close (&file, NULL);
2207       return TRUE;
2208     }
2209 }
2210
2211 /**
2212  * Writes a string out to a file. If the file exists,
2213  * it will be atomically overwritten by the new data.
2214  *
2215  * @param str the string to write out
2216  * @param filename the file to save string to
2217  * @param error error to be filled in on failure
2218  * @returns #FALSE on failure
2219  */
2220 dbus_bool_t
2221 _dbus_string_save_to_file (const DBusString *str,
2222                            const DBusString *filename,
2223                            DBusError        *error)
2224 {
2225   DBusFile file;
2226   int bytes_to_write;
2227   const char *filename_c;
2228   DBusString tmp_filename;
2229   const char *tmp_filename_c;
2230   int total;
2231   dbus_bool_t need_unlink;
2232   dbus_bool_t retval;
2233
2234   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2235
2236   retval = FALSE;
2237   need_unlink = FALSE;
2238
2239   if (!_dbus_string_init (&tmp_filename))
2240     {
2241       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2242       return FALSE;
2243     }
2244
2245   if (!_dbus_string_copy (filename, 0, &tmp_filename, 0))
2246     {
2247       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2248       _dbus_string_free (&tmp_filename);
2249       return FALSE;
2250     }
2251
2252   if (!_dbus_string_append (&tmp_filename, "."))
2253     {
2254       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2255       _dbus_string_free (&tmp_filename);
2256       return FALSE;
2257     }
2258
2259 #define N_TMP_FILENAME_RANDOM_BYTES 8
2260   if (!_dbus_generate_random_ascii (&tmp_filename, N_TMP_FILENAME_RANDOM_BYTES))
2261     {
2262       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2263       _dbus_string_free (&tmp_filename);
2264       return FALSE;
2265     }
2266
2267   filename_c = _dbus_string_get_const_data (filename);
2268   tmp_filename_c = _dbus_string_get_const_data (&tmp_filename);
2269
2270   if (!_dbus_file_open (&file, tmp_filename_c, O_WRONLY | O_BINARY | O_EXCL | O_CREAT,
2271                         0600))
2272     {
2273       dbus_set_error (error, _dbus_error_from_errno (errno),
2274                       "Could not create %s: %s", tmp_filename_c,
2275                       _dbus_strerror (errno));
2276       goto out;
2277     }
2278
2279   need_unlink = TRUE;
2280
2281   total = 0;
2282   bytes_to_write = _dbus_string_get_length (str);
2283
2284   while (total < bytes_to_write)
2285     {
2286       int bytes_written;
2287
2288       bytes_written = _dbus_file_write (&file, str, total,
2289                                         bytes_to_write - total);
2290
2291       if (bytes_written <= 0)
2292         {
2293           dbus_set_error (error, _dbus_error_from_errno (errno),
2294                           "Could not write to %s: %s", tmp_filename_c,
2295                           _dbus_strerror (errno));
2296
2297           goto out;
2298         }
2299
2300       total += bytes_written;
2301     }
2302
2303   if (!_dbus_file_close (&file, NULL))
2304     {
2305       dbus_set_error (error, _dbus_error_from_errno (errno),
2306                       "Could not close file %s: %s",
2307                       tmp_filename_c, _dbus_strerror (errno));
2308
2309       goto out;
2310     }
2311
2312
2313   if ((unlink (filename_c) == -1 && errno != ENOENT) ||
2314        rename (tmp_filename_c, filename_c) < 0)
2315     {
2316       dbus_set_error (error, _dbus_error_from_errno (errno),
2317                       "Could not rename %s to %s: %s",
2318                       tmp_filename_c, filename_c,
2319                       _dbus_strerror (errno));
2320
2321       goto out;
2322     }
2323
2324   need_unlink = FALSE;
2325
2326   retval = TRUE;
2327
2328 out:
2329   /* close first, then unlink, to prevent ".nfs34234235" garbage
2330    * files
2331    */
2332
2333   if (_dbus_is_valid_file(&file))
2334     _dbus_file_close (&file, NULL);
2335
2336   if (need_unlink && unlink (tmp_filename_c) < 0)
2337     _dbus_verbose ("Failed to unlink temp file %s: %s\n",
2338                    tmp_filename_c, _dbus_strerror (errno));
2339
2340   _dbus_string_free (&tmp_filename);
2341
2342   if (!retval)
2343     _DBUS_ASSERT_ERROR_IS_SET (error);
2344
2345   return retval;
2346 }
2347
2348
2349 /** Creates the given file, failing if the file already exists.
2350  *
2351  * @param filename the filename
2352  * @param error error location
2353  * @returns #TRUE if we created the file and it didn't exist
2354  */
2355 dbus_bool_t
2356 _dbus_create_file_exclusively (const DBusString *filename,
2357                                DBusError        *error)
2358 {
2359   DBusFile file;
2360   const char *filename_c;
2361
2362   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2363
2364   filename_c = _dbus_string_get_const_data (filename);
2365
2366   if (!_dbus_file_open (&file, filename_c, O_WRONLY | O_BINARY | O_EXCL | O_CREAT,
2367                         0600))
2368     {
2369       dbus_set_error (error,
2370                       DBUS_ERROR_FAILED,
2371                       "Could not create file %s: %s\n",
2372                       filename_c,
2373                       _dbus_strerror (errno));
2374       return FALSE;
2375     }
2376
2377   if (!_dbus_file_close (&file, NULL))
2378     {
2379       dbus_set_error (error,
2380                       DBUS_ERROR_FAILED,
2381                       "Could not close file %s: %s\n",
2382                       filename_c,
2383                       _dbus_strerror (errno));
2384       return FALSE;
2385     }
2386
2387   return TRUE;
2388 }
2389
2390
2391 /**
2392  * Creates a directory; succeeds if the directory
2393  * is created or already existed.
2394  *
2395  * @param filename directory filename
2396  * @param error initialized error object
2397  * @returns #TRUE on success
2398  */
2399 dbus_bool_t
2400 _dbus_create_directory (const DBusString *filename,
2401                         DBusError        *error)
2402 {
2403   const char *filename_c;
2404
2405   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2406
2407   filename_c = _dbus_string_get_const_data (filename);
2408
2409   if (!CreateDirectory (filename_c, NULL))
2410     {
2411       if (GetLastError () == ERROR_ALREADY_EXISTS)
2412         return TRUE;
2413
2414       dbus_set_error (error, DBUS_ERROR_FAILED,
2415                       "Failed to create directory %s: %s\n",
2416                       filename_c, _dbus_strerror (errno));
2417       return FALSE;
2418     }
2419   else
2420     return TRUE;
2421 }
2422
2423
2424 static void
2425 pseudorandom_generate_random_bytes_buffer (char *buffer,
2426     int   n_bytes)
2427 {
2428   long tv_usec;
2429   int i;
2430
2431   /* fall back to pseudorandom */
2432   _dbus_verbose ("Falling back to pseudorandom for %d bytes\n",
2433                  n_bytes);
2434
2435   _dbus_get_current_time (NULL, &tv_usec);
2436   srand (tv_usec);
2437
2438   i = 0;
2439   while (i < n_bytes)
2440     {
2441       double r;
2442       unsigned int b;
2443
2444       r = rand ();
2445       b = (r / (double) RAND_MAX) * 255.0;
2446
2447       buffer[i] = b;
2448
2449       ++i;
2450     }
2451 }
2452
2453 static dbus_bool_t
2454 pseudorandom_generate_random_bytes (DBusString *str,
2455                                     int         n_bytes)
2456 {
2457   int old_len;
2458   char *p;
2459
2460   old_len = _dbus_string_get_length (str);
2461
2462   if (!_dbus_string_lengthen (str, n_bytes))
2463     return FALSE;
2464
2465   p = _dbus_string_get_data_len (str, old_len, n_bytes);
2466
2467   pseudorandom_generate_random_bytes_buffer (p, n_bytes);
2468
2469   return TRUE;
2470 }
2471
2472 /**
2473  * Gets the temporary files directory by inspecting the environment variables
2474  * TMPDIR, TMP, and TEMP in that order. If none of those are set "/tmp" is returned
2475  *
2476  * @returns location of temp directory
2477  */
2478 const char*
2479 _dbus_get_tmpdir(void)
2480 {
2481   static const char* tmpdir = NULL;
2482
2483   if (tmpdir == NULL)
2484     {
2485       if (tmpdir == NULL)
2486         tmpdir = getenv("TMP");
2487       if (tmpdir == NULL)
2488         tmpdir = getenv("TEMP");
2489       if (tmpdir == NULL)
2490         tmpdir = getenv("TMPDIR");
2491       if (tmpdir == NULL)
2492           tmpdir = "C:\\Temp";
2493     }
2494
2495   _dbus_assert(tmpdir != NULL);
2496
2497   return tmpdir;
2498 }
2499
2500
2501 /**
2502  * Deletes the given file.
2503  *
2504  * @param filename the filename
2505  * @param error error location
2506  *
2507  * @returns #TRUE if unlink() succeeded
2508  */
2509 dbus_bool_t
2510 _dbus_delete_file (const DBusString *filename,
2511                    DBusError        *error)
2512 {
2513   const char *filename_c;
2514
2515   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2516
2517   filename_c = _dbus_string_get_const_data (filename);
2518
2519   if (unlink (filename_c) < 0)
2520     {
2521       dbus_set_error (error, DBUS_ERROR_FAILED,
2522                       "Failed to delete file %s: %s\n",
2523                       filename_c, _dbus_strerror (errno));
2524       return FALSE;
2525     }
2526   else
2527     return TRUE;
2528 }
2529
2530 /**
2531  * Generates the given number of random bytes,
2532  * using the best mechanism we can come up with.
2533  *
2534  * @param str the string
2535  * @param n_bytes the number of random bytes to append to string
2536  * @returns #TRUE on success, #FALSE if no memory
2537  */
2538 dbus_bool_t
2539 _dbus_generate_random_bytes (DBusString *str,
2540                              int         n_bytes)
2541 {
2542   return pseudorandom_generate_random_bytes (str, n_bytes);
2543 }
2544
2545 #if !defined (DBUS_DISABLE_ASSERT) || defined(DBUS_BUILD_TESTS)
2546
2547 #ifdef _MSC_VER
2548 # ifdef BACKTRACES
2549 #  undef BACKTRACES
2550 # endif
2551 #else
2552 # define BACKTRACES
2553 #endif
2554
2555 #ifdef BACKTRACES
2556 /*
2557  * Backtrace Generator
2558  *
2559  * Copyright 2004 Eric Poech
2560  * Copyright 2004 Robert Shearman
2561  *
2562  * This library is free software; you can redistribute it and/or
2563  * modify it under the terms of the GNU Lesser General Public
2564  * License as published by the Free Software Foundation; either
2565  * version 2.1 of the License, or (at your option) any later version.
2566  *
2567  * This library is distributed in the hope that it will be useful,
2568  * but WITHOUT ANY WARRANTY; without even the implied warranty of
2569  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
2570  * Lesser General Public License for more details.
2571  *
2572  * You should have received a copy of the GNU Lesser General Public
2573  * License along with this library; if not, write to the Free Software
2574  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
2575  */
2576
2577 #include <winver.h>
2578 #include <imagehlp.h>
2579 #include <stdio.h>
2580
2581 #define DPRINTF _dbus_warn
2582
2583 #ifdef _MSC_VER
2584 #define BOOL int
2585
2586 #define __i386__
2587 #endif
2588
2589 //#define MAKE_FUNCPTR(f) static typeof(f) * p##f
2590
2591 //MAKE_FUNCPTR(StackWalk);
2592 //MAKE_FUNCPTR(SymGetModuleBase);
2593 //MAKE_FUNCPTR(SymFunctionTableAccess);
2594 //MAKE_FUNCPTR(SymInitialize);
2595 //MAKE_FUNCPTR(SymGetSymFromAddr);
2596 //MAKE_FUNCPTR(SymGetModuleInfo);
2597 static BOOL (WINAPI *pStackWalk)(
2598   DWORD MachineType,
2599   HANDLE hProcess,
2600   HANDLE hThread,
2601   LPSTACKFRAME StackFrame,
2602   PVOID ContextRecord,
2603   PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine,
2604   PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,
2605   PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,
2606   PTRANSLATE_ADDRESS_ROUTINE TranslateAddress
2607 );
2608 static DWORD (WINAPI *pSymGetModuleBase)(
2609   HANDLE hProcess,
2610   DWORD dwAddr
2611 );
2612 static PVOID  (WINAPI *pSymFunctionTableAccess)(
2613   HANDLE hProcess,
2614   DWORD AddrBase
2615 );
2616 static BOOL  (WINAPI *pSymInitialize)(
2617   HANDLE hProcess,
2618   PSTR UserSearchPath,
2619   BOOL fInvadeProcess
2620 );
2621 static BOOL  (WINAPI *pSymGetSymFromAddr)(
2622   HANDLE hProcess,
2623   DWORD Address,
2624   PDWORD Displacement,
2625   PIMAGEHLP_SYMBOL Symbol
2626 );
2627 static BOOL  (WINAPI *pSymGetModuleInfo)(
2628   HANDLE hProcess,
2629   DWORD dwAddr,
2630   PIMAGEHLP_MODULE ModuleInfo
2631 );
2632 static DWORD  (WINAPI *pSymSetOptions)(
2633   DWORD SymOptions
2634 );
2635
2636
2637 static BOOL init_backtrace()
2638 {
2639     HMODULE hmodDbgHelp = LoadLibraryA("dbghelp");
2640 /*
2641     #define GETFUNC(x) \
2642     p##x = (typeof(x)*)GetProcAddress(hmodDbgHelp, #x); \
2643     if (!p##x) \
2644     { \
2645         return FALSE; \
2646     }
2647     */
2648
2649
2650 //    GETFUNC(StackWalk);
2651 //    GETFUNC(SymGetModuleBase);
2652 //    GETFUNC(SymFunctionTableAccess);
2653 //    GETFUNC(SymInitialize);
2654 //    GETFUNC(SymGetSymFromAddr);
2655 //    GETFUNC(SymGetModuleInfo);
2656
2657 #define FUNC(x) #x
2658
2659       pStackWalk = (BOOL  (WINAPI *)(
2660 DWORD MachineType,
2661 HANDLE hProcess,
2662 HANDLE hThread,
2663 LPSTACKFRAME StackFrame,
2664 PVOID ContextRecord,
2665 PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine,
2666 PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,
2667 PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,
2668 PTRANSLATE_ADDRESS_ROUTINE TranslateAddress
2669 ))GetProcAddress (hmodDbgHelp, FUNC(StackWalk));
2670     pSymGetModuleBase=(DWORD  (WINAPI *)(
2671   HANDLE hProcess,
2672   DWORD dwAddr
2673 ))GetProcAddress (hmodDbgHelp, FUNC(SymGetModuleBase));
2674     pSymFunctionTableAccess=(PVOID  (WINAPI *)(
2675   HANDLE hProcess,
2676   DWORD AddrBase
2677 ))GetProcAddress (hmodDbgHelp, FUNC(SymFunctionTableAccess));
2678     pSymInitialize = (BOOL  (WINAPI *)(
2679   HANDLE hProcess,
2680   PSTR UserSearchPath,
2681   BOOL fInvadeProcess
2682 ))GetProcAddress (hmodDbgHelp, FUNC(SymInitialize));
2683     pSymGetSymFromAddr = (BOOL  (WINAPI *)(
2684   HANDLE hProcess,
2685   DWORD Address,
2686   PDWORD Displacement,
2687   PIMAGEHLP_SYMBOL Symbol
2688 ))GetProcAddress (hmodDbgHelp, FUNC(SymGetSymFromAddr));
2689     pSymGetModuleInfo = (BOOL  (WINAPI *)(
2690   HANDLE hProcess,
2691   DWORD dwAddr,
2692   PIMAGEHLP_MODULE ModuleInfo
2693 ))GetProcAddress (hmodDbgHelp, FUNC(SymGetModuleInfo));
2694 pSymSetOptions = (DWORD  (WINAPI *)(
2695 DWORD SymOptions
2696 ))GetProcAddress (hmodDbgHelp, FUNC(SymSetOptions));
2697
2698
2699     pSymSetOptions(SYMOPT_UNDNAME);
2700
2701     pSymInitialize(GetCurrentProcess(), NULL, TRUE);
2702
2703     return TRUE;
2704 }
2705
2706 static void dump_backtrace_for_thread(HANDLE hThread)
2707 {
2708     STACKFRAME sf;
2709     CONTEXT context;
2710     DWORD dwImageType;
2711
2712     if (!pStackWalk)
2713         if (!init_backtrace())
2714             return;
2715
2716     /* can't use this function for current thread as GetThreadContext
2717      * doesn't support getting context from current thread */
2718     if (hThread == GetCurrentThread())
2719         return;
2720
2721     DPRINTF("Backtrace:\n");
2722
2723     _DBUS_ZERO(context);
2724     context.ContextFlags = CONTEXT_FULL;
2725
2726     SuspendThread(hThread);
2727
2728     if (!GetThreadContext(hThread, &context))
2729     {
2730         DPRINTF("Couldn't get thread context (error %ld)\n", GetLastError());
2731         ResumeThread(hThread);
2732         return;
2733     }
2734
2735     _DBUS_ZERO(sf);
2736
2737 #ifdef __i386__
2738     sf.AddrFrame.Offset = context.Ebp;
2739     sf.AddrFrame.Mode = AddrModeFlat;
2740     sf.AddrPC.Offset = context.Eip;
2741     sf.AddrPC.Mode = AddrModeFlat;
2742     dwImageType = IMAGE_FILE_MACHINE_I386;
2743 #else
2744 # error You need to fill in the STACKFRAME structure for your architecture
2745 #endif
2746
2747     while (pStackWalk(dwImageType, GetCurrentProcess(),
2748                      hThread, &sf, &context, NULL, pSymFunctionTableAccess,
2749                      pSymGetModuleBase, NULL))
2750     {
2751         BYTE buffer[256];
2752         IMAGEHLP_SYMBOL * pSymbol = (IMAGEHLP_SYMBOL *)buffer;
2753         DWORD dwDisplacement;
2754
2755         pSymbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL);
2756         pSymbol->MaxNameLength = sizeof(buffer) - sizeof(IMAGEHLP_SYMBOL) + 1;
2757
2758         if (!pSymGetSymFromAddr(GetCurrentProcess(), sf.AddrPC.Offset,
2759                                 &dwDisplacement, pSymbol))
2760         {
2761             IMAGEHLP_MODULE ModuleInfo;
2762             ModuleInfo.SizeOfStruct = sizeof(ModuleInfo);
2763
2764             if (!pSymGetModuleInfo(GetCurrentProcess(), sf.AddrPC.Offset,
2765                                    &ModuleInfo))
2766                 DPRINTF("1\t%p\n", (void*)sf.AddrPC.Offset);
2767             else
2768                 DPRINTF("2\t%s+0x%lx\n", ModuleInfo.ImageName,
2769                     sf.AddrPC.Offset - ModuleInfo.BaseOfImage);
2770         }
2771         else if (dwDisplacement)
2772             DPRINTF("3\t%s+0x%lx\n", pSymbol->Name, dwDisplacement);
2773         else
2774             DPRINTF("4\t%s\n", pSymbol->Name);
2775     }
2776
2777     ResumeThread(hThread);
2778 }
2779
2780 static DWORD WINAPI dump_thread_proc(LPVOID lpParameter)
2781 {
2782     dump_backtrace_for_thread((HANDLE)lpParameter);
2783     return 0;
2784 }
2785
2786 /* cannot get valid context from current thread, so we have to execute
2787  * backtrace from another thread */
2788 static void dump_backtrace()
2789 {
2790     HANDLE hCurrentThread;
2791     HANDLE hThread;
2792     DWORD dwThreadId;
2793     DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
2794         GetCurrentProcess(), &hCurrentThread, 0, FALSE, DUPLICATE_SAME_ACCESS);
2795     hThread = CreateThread(NULL, 0, dump_thread_proc, (LPVOID)hCurrentThread,
2796         0, &dwThreadId);
2797     WaitForSingleObject(hThread, INFINITE);
2798     CloseHandle(hThread);
2799     CloseHandle(hCurrentThread);
2800 }
2801
2802 void _dbus_print_backtrace(void)
2803 {
2804   init_backtrace();
2805   dump_backtrace();
2806 }
2807 #else
2808 void _dbus_print_backtrace(void)
2809 {
2810   _dbus_verbose ("  D-Bus not compiled with backtrace support\n");
2811 }
2812 #endif
2813
2814 static dbus_uint32_t fromAscii(char ascii)
2815 {
2816     if(ascii >= '0' && ascii <= '9')
2817         return ascii - '0';
2818     if(ascii >= 'A' && ascii <= 'F')
2819         return ascii - 'A' + 10;
2820     if(ascii >= 'a' && ascii <= 'f')
2821         return ascii - 'a' + 10;
2822     return 0;
2823 }
2824
2825 dbus_bool_t _dbus_read_local_machine_uuid   (DBusGUID         *machine_id,
2826                                              dbus_bool_t       create_if_not_found,
2827                                              DBusError        *error)
2828 {
2829 #ifdef DBUS_WINCE
2830         return TRUE;
2831   // TODO
2832 #else
2833     HW_PROFILE_INFOA info;
2834     char *lpc = &info.szHwProfileGuid[0];
2835     dbus_uint32_t u;
2836
2837     //  the hw-profile guid lives long enough
2838     if(!GetCurrentHwProfileA(&info))
2839       {
2840         dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL); // FIXME
2841         return FALSE;
2842       }
2843
2844     // Form: {12340001-4980-1920-6788-123456789012}
2845     lpc++;
2846     // 12340001
2847     u = ((fromAscii(lpc[0]) <<  0) |
2848          (fromAscii(lpc[1]) <<  4) |
2849          (fromAscii(lpc[2]) <<  8) |
2850          (fromAscii(lpc[3]) << 12) |
2851          (fromAscii(lpc[4]) << 16) |
2852          (fromAscii(lpc[5]) << 20) |
2853          (fromAscii(lpc[6]) << 24) |
2854          (fromAscii(lpc[7]) << 28));
2855     machine_id->as_uint32s[0] = u;
2856
2857     lpc += 9;
2858     // 4980-1920
2859     u = ((fromAscii(lpc[0]) <<  0) |
2860          (fromAscii(lpc[1]) <<  4) |
2861          (fromAscii(lpc[2]) <<  8) |
2862          (fromAscii(lpc[3]) << 12) |
2863          (fromAscii(lpc[5]) << 16) |
2864          (fromAscii(lpc[6]) << 20) |
2865          (fromAscii(lpc[7]) << 24) |
2866          (fromAscii(lpc[8]) << 28));
2867     machine_id->as_uint32s[1] = u;
2868
2869     lpc += 10;
2870     // 6788-1234
2871     u = ((fromAscii(lpc[0]) <<  0) |
2872          (fromAscii(lpc[1]) <<  4) |
2873          (fromAscii(lpc[2]) <<  8) |
2874          (fromAscii(lpc[3]) << 12) |
2875          (fromAscii(lpc[5]) << 16) |
2876          (fromAscii(lpc[6]) << 20) |
2877          (fromAscii(lpc[7]) << 24) |
2878          (fromAscii(lpc[8]) << 28));
2879     machine_id->as_uint32s[2] = u;
2880
2881     lpc += 9;
2882     // 56789012
2883     u = ((fromAscii(lpc[0]) <<  0) |
2884          (fromAscii(lpc[1]) <<  4) |
2885          (fromAscii(lpc[2]) <<  8) |
2886          (fromAscii(lpc[3]) << 12) |
2887          (fromAscii(lpc[4]) << 16) |
2888          (fromAscii(lpc[5]) << 20) |
2889          (fromAscii(lpc[6]) << 24) |
2890          (fromAscii(lpc[7]) << 28));
2891     machine_id->as_uint32s[3] = u;
2892 #endif
2893     return TRUE;
2894 }
2895
2896 static
2897 HANDLE _dbus_global_lock (const char *mutexname)
2898 {
2899   HANDLE mutex;
2900   DWORD gotMutex;
2901
2902   mutex = CreateMutex( NULL, FALSE, mutexname );
2903   if( !mutex )
2904     {
2905       return FALSE;
2906     }
2907
2908    gotMutex = WaitForSingleObject( mutex, INFINITE );
2909    switch( gotMutex )
2910      {
2911        case WAIT_ABANDONED:
2912                ReleaseMutex (mutex);
2913                CloseHandle (mutex);
2914                return 0;
2915        case WAIT_FAILED:
2916        case WAIT_TIMEOUT:
2917                return 0;
2918      }
2919
2920    return mutex;
2921 }
2922
2923 static
2924 void _dbus_global_unlock (HANDLE mutex)
2925 {
2926   ReleaseMutex (mutex);
2927   CloseHandle (mutex);
2928 }
2929
2930 // for proper cleanup in dbus-daemon
2931 static HANDLE hDBusDaemonMutex = NULL;
2932 static HANDLE hDBusSharedMem = NULL;
2933 // sync _dbus_daemon_init, _dbus_daemon_uninit and _dbus_daemon_already_runs
2934 static const char *cUniqueDBusInitMutex = "UniqueDBusInitMutex";
2935 // sync _dbus_get_autolaunch_address
2936 static const char *cDBusAutolaunchMutex = "DBusAutolaunchMutex";
2937 // mutex to determine if dbus-daemon is already started (per user)
2938 static const char *cDBusDaemonMutex = "DBusDaemonMutex";
2939 // named shm for dbus adress info (per user)
2940 #ifdef _DEBUG
2941 static const char *cDBusDaemonAddressInfo = "DBusDaemonAddressInfoDebug";
2942 #else
2943 static const char *cDBusDaemonAddressInfo = "DBusDaemonAddressInfo";
2944 #endif
2945
2946 void
2947 _dbus_daemon_init(const char *host, dbus_uint32_t port)
2948 {
2949   HANDLE lock;
2950   char *adr = NULL;
2951   char szUserName[64];
2952   DWORD dwUserNameSize = sizeof(szUserName);
2953   char szDBusDaemonMutex[128];
2954   char szDBusDaemonAddressInfo[128];
2955   char szAddress[128];
2956   DWORD ret;
2957
2958   _dbus_assert(host);
2959   _dbus_assert(port);
2960
2961   _snprintf(szAddress, sizeof(szAddress) - 1, "tcp:host=%s,port=%d", host, port);
2962   ret = GetUserName(szUserName, &dwUserNameSize);
2963   _dbus_assert(ret != 0);
2964   _snprintf(szDBusDaemonMutex, sizeof(szDBusDaemonMutex) - 1, "%s:%s",
2965             cDBusDaemonMutex, szUserName);
2966   _snprintf(szDBusDaemonAddressInfo, sizeof(szDBusDaemonAddressInfo) - 1, "%s:%s",
2967             cDBusDaemonAddressInfo, szUserName);
2968
2969   // before _dbus_global_lock to keep correct lock/release order
2970   hDBusDaemonMutex = CreateMutex( NULL, FALSE, szDBusDaemonMutex );
2971   ret = WaitForSingleObject( hDBusDaemonMutex, 1000 );
2972   if ( ret != WAIT_OBJECT_0 ) {
2973     _dbus_warn("Could not lock mutex %s (return code %d). daemon already running?\n", szDBusDaemonMutex, ret );
2974     _dbus_assert( !"Could not lock mutex, daemon already running?" );
2975   }
2976
2977   // sync _dbus_daemon_init, _dbus_daemon_uninit and _dbus_daemon_already_runs
2978   lock = _dbus_global_lock( cUniqueDBusInitMutex );
2979
2980   // create shm
2981   hDBusSharedMem = CreateFileMapping( INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
2982                                       0, strlen( szAddress ) + 1, szDBusDaemonAddressInfo );
2983   _dbus_assert( hDBusSharedMem );
2984
2985   adr = MapViewOfFile( hDBusSharedMem, FILE_MAP_WRITE, 0, 0, 0 );
2986
2987   _dbus_assert( adr );
2988
2989   strcpy( adr, szAddress);
2990
2991   // cleanup
2992   UnmapViewOfFile( adr );
2993
2994   _dbus_global_unlock( lock );
2995 }
2996
2997 void
2998 _dbus_daemon_release()
2999 {
3000   HANDLE lock;
3001
3002   // sync _dbus_daemon_init, _dbus_daemon_uninit and _dbus_daemon_already_runs
3003   lock = _dbus_global_lock( cUniqueDBusInitMutex );
3004
3005   CloseHandle( hDBusSharedMem );
3006
3007   hDBusSharedMem = NULL;
3008
3009   ReleaseMutex( hDBusDaemonMutex );
3010
3011   CloseHandle( hDBusDaemonMutex );
3012
3013   hDBusDaemonMutex = NULL;
3014
3015   _dbus_global_unlock( lock );
3016 }
3017
3018 static dbus_bool_t
3019 _dbus_get_autolaunch_shm(DBusString *adress)
3020 {
3021   HANDLE sharedMem;
3022   char *adr;
3023   char szUserName[64];
3024   DWORD dwUserNameSize = sizeof(szUserName);
3025   char szDBusDaemonAddressInfo[128];
3026   int i;
3027
3028   if( !GetUserName(szUserName, &dwUserNameSize) )
3029       return FALSE;
3030   _snprintf(szDBusDaemonAddressInfo, sizeof(szDBusDaemonAddressInfo) - 1, "%s:%s",
3031             cDBusDaemonAddressInfo, szUserName);
3032
3033   // read shm
3034   for(i=0;i<20;++i) {
3035       // we know that dbus-daemon is available, so we wait until shm is available
3036       sharedMem = OpenFileMapping( FILE_MAP_READ, FALSE, szDBusDaemonAddressInfo );
3037       if( sharedMem == 0 )
3038           Sleep( 100 );
3039       if ( sharedMem != 0)
3040           break;
3041   }
3042
3043   if( sharedMem == 0 )
3044       return FALSE;
3045
3046   adr = MapViewOfFile( sharedMem, FILE_MAP_READ, 0, 0, 0 );
3047
3048   if( adr == 0 )
3049       return FALSE;
3050
3051   _dbus_string_init( adress );
3052
3053   _dbus_string_append( adress, adr );
3054
3055   // cleanup
3056   UnmapViewOfFile( adr );
3057
3058   CloseHandle( sharedMem );
3059
3060   return TRUE;
3061 }
3062
3063 static dbus_bool_t
3064 _dbus_daemon_already_runs (DBusString *adress)
3065 {
3066   HANDLE lock;
3067   HANDLE daemon;
3068   dbus_bool_t bRet = TRUE;
3069   char szUserName[64];
3070   DWORD dwUserNameSize = sizeof(szUserName);
3071   char szDBusDaemonMutex[128];
3072
3073   // sync _dbus_daemon_init, _dbus_daemon_uninit and _dbus_daemon_already_runs
3074   lock = _dbus_global_lock( cUniqueDBusInitMutex );
3075
3076   if( !GetUserName(szUserName, &dwUserNameSize) )
3077       return FALSE;
3078   _snprintf(szDBusDaemonMutex, sizeof(szDBusDaemonMutex) - 1, "%s:%s",
3079             cDBusDaemonMutex, szUserName);
3080
3081   // do checks
3082   daemon = CreateMutex( NULL, FALSE, szDBusDaemonMutex );
3083   if(WaitForSingleObject( daemon, 10 ) != WAIT_TIMEOUT)
3084     {
3085       ReleaseMutex (daemon);
3086       CloseHandle (daemon);
3087
3088       _dbus_global_unlock( lock );
3089       return FALSE;
3090     }
3091
3092   // read shm
3093   bRet = _dbus_get_autolaunch_shm( adress );
3094
3095   // cleanup
3096   CloseHandle ( daemon );
3097
3098   _dbus_global_unlock( lock );
3099
3100   return bRet;
3101 }
3102
3103 dbus_bool_t
3104 _dbus_get_autolaunch_address (DBusString *address,
3105                               DBusError *error)
3106 {
3107   HANDLE mutex;
3108   STARTUPINFOA si;
3109   PROCESS_INFORMATION pi;
3110   dbus_bool_t retval = FALSE;
3111   LPSTR lpFile;
3112   char dbus_exe_path[MAX_PATH];
3113   char dbus_args[MAX_PATH * 2];
3114 #ifdef _DEBUG
3115   const char * daemon_name = "dbus-daemond.exe";
3116 #else
3117   const char * daemon_name = "dbus-daemon.exe";
3118 #endif
3119
3120   mutex = _dbus_global_lock ( cDBusAutolaunchMutex );
3121
3122   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3123
3124   if (_dbus_daemon_already_runs(address))
3125     {
3126         _dbus_verbose("found already running dbus daemon\n");
3127         retval = TRUE;
3128         goto out;
3129     }
3130
3131   if (!SearchPathA(NULL, daemon_name, NULL, sizeof(dbus_exe_path), dbus_exe_path, &lpFile))
3132     {
3133       printf ("please add the path to %s to your PATH environment variable\n", daemon_name);
3134       printf ("or start the daemon manually\n\n");
3135       printf ("");
3136       goto out;
3137     }
3138
3139   // Create process
3140   ZeroMemory( &si, sizeof(si) );
3141   si.cb = sizeof(si);
3142   ZeroMemory( &pi, sizeof(pi) );
3143
3144   _snprintf(dbus_args, sizeof(dbus_args) - 1, "\"%s\" %s", dbus_exe_path,  " --session");
3145
3146 //  argv[i] = "--config-file=bus\\session.conf";
3147 //  printf("create process \"%s\" %s\n", dbus_exe_path, dbus_args);
3148   if(CreateProcessA(dbus_exe_path, dbus_args, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi))
3149     {
3150
3151       retval = _dbus_get_autolaunch_shm( address );
3152     }
3153
3154   if (retval == FALSE)
3155     dbus_set_error_const (error, DBUS_ERROR_FAILED, "Failed to launch dbus-daemon");
3156
3157 out:
3158   if (retval)
3159     _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3160   else
3161     _DBUS_ASSERT_ERROR_IS_SET (error);
3162
3163   _dbus_global_unlock (mutex);
3164
3165   return retval;
3166  }
3167
3168
3169 /** Makes the file readable by every user in the system.
3170  *
3171  * @param filename the filename
3172  * @param error error location
3173  * @returns #TRUE if the file's permissions could be changed.
3174  */
3175 dbus_bool_t
3176 _dbus_make_file_world_readable(const DBusString *filename,
3177                                DBusError *error)
3178 {
3179   // TODO
3180   return TRUE;
3181 }
3182
3183
3184 #define DBUS_STANDARD_SESSION_SERVICEDIR "/dbus-1/services"
3185 #define DBUS_STANDARD_SYSTEM_SERVICEDIR "/dbus-1/system-services"
3186
3187 /**
3188  * Returns the standard directories for a session bus to look for service
3189  * activation files
3190  *
3191  * On Windows this should be data directories:
3192  *
3193  * %CommonProgramFiles%/dbus
3194  *
3195  * and
3196  *
3197  * DBUS_DATADIR
3198  *
3199  * @param dirs the directory list we are returning
3200  * @returns #FALSE on OOM
3201  */
3202
3203 dbus_bool_t
3204 _dbus_get_standard_session_servicedirs (DBusList **dirs)
3205 {
3206   const char *common_progs;
3207   DBusString servicedir_path;
3208
3209   if (!_dbus_string_init (&servicedir_path))
3210     return FALSE;
3211
3212   if (!_dbus_string_append (&servicedir_path, DBUS_DATADIR _DBUS_PATH_SEPARATOR))
3213         goto oom;
3214
3215   common_progs = _dbus_getenv ("CommonProgramFiles");
3216
3217   if (common_progs != NULL)
3218     {
3219       if (!_dbus_string_append (&servicedir_path, common_progs))
3220         goto oom;
3221
3222       if (!_dbus_string_append (&servicedir_path, _DBUS_PATH_SEPARATOR))
3223         goto oom;
3224     }
3225
3226   if (!_dbus_split_paths_and_append (&servicedir_path,
3227                                DBUS_STANDARD_SESSION_SERVICEDIR,
3228                                dirs))
3229     goto oom;
3230
3231   _dbus_string_free (&servicedir_path);
3232   return TRUE;
3233
3234  oom:
3235   _dbus_string_free (&servicedir_path);
3236   return FALSE;
3237 }
3238
3239 /**
3240  * Returns the standard directories for a system bus to look for service
3241  * activation files
3242  *
3243  * On UNIX this should be the standard xdg freedesktop.org data directories:
3244  *
3245  * XDG_DATA_DIRS=${XDG_DATA_DIRS-/usr/local/share:/usr/share}
3246  *
3247  * and
3248  *
3249  * DBUS_DATADIR
3250  *
3251  * On Windows there is no system bus and this function can return nothing.
3252  *
3253  * @param dirs the directory list we are returning
3254  * @returns #FALSE on OOM
3255  */
3256
3257 dbus_bool_t
3258 _dbus_get_standard_system_servicedirs (DBusList **dirs)
3259 {
3260   *dirs = NULL;
3261   return TRUE;
3262 }
3263
3264 _DBUS_DEFINE_GLOBAL_LOCK (atomic);
3265
3266 /**
3267  * Atomically increments an integer
3268  *
3269  * @param atomic pointer to the integer to increment
3270  * @returns the value before incrementing
3271  *
3272  */
3273 dbus_int32_t
3274 _dbus_atomic_inc (DBusAtomic *atomic)
3275 {
3276   // +/- 1 is needed here!
3277   // no volatile argument with mingw
3278   return InterlockedIncrement (&atomic->value) - 1;
3279 }
3280
3281 /**
3282  * Atomically decrement an integer
3283  *
3284  * @param atomic pointer to the integer to decrement
3285  * @returns the value before decrementing
3286  *
3287  */
3288 dbus_int32_t
3289 _dbus_atomic_dec (DBusAtomic *atomic)
3290 {
3291   // +/- 1 is needed here!
3292   // no volatile argument with mingw
3293   return InterlockedDecrement (&atomic->value) + 1;
3294 }
3295
3296 #endif /* asserts or tests enabled */
3297
3298 /**
3299  * Called when the bus daemon is signaled to reload its configuration; any
3300  * caches should be nuked. Of course any caches that need explicit reload
3301  * are probably broken, but c'est la vie.
3302  *
3303  *
3304  */
3305 void
3306 _dbus_flush_caches (void)
3307 {
3308
3309 }
3310
3311 dbus_bool_t _dbus_windows_user_is_process_owner (const char *windows_sid)
3312 {
3313     return TRUE;
3314 }
3315
3316 /**
3317  * See if errno is EAGAIN or EWOULDBLOCK (this has to be done differently
3318  * for Winsock so is abstracted)
3319  *
3320  * @returns #TRUE if errno == EAGAIN or errno == EWOULDBLOCK
3321  */
3322 dbus_bool_t
3323 _dbus_get_is_errno_eagain_or_ewouldblock (void)
3324 {
3325   return errno == EAGAIN || errno == EWOULDBLOCK;
3326 }
3327
3328 /**
3329  * return the absolute path of the dbus installation
3330  *
3331  * @param s buffer for installation path
3332  * @param len length of buffer
3333  * @returns #FALSE on failure
3334  */
3335 dbus_bool_t
3336 _dbus_get_install_root(char *s, int len)
3337 {
3338   char *p = NULL;
3339   int ret = GetModuleFileName(NULL,s,len);
3340   if ( ret == 0
3341     || ret == len && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
3342     {
3343       *s = '\0';
3344       return FALSE;
3345     }
3346   else if ((p = strstr(s,"\\bin\\")))
3347     {
3348       *(p+1)= '\0';
3349       return TRUE;
3350     }
3351   else
3352     {
3353       *s = '\0';
3354       return FALSE;
3355     }
3356 }
3357
3358 /**
3359   find config file either from installation or build root according to
3360   the following path layout
3361     install-root/
3362       bin/dbus-daemon[d].exe
3363       etc/<config-file>.conf
3364
3365     build-root/
3366       bin/dbus-daemon[d].exe
3367       bus/<config-file>.conf
3368 */
3369 dbus_bool_t
3370 _dbus_get_config_file_name(DBusString *config_file, char *s)
3371 {
3372   char path[MAX_PATH*2];
3373   int path_size = sizeof(path);
3374   int len = 4 + strlen(s);
3375
3376   if (!_dbus_get_install_root(path,path_size))
3377     return FALSE;
3378
3379   if(len > sizeof(path)-2)
3380     return FALSE;
3381   strcat(path,"etc\\");
3382   strcat(path,s);
3383   if (_dbus_file_exists(path))
3384     {
3385       // find path from executable
3386       if (!_dbus_string_append (config_file, path))
3387         return FALSE;
3388     }
3389   else
3390     {
3391       if (!_dbus_get_install_root(path,path_size))
3392         return FALSE;
3393       if(len + strlen(path) > sizeof(path)-2)
3394         return FALSE;
3395       strcat(path,"bus\\");
3396       strcat(path,s);
3397
3398       if (_dbus_file_exists(path))
3399         {
3400           if (!_dbus_string_append (config_file, path))
3401             return FALSE;
3402         }
3403     }
3404   return TRUE;
3405 }
3406
3407 /**
3408  * Append the absolute path of the system.conf file
3409  * (there is no system bus on Windows so this can just
3410  * return FALSE and print a warning or something)
3411  *
3412  * @param str the string to append to
3413  * @returns #FALSE if no memory
3414  */
3415 dbus_bool_t
3416 _dbus_append_system_config_file (DBusString *str)
3417 {
3418   return _dbus_get_config_file_name(str, "system.conf");
3419 }
3420
3421 /**
3422  * Append the absolute path of the session.conf file.
3423  *
3424  * @param str the string to append to
3425  * @returns #FALSE if no memory
3426  */
3427 dbus_bool_t
3428 _dbus_append_session_config_file (DBusString *str)
3429 {
3430   return _dbus_get_config_file_name(str, "session.conf");
3431 }
3432
3433 /* See comment in dbus-sysdeps-unix.c */
3434 dbus_bool_t
3435 _dbus_lookup_session_address (dbus_bool_t *supported,
3436                               DBusString  *address,
3437                               DBusError   *error)
3438 {
3439   /* Probably fill this in with something based on COM? */
3440   *supported = FALSE;
3441   return TRUE;
3442 }
3443
3444 /**
3445  * Appends the directory in which a keyring for the given credentials
3446  * should be stored.  The credentials should have either a Windows or
3447  * UNIX user in them.  The directory should be an absolute path.
3448  *
3449  * On UNIX the directory is ~/.dbus-keyrings while on Windows it should probably
3450  * be something else, since the dotfile convention is not normal on Windows.
3451  *
3452  * @param directory string to append directory to
3453  * @param credentials credentials the directory should be for
3454  *
3455  * @returns #FALSE on no memory
3456  */
3457 dbus_bool_t
3458 _dbus_append_keyring_directory_for_credentials (DBusString      *directory,
3459                                                 DBusCredentials *credentials)
3460 {
3461   DBusString homedir;
3462   DBusString dotdir;
3463   dbus_uid_t uid;
3464   const char *homepath;
3465
3466   _dbus_assert (credentials != NULL);
3467   _dbus_assert (!_dbus_credentials_are_anonymous (credentials));
3468
3469   if (!_dbus_string_init (&homedir))
3470     return FALSE;
3471
3472   homepath = _dbus_getenv("HOMEPATH");
3473   if (homepath != NULL && *homepath != '\0')
3474     {
3475       _dbus_string_append(&homedir,homepath);
3476     }
3477
3478 #ifdef DBUS_BUILD_TESTS
3479   {
3480     const char *override;
3481
3482     override = _dbus_getenv ("DBUS_TEST_HOMEDIR");
3483     if (override != NULL && *override != '\0')
3484       {
3485         _dbus_string_set_length (&homedir, 0);
3486         if (!_dbus_string_append (&homedir, override))
3487           goto failed;
3488
3489         _dbus_verbose ("Using fake homedir for testing: %s\n",
3490                        _dbus_string_get_const_data (&homedir));
3491       }
3492     else
3493       {
3494         static dbus_bool_t already_warned = FALSE;
3495         if (!already_warned)
3496           {
3497             _dbus_warn ("Using your real home directory for testing, set DBUS_TEST_HOMEDIR to avoid\n");
3498             already_warned = TRUE;
3499           }
3500       }
3501   }
3502 #endif
3503
3504   _dbus_string_init_const (&dotdir, ".dbus-keyrings");
3505   if (!_dbus_concat_dir_and_file (&homedir,
3506                                   &dotdir))
3507     goto failed;
3508
3509   if (!_dbus_string_copy (&homedir, 0,
3510                           directory, _dbus_string_get_length (directory))) {
3511     goto failed;
3512   }
3513
3514   _dbus_string_free (&homedir);
3515   return TRUE;
3516
3517  failed:
3518   _dbus_string_free (&homedir);
3519   return FALSE;
3520 }
3521
3522 /** @} end of sysdeps-win */
3523 /* tests in dbus-sysdeps-util.c */
3524