32#define STRSAFE_NO_DEPRECATE 
   34#include "dbus-internals.h" 
   36#include "dbus-sysdeps.h" 
   37#include "dbus-threads.h" 
   38#include "dbus-protocol.h" 
   39#include "dbus-string.h" 
   40#include "dbus-sysdeps.h" 
   41#include "dbus-sysdeps-win.h" 
   42#include "dbus-protocol.h" 
   44#include "dbus-sockets-win.h" 
   46#include "dbus-nonce.h" 
   47#include "dbus-credentials.h" 
   57extern BOOL WINAPI ConvertStringSidToSidA (LPCSTR  StringSid, PSID *Sid);
 
   58extern BOOL WINAPI ConvertSidToStringSidA (PSID Sid, LPSTR *StringSid);
 
   82#ifndef PROCESS_QUERY_LIMITED_INFORMATION 
   84#define PROCESS_QUERY_LIMITED_INFORMATION (0x1000) 
   93_dbus_win_set_errno (
int err)
 
  102static BOOL is_winxp_sp3_or_lower (
void);
 
  108typedef MIB_TCPROW_OWNER_PID _MIB_TCPROW_EX;
 
  109typedef MIB_TCPTABLE_OWNER_PID MIB_TCPTABLE_EX;
 
  110typedef PMIB_TCPTABLE_OWNER_PID PMIB_TCPTABLE_EX;
 
  111typedef DWORD (WINAPI *ProcAllocateAndGetTcpExtTableFromStack)(PMIB_TCPTABLE_EX*,BOOL,HANDLE,DWORD,DWORD);
 
  116static ProcAllocateAndGetTcpExtTableFromStack lpfnAllocateAndGetTcpExTableFromStack = 
NULL;
 
  124load_ex_ip_helper_procedures(
void)
 
  126  HMODULE hModule = LoadLibrary (
"iphlpapi.dll");
 
  129      _dbus_verbose (
"could not load iphlpapi.dll\n");
 
  133  lpfnAllocateAndGetTcpExTableFromStack = (ProcAllocateAndGetTcpExtTableFromStack) (
void (*)(
void))GetProcAddress (hModule, 
"AllocateAndGetTcpExTableFromStack");
 
  134  if (lpfnAllocateAndGetTcpExTableFromStack == 
NULL)
 
  136      _dbus_verbose (
"could not find function AllocateAndGetTcpExTableFromStack in iphlpapi.dll\n");
 
  149get_pid_from_extended_tcp_table(
int peer_port)
 
  152  DWORD errorCode, size = 0, i;
 
  153  MIB_TCPTABLE_OWNER_PID *tcp_table;
 
  156       GetExtendedTcpTable (
NULL, &size, 
TRUE, AF_INET, TCP_TABLE_OWNER_PID_ALL, 0)) == ERROR_INSUFFICIENT_BUFFER)
 
  158      tcp_table = (MIB_TCPTABLE_OWNER_PID *) 
dbus_malloc (size);
 
  159      if (tcp_table == 
NULL)
 
  161          _dbus_verbose (
"Error allocating memory\n");
 
  167      _dbus_win_warn_win_error (
"unexpected error returned from GetExtendedTcpTable", errorCode);
 
  171  if ((errorCode = GetExtendedTcpTable (tcp_table, &size, 
TRUE, AF_INET, TCP_TABLE_OWNER_PID_ALL, 0)) != NO_ERROR)
 
  173      _dbus_verbose (
"Error fetching tcp table %d\n", (
int)errorCode);
 
  179  for (i = 0; i < tcp_table->dwNumEntries; i++)
 
  181      MIB_TCPROW_OWNER_PID *p = &tcp_table->table[i];
 
  182      int local_address = ntohl (p->dwLocalAddr);
 
  183      int local_port = ntohs (p->dwLocalPort);
 
  184      if (p->dwState == MIB_TCP_STATE_ESTAB
 
  185          && local_address == INADDR_LOOPBACK && local_port == peer_port)
 
  186         result = p->dwOwningPid;
 
  190  _dbus_verbose (
"got pid %lu\n", result);
 
  202get_pid_from_tcp_ex_table(
int peer_port)
 
  206  PMIB_TCPTABLE_EX tcp_table = 
NULL;
 
  208  if (!load_ex_ip_helper_procedures ())
 
  211        (
"Error not been able to load iphelper procedures\n");
 
  215  errorCode = lpfnAllocateAndGetTcpExTableFromStack (&tcp_table, 
TRUE, GetProcessHeap(), 0, 2);
 
  217  if (errorCode != NO_ERROR)
 
  220        (
"Error not been able to call AllocateAndGetTcpExTableFromStack()\n");
 
  225  for (i = 0; i < tcp_table->dwNumEntries; i++)
 
  227      _MIB_TCPROW_EX *p = &tcp_table->table[i];
 
  228      int local_port = ntohs (p->dwLocalPort);
 
  229      int local_address = ntohl (p->dwLocalAddr);
 
  230      if (local_address == INADDR_LOOPBACK && local_port == peer_port)
 
  232          result = p->dwOwningPid;
 
  237  HeapFree (GetProcessHeap(), 0, tcp_table);
 
  238  _dbus_verbose (
"got pid %lu\n", result);
 
  248_dbus_get_peer_pid_from_tcp_handle (
int handle)
 
  250  struct sockaddr_storage addr;
 
  251  socklen_t len = 
sizeof (addr);
 
  257  getpeername (handle, (
struct sockaddr *) &addr, &len);
 
  259  if (addr.ss_family == AF_INET)
 
  261      struct sockaddr_in *s = (
struct sockaddr_in *) &addr;
 
  262      peer_port = ntohs (s->sin_port);
 
  263      is_localhost = (ntohl (s->sin_addr.s_addr) == INADDR_LOOPBACK);
 
  265  else if (addr.ss_family == AF_INET6)
 
  267      _dbus_verbose (
"FIXME [61922]: IPV6 support not working on windows\n");
 
  278      _dbus_verbose (
"no idea what address family %d is\n", addr.ss_family);
 
  284      _dbus_verbose (
"could not fetch process id from remote process\n");
 
  291        (
"Error not been able to fetch tcp peer port from connection\n");
 
  295  _dbus_verbose (
"trying to get peer's pid\n");
 
  297  result = get_pid_from_extended_tcp_table (peer_port);
 
  300  result = get_pid_from_tcp_ex_table (peer_port);
 
  306_dbus_win_error_from_last_error (
void)
 
  308  switch (GetLastError())
 
  313    case ERROR_NO_MORE_FILES:
 
  314    case ERROR_TOO_MANY_OPEN_FILES:
 
  317    case ERROR_ACCESS_DENIED:
 
  318    case ERROR_CANNOT_MAKE:
 
  321    case ERROR_NOT_ENOUGH_MEMORY:
 
  324    case ERROR_FILE_EXISTS:
 
  327    case ERROR_FILE_NOT_FOUND:
 
  328    case ERROR_PATH_NOT_FOUND:
 
  338_dbus_win_error_string (
int error_number)
 
  342  FormatMessageA (FORMAT_MESSAGE_ALLOCATE_BUFFER |
 
  343                  FORMAT_MESSAGE_IGNORE_INSERTS |
 
  344                  FORMAT_MESSAGE_FROM_SYSTEM,
 
  345                  NULL, error_number, 0,
 
  346                  (LPSTR) &msg, 0, 
NULL);
 
  348  if (msg[strlen (msg) - 1] == 
'\n')
 
  349    msg[strlen (msg) - 1] = 
'\0';
 
  350  if (msg[strlen (msg) - 1] == 
'\r')
 
  351    msg[strlen (msg) - 1] = 
'\0';
 
  357_dbus_win_free_error_string (
char *
string)
 
  393  start = _dbus_string_get_length (buffer);
 
  397      _dbus_win_set_errno (ENOMEM);
 
  405  _dbus_verbose (
"recv: count=%d fd=%Iu\n", count, fd.sock);
 
  406  bytes_read = recv (fd.sock, data, count, 0);
 
  408  if (bytes_read == SOCKET_ERROR)
 
  410          DBUS_SOCKET_SET_ERRNO();
 
  411          _dbus_verbose (
"recv: failed: %s (%d)\n", _dbus_strerror (errno), errno);
 
  415          _dbus_verbose (
"recv: = %d\n", bytes_read);
 
 
  461  data = _dbus_string_get_const_data_len (buffer, start, len);
 
  465  _dbus_verbose (
"send: len=%d fd=%Iu\n", len, fd.sock);
 
  466  bytes_written = send (fd.sock, data, len, 0);
 
  468  if (bytes_written == SOCKET_ERROR)
 
  470      DBUS_SOCKET_SET_ERRNO();
 
  475      _dbus_verbose (
"send: = %d\n", bytes_written);
 
  477  if (bytes_written < 0 && errno == EINTR)
 
  481  if (bytes_written > 0)
 
  485  return bytes_written;
 
 
  501  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
  504  if (closesocket (fd->sock) == SOCKET_ERROR)
 
  506      DBUS_SOCKET_SET_ERRNO ();
 
  512                      "Could not close socket: socket=%Iu, , %s",
 
  514      _dbus_socket_invalidate (fd);
 
  517  _dbus_verbose (
"socket=%Iu, \n", fd->sock);
 
  519  _dbus_socket_invalidate (fd);
 
 
  531_dbus_win_handle_set_close_on_exec (HANDLE handle)
 
  533  if ( !SetHandleInformation( (HANDLE) handle,
 
  534                        HANDLE_FLAG_INHERIT | HANDLE_FLAG_PROTECT_FROM_CLOSE,
 
  537      _dbus_win_warn_win_error (
"Disabling socket handle inheritance failed:", GetLastError());
 
  554  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
  556  if (ioctlsocket (handle.sock, FIONBIO, &one) == SOCKET_ERROR)
 
  558      DBUS_SOCKET_SET_ERRNO ();
 
  560                      "Failed to set socket %Iu to nonblocking: %s",
 
 
  611  data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
 
  614    data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
 
  622  vectors[0].buf = (
char*) data1;
 
  623  vectors[0].len = len1;
 
  624  vectors[1].buf = (
char*) data2;
 
  625  vectors[1].len = len2;
 
  629  _dbus_verbose (
"WSASend: len1+2=%d+%d fd=%Iu\n", len1, len2, fd.sock);
 
  630  rc = WSASend (fd.sock,
 
  638  if (rc == SOCKET_ERROR)
 
  640      DBUS_SOCKET_SET_ERRNO ();
 
  642      bytes_written = (DWORD) -1;
 
  645    _dbus_verbose (
"WSASend: = %ld\n", bytes_written);
 
  647  if (bytes_written == (DWORD) -1 && errno == EINTR)
 
  650  return bytes_written;
 
 
  664_dbus_connect_named_pipe (
const char     *path,
 
  676_dbus_win_startup_winsock (
void)
 
  683  WORD wVersionRequested;
 
  693  wVersionRequested = MAKEWORD (2, 0);
 
  695  err = WSAStartup (wVersionRequested, &wsaData);
 
  707  if (LOBYTE (wsaData.wVersion) != 2 ||
 
  708      HIBYTE (wsaData.wVersion) != 0)
 
  747  bufsize = 
sizeof (buf);
 
  748  va_copy (args_copy, args);
 
  749  len = _vsnprintf (buf, bufsize - 1, format, args_copy);
 
  758      p = malloc (bufsize);
 
  763      va_copy (args_copy, args);
 
  764      len = _vsnprintf (p, bufsize - 1, format, args_copy);
 
 
  781_dbus_win_utf8_to_utf16 (
const char *str,
 
  796  n = MultiByteToWideChar (CP_UTF8, 0, str, -1, 
NULL, 0);
 
  800      _dbus_win_set_error_from_win_error (error, GetLastError ());
 
  808      _DBUS_SET_OOM (error);
 
  812  if (MultiByteToWideChar (CP_UTF8, 0, str, -1, retval, n) != n)
 
  830_dbus_win_utf16_to_utf8 (
const wchar_t *str,
 
  836  n = WideCharToMultiByte (CP_UTF8, 0, str, -1, 
NULL, 0, 
NULL, 
NULL);
 
  840      _dbus_win_set_error_from_win_error (error, GetLastError ());
 
  848      _DBUS_SET_OOM (error);
 
  852  if (WideCharToMultiByte (CP_UTF8, 0, str, -1, retval, n, 
NULL, 
NULL) != n)
 
  873_dbus_win_account_to_sid (
const wchar_t *waccount,
 
  878  DWORD sid_length, wdomain_length;
 
  886  if (!LookupAccountNameW (
NULL, waccount, 
NULL, &sid_length,
 
  887                           NULL, &wdomain_length, &use) &&
 
  888      GetLastError () != ERROR_INSUFFICIENT_BUFFER)
 
  890      _dbus_win_set_error_from_win_error (error, GetLastError ());
 
  897      _DBUS_SET_OOM (error);
 
  901  wdomain = 
dbus_new (
wchar_t, wdomain_length);
 
  904      _DBUS_SET_OOM (error);
 
  908  if (!LookupAccountNameW (
NULL, waccount, (PSID) *ppsid, &sid_length,
 
  909                           wdomain, &wdomain_length, &use))
 
  911      _dbus_win_set_error_from_win_error (error, GetLastError ());
 
  915  if (!IsValidSid ((PSID) *ppsid))
 
  953is_winxp_sp3_or_lower (
void)
 
  955   OSVERSIONINFOEX osvi;
 
  956   DWORDLONG dwlConditionMask = 0;
 
  957   int op=VER_LESS_EQUAL;
 
  961   ZeroMemory(&osvi, 
sizeof(OSVERSIONINFOEX));
 
  962   osvi.dwOSVersionInfoSize = 
sizeof(OSVERSIONINFOEX);
 
  963   osvi.dwMajorVersion = 5;
 
  964   osvi.dwMinorVersion = 1;
 
  965   osvi.wServicePackMajor = 3;
 
  966   osvi.wServicePackMinor = 0;
 
  970   VER_SET_CONDITION (dwlConditionMask, VER_MAJORVERSION, op);
 
  971   VER_SET_CONDITION (dwlConditionMask, VER_MINORVERSION, op);
 
  972   VER_SET_CONDITION (dwlConditionMask, VER_SERVICEPACKMAJOR, op);
 
  973   VER_SET_CONDITION (dwlConditionMask, VER_SERVICEPACKMINOR, op);
 
  977   return VerifyVersionInfo(
 
  979      VER_MAJORVERSION | VER_MINORVERSION |
 
  980      VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 
  990_dbus_getsid(
char **sid, 
dbus_pid_t process_id)
 
  992  HANDLE process_token = INVALID_HANDLE_VALUE;
 
  993  TOKEN_USER *token_user = 
NULL;
 
  998  HANDLE process_handle;
 
 1000    process_handle = GetCurrentProcess();
 
 1001  else if (is_winxp_sp3_or_lower())
 
 1002    process_handle = OpenProcess(PROCESS_QUERY_INFORMATION, 
FALSE, process_id);
 
 1004    process_handle = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 
FALSE, process_id);
 
 1006  if (!OpenProcessToken (process_handle, TOKEN_QUERY, &process_token))
 
 1008      _dbus_win_warn_win_error (
"OpenProcessToken failed", GetLastError ());
 
 1011  if ((!GetTokenInformation (process_token, TokenUser, 
NULL, 0, &n)
 
 1012            && GetLastError () != ERROR_INSUFFICIENT_BUFFER)
 
 1013           || (token_user = alloca (n)) == 
NULL 
 1014           || !GetTokenInformation (process_token, TokenUser, token_user, n, &n))
 
 1016      _dbus_win_warn_win_error (
"GetTokenInformation failed", GetLastError ());
 
 1019  psid = token_user->User.Sid;
 
 1020  if (!IsValidSid (psid))
 
 1022      _dbus_verbose(
"invalid sid\n");
 
 1025  if (!ConvertSidToStringSidA (psid, sid))
 
 1027      _dbus_verbose(
"invalid sid\n");
 
 1034  CloseHandle (process_handle);
 
 1035  if (process_token != INVALID_HANDLE_VALUE)
 
 1036    CloseHandle (process_token);
 
 1038  _dbus_verbose(
"_dbus_getsid() got '%s' and returns %d\n", *sid, retval);
 
 1067  SOCKET temp, socket1 = -1, socket2 = -1;
 
 1068  struct sockaddr_in saddr;
 
 1072  if (!_dbus_win_startup_winsock ())
 
 1074      _DBUS_SET_OOM (error);
 
 1078  temp = socket (AF_INET, SOCK_STREAM, 0);
 
 1079  if (temp == INVALID_SOCKET)
 
 1081      DBUS_SOCKET_SET_ERRNO ();
 
 1086  saddr.sin_family = AF_INET;
 
 1088  saddr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
 
 1090  if (bind (temp, (
struct sockaddr *)&saddr, 
sizeof (saddr)) == SOCKET_ERROR)
 
 1092      DBUS_SOCKET_SET_ERRNO ();
 
 1096  if (listen (temp, 1) == SOCKET_ERROR)
 
 1098      DBUS_SOCKET_SET_ERRNO ();
 
 1102  len = 
sizeof (saddr);
 
 1103  if (getsockname (temp, (
struct sockaddr *)&saddr, &len) == SOCKET_ERROR)
 
 1105      DBUS_SOCKET_SET_ERRNO ();
 
 1109  socket1 = socket (AF_INET, SOCK_STREAM, 0);
 
 1110  if (socket1 == INVALID_SOCKET)
 
 1112      DBUS_SOCKET_SET_ERRNO ();
 
 1116  if (connect (socket1, (
struct sockaddr  *)&saddr, len) == SOCKET_ERROR)
 
 1118      DBUS_SOCKET_SET_ERRNO ();
 
 1122  socket2 = accept (temp, (
struct sockaddr *) &saddr, &len);
 
 1123  if (socket2 == INVALID_SOCKET)
 
 1125      DBUS_SOCKET_SET_ERRNO ();
 
 1132      if (ioctlsocket (socket1, FIONBIO, &arg) == SOCKET_ERROR)
 
 1134          DBUS_SOCKET_SET_ERRNO ();
 
 1139      if (ioctlsocket (socket2, FIONBIO, &arg) == SOCKET_ERROR)
 
 1141          DBUS_SOCKET_SET_ERRNO ();
 
 1146  fd1->sock = socket1;
 
 1147  fd2->sock = socket2;
 
 1149  _dbus_verbose (
"full-duplex pipe %Iu:%Iu <-> %Iu:%Iu\n",
 
 1150                 fd1->sock, socket1, fd2->sock, socket2);
 
 1157  closesocket (socket2);
 
 1159  closesocket (socket1);
 
 1164                  "Could not setup socket pair: %s",
 
 
 1170#ifdef DBUS_ENABLE_VERBOSE_MODE 
 1172_dbus_dump_fd_events (
DBusPollFD *fds, 
int n_fds)
 
 1181  for (i = 0; i < n_fds; i++)
 
 1199  _dbus_verbose (
"%s\n", _dbus_string_get_const_data (&msg));
 
 1206#ifdef USE_CHRIS_IMPL 
 1208_dbus_dump_fd_revents (
DBusPollFD *fds, 
int n_fds)
 
 1217  for (i = 0; i < n_fds; i++)
 
 1236  _dbus_verbose (
"%s\n", _dbus_string_get_const_data (&msg));
 
 1244_dbus_dump_fdset (
DBusPollFD *fds, 
int n_fds, fd_set *read_set, fd_set *write_set, fd_set *err_set)
 
 1253  for (i = 0; i < n_fds; i++)
 
 1260      if (FD_ISSET (fdp->
fd.sock, read_set) &&
 
 1264      if (FD_ISSET (fdp->
fd.sock, write_set) &&
 
 1268      if (FD_ISSET (fdp->
fd.sock, err_set) &&
 
 1272  _dbus_verbose (
"%s\n", _dbus_string_get_const_data (&msg));
 
 1281#ifdef USE_CHRIS_IMPL 
 1293                   int         timeout_milliseconds)
 
 1299#define DBUS_STACK_WSAEVENTS 256 
 1300  WSAEVENT eventsOnStack[DBUS_STACK_WSAEVENTS];
 
 1301  WSAEVENT *pEvents = 
NULL;
 
 1302  if (n_fds > DBUS_STACK_WSAEVENTS)
 
 1303    pEvents = calloc(
sizeof(WSAEVENT), n_fds);
 
 1305    pEvents = eventsOnStack;
 
 1307  if (pEvents == 
NULL)
 
 1309     _dbus_win_set_errno (ENOMEM);
 
 1314#ifdef DBUS_ENABLE_VERBOSE_MODE 
 1315  _dbus_verbose (
"_dbus_poll: to=%d", timeout_milliseconds);
 
 1316  if (!_dbus_dump_fd_events (fds, n_fds))
 
 1318      _dbus_win_set_errno (ENOMEM);
 
 1324  for (i = 0; i < n_fds; i++)
 
 1325    pEvents[i] = WSA_INVALID_EVENT;
 
 1327  for (i = 0; i < n_fds; i++)
 
 1331      long lNetworkEvents = FD_OOB;
 
 1333      ev = WSACreateEvent();
 
 1336        lNetworkEvents |= FD_READ | FD_ACCEPT | FD_CLOSE;
 
 1339        lNetworkEvents |= FD_WRITE | FD_CONNECT;
 
 1341      WSAEventSelect (fdp->
fd.sock, ev, lNetworkEvents);
 
 1346  ready = WSAWaitForMultipleEvents (n_fds, pEvents, 
FALSE, timeout_milliseconds, 
FALSE);
 
 1348  if (ready == WSA_WAIT_FAILED)
 
 1350      DBUS_SOCKET_SET_ERRNO ();
 
 1351      if (errno != WSAEWOULDBLOCK)
 
 1355  else if (ready == WSA_WAIT_TIMEOUT)
 
 1357      _dbus_verbose (
"WSAWaitForMultipleEvents: WSA_WAIT_TIMEOUT\n");
 
 1360  else if (ready < (WSA_WAIT_EVENT_0 + n_fds))
 
 1362      for (i = 0; i < n_fds; i++)
 
 1365          WSANETWORKEVENTS ne;
 
 1369          WSAEnumNetworkEvents (fdp->
fd.sock, pEvents[i], &ne);
 
 1371          if (ne.lNetworkEvents & (FD_READ | FD_ACCEPT | FD_CLOSE))
 
 1374          if (ne.lNetworkEvents & (FD_WRITE | FD_CONNECT))
 
 1377          if (ne.lNetworkEvents & (FD_OOB))
 
 1380          if(ne.lNetworkEvents)
 
 1383          WSAEventSelect (fdp->
fd.sock, pEvents[i], 0);
 
 1385#ifdef DBUS_ENABLE_VERBOSE_MODE 
 1386      _dbus_verbose (
"_dbus_poll: to=%d", timeout_milliseconds);
 
 1387      if (!_dbus_dump_fd_revents (fds, n_fds))
 
 1389          _dbus_win_set_errno (ENOMEM);
 
 1397      _dbus_verbose (
"WSAWaitForMultipleEvents: failed for unknown reason!");
 
 1402  if (pEvents != 
NULL)
 
 1404      for (i = 0; i < n_fds; i++)
 
 1406          if (pEvents[i] != WSA_INVALID_EVENT)
 
 1407            WSACloseEvent (pEvents[i]);
 
 1409      if (n_fds > DBUS_STACK_WSAEVENTS)
 
 1427                   int         timeout_milliseconds)
 
 1429  fd_set read_set, write_set, err_set;
 
 1435  FD_ZERO (&read_set);
 
 1436  FD_ZERO (&write_set);
 
 1438#ifdef DBUS_ENABLE_VERBOSE_MODE 
 1439  _dbus_verbose(
"_dbus_poll: to=%d\n", timeout_milliseconds);
 
 1440  if (!_dbus_dump_fd_events (fds, n_fds))
 
 1444  for (i = 0; i < n_fds; i++)
 
 1449        FD_SET (fdp->
fd.sock, &read_set);
 
 1452        FD_SET (fdp->
fd.sock, &write_set);
 
 1454      FD_SET (fdp->
fd.sock, &err_set);
 
 1456      max_fd = MAX (max_fd, fdp->
fd.sock);
 
 1460  tv.tv_sec = timeout_milliseconds < 0 ? 1 : timeout_milliseconds / 1000;
 
 1461  tv.tv_usec = timeout_milliseconds < 0 ? 0 : (timeout_milliseconds % 1000) * 1000;
 
 1463  ready = select (max_fd + 1, &read_set, &write_set, &err_set, &tv);
 
 1465  if (DBUS_SOCKET_API_RETURNS_ERROR (ready))
 
 1467      DBUS_SOCKET_SET_ERRNO ();
 
 1468      if (errno != WSAEWOULDBLOCK)
 
 1471  else if (ready == 0)
 
 1472    _dbus_verbose (
"select: = 0\n");
 
 1476#ifdef DBUS_ENABLE_VERBOSE_MODE 
 1477        _dbus_verbose (
"select: to=%d\n", ready);
 
 1478        if (!_dbus_dump_fdset (fds, n_fds, &read_set, &write_set, &err_set))
 
 1480            _dbus_win_set_errno (ENOMEM);
 
 1484        for (i = 0; i < n_fds; i++)
 
 1490            if (FD_ISSET (fdp->
fd.sock, &read_set))
 
 1493            if (FD_ISSET (fdp->
fd.sock, &write_set))
 
 1496            if (FD_ISSET (fdp->
fd.sock, &err_set))
 
 1515            int         timeout_milliseconds)
 
 1517#ifdef USE_CHRIS_IMPL 
 1518  return _dbus_poll_events (fds, n_fds, timeout_milliseconds);
 
 1520  return _dbus_poll_select (fds, n_fds, timeout_milliseconds);
 
 
 1583  return _dbus_connect_tcp_socket_with_nonce (host, port, family, (
const char*)
NULL, error);
 
 
 1587_dbus_connect_tcp_socket_with_nonce (
const char     *host,
 
 1590                                     const char     *noncefile,
 
 1593  int saved_errno = 0;
 
 1597  struct addrinfo hints;
 
 1598  struct addrinfo *ai = 
NULL;
 
 1599  const struct addrinfo *tmp;
 
 1602  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 1604  if (!_dbus_win_startup_winsock ())
 
 1606      _DBUS_SET_OOM (error);
 
 1607      return _dbus_socket_get_invalid ();
 
 1613    hints.ai_family = AF_UNSPEC;
 
 1614  else if (!strcmp(family, 
"ipv4"))
 
 1615    hints.ai_family = AF_INET;
 
 1616  else if (!strcmp(family, 
"ipv6"))
 
 1617    hints.ai_family = AF_INET6;
 
 1622                      "Unknown address family %s", family);
 
 1623      return _dbus_socket_get_invalid ();
 
 1625  hints.ai_protocol = IPPROTO_TCP;
 
 1626  hints.ai_socktype = SOCK_STREAM;
 
 1628  hints.ai_flags = AI_ADDRCONFIG;
 
 1633  if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
 
 1637                      "Failed to lookup host/port: \"%s:%s\": %s (%d)",
 
 1638                      host, port, _dbus_strerror (res), res);
 
 1645      if ((fd.sock = socket (tmp->ai_family, SOCK_STREAM, 0)) == INVALID_SOCKET)
 
 1647          saved_errno = _dbus_get_low_level_socket_errno ();
 
 1650                          "Failed to open socket: %s",
 
 1651                          _dbus_strerror (saved_errno));
 
 1655      _DBUS_ASSERT_ERROR_IS_CLEAR(error);
 
 1657      if (connect (fd.sock, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) == SOCKET_ERROR)
 
 1659          saved_errno = _dbus_get_low_level_socket_errno ();
 
 1664          if (connect_error == 
NULL)
 
 1666              _DBUS_SET_OOM (error);
 
 1671          _dbus_set_error_with_inet_sockaddr (connect_error,
 
 1672                                              tmp->ai_addr, tmp->ai_addrlen,
 
 1673                                              "Failed to connect to socket",
 
 1680              _DBUS_SET_OOM (error);
 
 1691  if (!_dbus_socket_is_valid (fd))
 
 1693      _dbus_combine_tcp_errors (&connect_errors, 
"Failed to connect",
 
 1698  if (noncefile != 
NULL)
 
 1703      ret = _dbus_send_nonce (fd, &noncefileStr, error);
 
 1713  _dbus_win_handle_set_close_on_exec ((HANDLE) fd.sock);
 
 1754                         const char    **retfamily,
 
 1759  int nlisten_fd = 0, res, i, port_num = -1;
 
 1763  struct addrinfo hints;
 
 1764  struct addrinfo *ai, *tmp;
 
 1773        struct sockaddr Address;
 
 1774        struct sockaddr_in AddressIn;
 
 1775        struct sockaddr_in6 AddressIn6;
 
 1779  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 1781  if (!_dbus_win_startup_winsock ())
 
 1783      _DBUS_SET_OOM (error);
 
 1790    hints.ai_family = AF_UNSPEC;
 
 1791  else if (!strcmp(family, 
"ipv4"))
 
 1792    hints.ai_family = AF_INET;
 
 1793  else if (!strcmp(family, 
"ipv6"))
 
 1794    hints.ai_family = AF_INET6;
 
 1799                      "Unknown address family %s", family);
 
 1803  hints.ai_protocol = IPPROTO_TCP;
 
 1804  hints.ai_socktype = SOCK_STREAM;
 
 1806  hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
 
 1808  hints.ai_flags = AI_PASSIVE;
 
 1811 redo_lookup_with_port:
 
 1813  if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
 
 1817                      "Failed to lookup host/port: \"%s:%s\": %s (%d)",
 
 1818                      host ? host : 
"*", port, _dbus_strerror(res), res);
 
 1825      const int reuseaddr = 1, tcp_nodelay_on = 1;
 
 1826      DBusSocket fd = DBUS_SOCKET_INIT, *newlisten_fd;
 
 1828      if ((fd.sock = socket (tmp->ai_family, SOCK_STREAM, 0)) == INVALID_SOCKET)
 
 1830          saved_errno = _dbus_get_low_level_socket_errno ();
 
 1833                         "Failed to open socket: %s",
 
 1834                         _dbus_strerror (saved_errno));
 
 1838      _DBUS_ASSERT_ERROR_IS_CLEAR(error);
 
 1840      if (setsockopt (fd.sock, SOL_SOCKET, SO_REUSEADDR, (
const char *)&reuseaddr, 
sizeof(reuseaddr)) == SOCKET_ERROR)
 
 1842          saved_errno = _dbus_get_low_level_socket_errno ();
 
 1843          _dbus_warn (
"Failed to set socket option \"%s:%s\": %s",
 
 1844                      host ? host : 
"*", port, _dbus_strerror (saved_errno));
 
 1849      if (setsockopt (fd.sock, IPPROTO_TCP, TCP_NODELAY, (
const char *)&tcp_nodelay_on, sizeof (tcp_nodelay_on)) == SOCKET_ERROR)
 
 1851          saved_errno = _dbus_get_low_level_socket_errno ();
 
 1852          _dbus_warn (
"Failed to set TCP_NODELAY socket option \"%s:%s\": %s",
 
 1853                      host ? host : 
"*", port, _dbus_strerror (saved_errno));
 
 1856      if (bind (fd.sock, (
struct sockaddr *) tmp->ai_addr, tmp->ai_addrlen) == SOCKET_ERROR)
 
 1858          saved_errno = _dbus_get_low_level_socket_errno ();
 
 1859          closesocket (fd.sock);
 
 1881          if (bind_error == 
NULL)
 
 1883              _DBUS_SET_OOM (error);
 
 1888          _dbus_set_error_with_inet_sockaddr (bind_error, tmp->ai_addr, tmp->ai_addrlen,
 
 1889                                              "Failed to bind socket",
 
 1896              _DBUS_SET_OOM (error);
 
 1905      if (listen (fd.sock, 30 ) == SOCKET_ERROR)
 
 1907          saved_errno = _dbus_get_low_level_socket_errno ();
 
 1908          closesocket (fd.sock);
 
 1909          _dbus_set_error_with_inet_sockaddr (error, tmp->ai_addr, tmp->ai_addrlen,
 
 1910                                              "Failed to listen on socket",
 
 1918          closesocket (fd.sock);
 
 1920                          "Failed to allocate file handle array");
 
 1923      listen_fd = newlisten_fd;
 
 1924      listen_fd[nlisten_fd] = fd;
 
 1927      if (tmp->ai_addr->sa_family == AF_INET)
 
 1929      else if (tmp->ai_addr->sa_family == AF_INET6)
 
 1932      if (!_dbus_string_get_length(retport))
 
 1938          if (!port || !strcmp(port, 
"0"))
 
 1940              mysockaddr_gen addr;
 
 1941              socklen_t addrlen = 
sizeof(addr);
 
 1942              char portbuf[NI_MAXSERV];
 
 1944              if (getsockname (fd.sock, &addr.Address, &addrlen) == SOCKET_ERROR ||
 
 1945                (res = getnameinfo (&addr.Address, addrlen, 
NULL, 0,
 
 1946                                    portbuf, 
sizeof(portbuf),
 
 1947                                    NI_NUMERICSERV)) != 0)
 
 1949                  saved_errno = _dbus_get_low_level_socket_errno ();
 
 1951                                  "Failed to resolve port \"%s:%s\": %s",
 
 1952                                  host ? host : 
"*", port, _dbus_strerror (saved_errno));
 
 1962              port = _dbus_string_get_const_data(retport);
 
 1964              goto redo_lookup_with_port;
 
 1983      _dbus_combine_tcp_errors (&bind_errors, 
"Failed to bind", host, port, error);
 
 1987  if (have_ipv4 && !have_ipv6)
 
 1988    *retfamily = 
"ipv4";
 
 1989  else if (!have_ipv4 && have_ipv6)
 
 1990    *retfamily = 
"ipv6";
 
 1992  sscanf(_dbus_string_get_const_data(retport), 
"%d", &port_num);
 
 1994  for (i = 0 ; i < nlisten_fd ; i++)
 
 1996      _dbus_win_handle_set_close_on_exec ((HANDLE) listen_fd[i].sock);
 
 2017  for (i = 0 ; i < nlisten_fd ; i++)
 
 2018    closesocket (listen_fd[i].sock);
 
 
 2044  client_fd.sock = accept (listen_fd.sock, 
NULL, 
NULL);
 
 2046  if (!_dbus_socket_is_valid (client_fd))
 
 2048      DBUS_SOCKET_SET_ERRNO ();
 
 2053  _dbus_verbose (
"client fd %Iu accepted\n", client_fd.sock);
 
 
 2095  if (bytes_written < 0 && errno == EINTR)
 
 2098  if (bytes_written < 0)
 
 2101                      "Failed to write credentials byte: %s",
 
 2105  else if (bytes_written == 0)
 
 2108                      "wrote zero bytes writing credentials byte");
 
 2114      _dbus_verbose (
"wrote 1 zero byte, credential sending isn't implemented yet\n");
 
 
 2131  struct sockaddr_un saddr;
 
 2134  len = 
sizeof (saddr);
 
 2135  if (getsockname (s.sock, (
struct sockaddr *)&saddr, &len) == SOCKET_ERROR)
 
 2137      DBUS_SOCKET_SET_ERRNO ();
 
 2139                      "Failed to getsockname: %s",
 
 2144  return saddr.sun_family == AF_UNIX;
 
 2153_dbus_get_peer_pid_from_uds_handle (
int handle)
 
 2157  if (WSAIoctl (handle, SIO_AF_UNIX_GETPEERPID,
 
 2159                &pid, 
sizeof (pid), &drc,
 
 2162      _dbus_verbose (
"failed to get peer's pid\n");
 
 2209        _dbus_verbose (
"got one zero byte from server\n");
 
 2215  uds = _dbus_socket_is_af_unix (handle, error);
 
 2220    pid = _dbus_get_peer_pid_from_uds_handle (handle.sock);
 
 2223    pid = _dbus_get_peer_pid_from_tcp_handle (handle.sock);
 
 2229  if (_dbus_getsid (&sid, pid))
 
 
 2256  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 
 2278  if (_dbus_string_get_length (dir) == 0 ||
 
 2279      _dbus_string_get_length (next_component) == 0)
 
 2283    (
'/' == _dbus_string_get_byte (dir, _dbus_string_get_length (dir) - 1) ||
 
 2284     '\\' == _dbus_string_get_byte (dir, _dbus_string_get_length (dir) - 1));
 
 2286  file_starts_with_slash =
 
 2287    (
'/' == _dbus_string_get_byte (next_component, 0) ||
 
 2288     '\\' == _dbus_string_get_byte (next_component, 0));
 
 2290  if (dir_ends_in_slash && file_starts_with_slash)
 
 2294  else if (!(dir_ends_in_slash || file_starts_with_slash))
 
 2301                            _dbus_string_get_length (dir));
 
 
 2316                                 DBusCredentialsAddFlags  flags,
 
 2320                                          _dbus_string_get_const_data (username)))
 
 2322      _DBUS_SET_OOM (error);
 
 
 2397  return GetCurrentProcessId ();
 
 
 2410#define NANOSECONDS_PER_SECOND       1000000000 
 2412#define MICROSECONDS_PER_SECOND      1000000 
 2414#define MILLISECONDS_PER_SECOND      1000 
 2416#define NANOSECONDS_PER_MILLISECOND  1000000 
 2418#define MICROSECONDS_PER_MILLISECOND 1000 
 2427  Sleep (milliseconds);
 
 
 2445  GetSystemTimeAsFileTime (&ft);
 
 2447  memcpy (&time64, &ft, 
sizeof (time64));
 
 2456    *tv_sec = time64 / 1000000;
 
 2459    *tv_usec = time64 % 1000000;
 
 
 2497  const char *filename_c;
 
 2499  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 2501  filename_c = _dbus_string_get_const_data (filename);
 
 2503  if (!CreateDirectoryA (filename_c, 
NULL))
 
 2506                      "Failed to create directory %s: %s\n",
 
 
 2526  const char *filename_c;
 
 2528  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 2530  filename_c = _dbus_string_get_const_data (filename);
 
 2532  if (!CreateDirectoryA (filename_c, 
NULL))
 
 2534      if (GetLastError () == ERROR_ALREADY_EXISTS)
 
 2538                      "Failed to create directory %s: %s\n",
 
 
 2565  old_len = _dbus_string_get_length (str);
 
 2569      _DBUS_SET_OOM (error);
 
 2573  p = _dbus_string_get_udata_len (str, old_len, n_bytes);
 
 2575  if (!CryptAcquireContext (&hprov, 
NULL, 
NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
 
 2577      _DBUS_SET_OOM (error);
 
 2581  if (!CryptGenRandom (hprov, n_bytes, p))
 
 2583      _DBUS_SET_OOM (error);
 
 2584      CryptReleaseContext (hprov, 0);
 
 2588  CryptReleaseContext (hprov, 0);
 
 
 2602  static const char* tmpdir = 
NULL;
 
 2603  static char buf[1000];
 
 2610      unsigned char *last_slash;
 
 2611      unsigned char *p = (
unsigned char *)buf;
 
 2613      if (!GetTempPathA (
sizeof (buf), buf))
 
 2620      last_slash = _mbsrchr (p, 
'\\');
 
 2621      if (last_slash > p && last_slash[1] == 
'\0')
 
 2622        last_slash[0] = 
'\0';
 
 2623      last_slash = _mbsrchr (p, 
'/');
 
 2624      if (last_slash > p && last_slash[1] == 
'\0')
 
 2625        last_slash[0] = 
'\0';
 
 
 2650  const char *filename_c;
 
 2652  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 2654  filename_c = _dbus_string_get_const_data (filename);
 
 2656  if (DeleteFileA (filename_c) == 0)
 
 2659                      "Failed to delete file %s: %s\n",
 
 
 2669    if(ascii >= 
'0' && ascii <= 
'9')
 
 2671    if(ascii >= 
'A' && ascii <= 
'F')
 
 2672        return ascii - 
'A' + 10;
 
 2673    if(ascii >= 
'a' && ascii <= 
'f')
 
 2674        return ascii - 
'a' + 10;
 
 2686    HW_PROFILE_INFOA info;
 
 2687    char *lpc = &info.szHwProfileGuid[0];
 
 2691    if(!GetCurrentHwProfileA(&info))
 
 2700    u = ((fromAscii(lpc[0]) <<  0) |
 
 2701         (fromAscii(lpc[1]) <<  4) |
 
 2702         (fromAscii(lpc[2]) <<  8) |
 
 2703         (fromAscii(lpc[3]) << 12) |
 
 2704         (fromAscii(lpc[4]) << 16) |
 
 2705         (fromAscii(lpc[5]) << 20) |
 
 2706         (fromAscii(lpc[6]) << 24) |
 
 2707         (fromAscii(lpc[7]) << 28));
 
 2712    u = ((fromAscii(lpc[0]) <<  0) |
 
 2713         (fromAscii(lpc[1]) <<  4) |
 
 2714         (fromAscii(lpc[2]) <<  8) |
 
 2715         (fromAscii(lpc[3]) << 12) |
 
 2716         (fromAscii(lpc[5]) << 16) |
 
 2717         (fromAscii(lpc[6]) << 20) |
 
 2718         (fromAscii(lpc[7]) << 24) |
 
 2719         (fromAscii(lpc[8]) << 28));
 
 2724    u = ((fromAscii(lpc[0]) <<  0) |
 
 2725         (fromAscii(lpc[1]) <<  4) |
 
 2726         (fromAscii(lpc[2]) <<  8) |
 
 2727         (fromAscii(lpc[3]) << 12) |
 
 2728         (fromAscii(lpc[5]) << 16) |
 
 2729         (fromAscii(lpc[6]) << 20) |
 
 2730         (fromAscii(lpc[7]) << 24) |
 
 2731         (fromAscii(lpc[8]) << 28));
 
 2736    u = ((fromAscii(lpc[0]) <<  0) |
 
 2737         (fromAscii(lpc[1]) <<  4) |
 
 2738         (fromAscii(lpc[2]) <<  8) |
 
 2739         (fromAscii(lpc[3]) << 12) |
 
 2740         (fromAscii(lpc[4]) << 16) |
 
 2741         (fromAscii(lpc[5]) << 20) |
 
 2742         (fromAscii(lpc[6]) << 24) |
 
 2743         (fromAscii(lpc[7]) << 28));
 
 
 2750static HANDLE hDBusDaemonMutex = 
NULL;
 
 2751static HANDLE hDBusSharedMem = 
NULL;
 
 2753static const char *cUniqueDBusInitMutex = 
"UniqueDBusInitMutex";
 
 2755static const char *cDBusAutolaunchMutex = 
"DBusAutolaunchMutex";
 
 2757static const char *cDBusDaemonMutex = 
"DBusDaemonMutex";
 
 2759static const char *cDBusDaemonAddressInfo = 
"DBusDaemonAddressInfo";
 
 2762static const char *autolaunch_custom_command_line_parameter = 
NULL;
 
 2776void _dbus_test_win_autolaunch_set_command_line_parameter (
const char *path)
 
 2778  autolaunch_custom_command_line_parameter = path;
 
 2781static HANDLE *autolaunch_handle_location;
 
 2794_dbus_test_win_set_autolaunch_handle_location (HANDLE *location)
 
 2796  autolaunch_handle_location = location;
 
 2810_dbus_get_install_root_as_hash (
DBusString *out)
 
 2819  if (!_dbus_get_install_root (&install_path))
 
 2823  if (_dbus_string_get_length (&install_path) == 0)
 
 2861_dbus_get_address_string (
DBusString *out, 
const char *basestring, 
const char *scope)
 
 2865  if (!scope || strlen (scope) == 0)
 
 2869  else if (strcmp (scope, 
"*install-path") == 0
 
 2871        || strcmp (scope, 
"install-path") == 0)
 
 2879      if (!_dbus_get_install_root_as_hash (&temp))
 
 2882      if (_dbus_string_get_length (&temp) == 0)
 
 2897  else if (strcmp (scope, 
"*user") == 0)
 
 2926_dbus_get_shm_name (
DBusString *out,
const char *scope)
 
 2928  return _dbus_get_address_string (out, cDBusDaemonAddressInfo, scope);
 
 2941_dbus_get_mutex_name (
DBusString *out, 
const char *scope)
 
 2943  return _dbus_get_address_string (out, cDBusDaemonMutex, scope);
 
 2947_dbus_daemon_is_session_bus_address_published (
const char *scope)
 
 2955  _dbus_verbose (
"scope:%s\n", scope);
 
 2956  if (!_dbus_get_mutex_name (&mutex_name, scope) ||
 
 2958      _dbus_string_get_length (&mutex_name) == 0)
 
 2964  if (hDBusDaemonMutex)
 
 2966      _dbus_verbose (
"(scope:%s) -> yes\n", scope);
 
 2969  lock = _dbus_win_rmutex_named_new (cUniqueDBusInitMutex);
 
 2974  _dbus_platform_rmutex_lock (lock);
 
 2978  hDBusDaemonMutex = CreateMutexA (
NULL, 
FALSE, _dbus_string_get_const_data(&mutex_name));
 
 2984  _dbus_platform_rmutex_unlock (lock);
 
 2985  _dbus_platform_rmutex_free (lock);
 
 2989  if (hDBusDaemonMutex  == 
NULL)
 
 2991      _dbus_verbose (
"(scope:%s) -> no\n", scope);
 
 2994  if (GetLastError() == ERROR_ALREADY_EXISTS)
 
 2996      CloseHandle(hDBusDaemonMutex);
 
 2997      hDBusDaemonMutex = 
NULL;
 
 2998      _dbus_verbose (
"(scope:%s) -> yes\n", scope);
 
 3004  _dbus_verbose (
"(scope:%s) -> no\n", scope);
 
 3009_dbus_daemon_publish_session_bus_address (
const char* address, 
const char *scope)
 
 3012  char *shared_addr = 
NULL;
 
 3013  DBusString shm_name  = _DBUS_STRING_INIT_INVALID;
 
 3023  _dbus_verbose (
"address:%s scope:%s\n", address, scope);
 
 3024  if (!_dbus_get_mutex_name (&mutex_name, scope) ||
 
 3026      _dbus_string_get_length (&mutex_name) == 0)
 
 3033  lock = _dbus_win_rmutex_named_new (cUniqueDBusInitMutex);
 
 3040  _dbus_platform_rmutex_lock (lock);
 
 3042  if (!hDBusDaemonMutex)
 
 3044      hDBusDaemonMutex = CreateMutexA (
NULL, 
FALSE, _dbus_string_get_const_data(&mutex_name));
 
 3049  if (WaitForSingleObject (hDBusDaemonMutex, 10) != WAIT_OBJECT_0)
 
 3051      CloseHandle (hDBusDaemonMutex);
 
 3060  if (!_dbus_get_shm_name (&shm_name, scope) ||
 
 3062      _dbus_string_get_length (&shm_name) == 0)
 
 3068  len = strlen (address) + 1;
 
 3070  hDBusSharedMem = CreateFileMappingA ( INVALID_HANDLE_VALUE, 
NULL, PAGE_READWRITE,
 
 3071                                       len >> 32, len & 0xffffffffu,
 
 3072                                       _dbus_string_get_const_data (&shm_name) );
 
 3075  shared_addr = MapViewOfFile (hDBusSharedMem, FILE_MAP_WRITE, 0, 0, 0);
 
 3079  strcpy(shared_addr, address);
 
 3082  UnmapViewOfFile (shared_addr);
 
 3084  _dbus_verbose (
"published session bus address at %s\n",_dbus_string_get_const_data (&shm_name));
 
 3088  _dbus_platform_rmutex_unlock (lock);
 
 3089  _dbus_platform_rmutex_free (lock);
 
 3116  _dbus_verbose (
"\n");
 
 3118  lock = _dbus_win_rmutex_named_new (cUniqueDBusInitMutex);
 
 3122  _dbus_platform_rmutex_lock (lock);
 
 3124  CloseHandle (hDBusSharedMem);
 
 3126  hDBusSharedMem = 
NULL;
 
 3128  ReleaseMutex (hDBusDaemonMutex);
 
 3130  CloseHandle (hDBusDaemonMutex);
 
 3132  hDBusDaemonMutex = 
NULL;
 
 3134  _dbus_platform_rmutex_unlock (lock);
 
 3135  _dbus_platform_rmutex_free (lock);
 
 
 3151  HANDLE sharedMem = 
NULL;
 
 3161  for (i = 0; i < max; ++i)
 
 3164      sharedMem = OpenFileMappingA (FILE_MAP_READ, 
FALSE, _dbus_string_get_const_data (shm_name));
 
 3174  shared_addr = MapViewOfFile (sharedMem, FILE_MAP_READ, 0, 0, 0);
 
 3181  UnmapViewOfFile (shared_addr);
 
 3184  CloseHandle (sharedMem);
 
 3199  if (!_dbus_get_mutex_name (&mutex_name, scope) ||
 
 3201      _dbus_string_get_length (&mutex_name) == 0)
 
 3208  lock = _dbus_win_rmutex_named_new (cUniqueDBusInitMutex);
 
 3212  _dbus_platform_rmutex_lock (lock);
 
 3215  daemon = CreateMutexA (
NULL, 
FALSE, _dbus_string_get_const_data (&mutex_name));
 
 3216  if (WaitForSingleObject (daemon, 10) != WAIT_TIMEOUT)
 
 3218      ReleaseMutex (daemon);
 
 3219      CloseHandle (daemon);
 
 3224  retval = _dbus_get_autolaunch_shm (address, shm_name, 
TRUE);
 
 3227  CloseHandle (daemon);
 
 3230  _dbus_platform_rmutex_unlock (lock);
 
 3231  _dbus_platform_rmutex_free (lock);
 
 3244  PROCESS_INFORMATION pi;
 
 3247  char dbus_exe_path[MAX_PATH];
 
 3248  DBusString dbus_args = _DBUS_STRING_INIT_INVALID;
 
 3249  const char *daemon_name = DBUS_DAEMON_NAME 
".exe";
 
 3251  HANDLE ready_event_handle = 
NULL;
 
 3253  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 3257      _DBUS_SET_OOM (error);
 
 3261  if (!_dbus_get_shm_name (&shm_name, scope) ||
 
 3263      _dbus_string_get_length (&shm_name) == 0)
 
 3269  lock = _dbus_win_rmutex_named_new (cDBusAutolaunchMutex);
 
 3277  _dbus_platform_rmutex_lock (lock);
 
 3279  if (_dbus_daemon_already_runs (address, &shm_name, scope))
 
 3281      _dbus_verbose (
"found running dbus daemon for scope '%s' at %s\n",
 
 3282                     scope ? scope : 
"", _dbus_string_get_const_data (&shm_name));
 
 3287  if (!SearchPathA (
NULL, daemon_name, 
NULL, 
sizeof (dbus_exe_path), dbus_exe_path, &lpFile))
 
 3291      char dbus_module_path[MAX_PATH];
 
 3294      _dbus_verbose (
"did not found dbus daemon executable on default search path, " 
 3295                     "trying path where dbus shared library is located");
 
 3297      hmod = _dbus_win_get_dll_hmodule ();
 
 3298      rc = GetModuleFileNameA (hmod, dbus_module_path, 
sizeof (dbus_module_path));
 
 3307          char *ext_idx = strrchr (dbus_module_path, 
'\\');
 
 3310          if (!SearchPathA (dbus_module_path, daemon_name, 
NULL, 
sizeof (dbus_exe_path), dbus_exe_path, &lpFile))
 
 3313                              "Could not find dbus-daemon executable. " 
 3314                              "Please add the path to %s to your PATH " 
 3315                              "environment variable or start the daemon manually",
 
 3320          _dbus_verbose (
"found dbus daemon executable at %s", dbus_module_path);
 
 3325  ZeroMemory (&si, 
sizeof (si));
 
 3326  si.cb = 
sizeof (si);
 
 3327  ZeroMemory (&pi, 
sizeof (pi));
 
 3337                                   autolaunch_custom_command_line_parameter ? autolaunch_custom_command_line_parameter : 
"--session"))
 
 3339      _DBUS_SET_OOM (error);
 
 3344  ready_event_handle = _dbus_win_event_create_inheritable (error);
 
 3345  if (ready_event_handle == 
NULL)
 
 3348  _dbus_verbose (
"Creating connection readiness event: handle=%p\n", ready_event_handle);
 
 3351      _DBUS_SET_OOM (error);
 
 3355  _dbus_verbose (
"Starting dbus daemon with args: '%s'\n", _dbus_string_get_const_data (&dbus_args));
 
 3356  if (CreateProcessA (dbus_exe_path, _dbus_string_get_data (&dbus_args), 
NULL, 
NULL, 
TRUE, CREATE_NO_WINDOW, 
NULL, 
NULL, &si, &pi))
 
 3361      CloseHandle (pi.hThread);
 
 3363      _dbus_verbose (
"Wait until dbus-daemon is ready for connections (event handle %p)\n", ready_event_handle);
 
 3365      events[0] = ready_event_handle;
 
 3366      events[1] = pi.hProcess;
 
 3367      status = WaitForMultipleObjects (2, events, 
FALSE, 30000);
 
 3376        case WAIT_OBJECT_0 + 1:
 
 3382          _dbus_win_set_error_from_last_error (error, 
"Unable to wait for server readiness (handle %p)", ready_event_handle);
 
 3395      _dbus_verbose (
"Got signal that dbus-daemon with process id '%ld' is ready for connections\n", GetProcessId (pi.hProcess));
 
 3397      if (autolaunch_handle_location != 
NULL)
 
 3399          *autolaunch_handle_location = pi.hProcess;
 
 3400          _dbus_verbose (
"Returning process handle of started server (handle=%p)\n", pi.hProcess);
 
 3404          CloseHandle (pi.hProcess);
 
 3408      retval = _dbus_get_autolaunch_shm (address, &shm_name, 
FALSE);
 
 3409      if (retval == 
FALSE)
 
 3419  _DBUS_ASSERT_ERROR_XOR_BOOL (error, retval);
 
 3420  _dbus_platform_rmutex_unlock (lock);
 
 3421  _dbus_platform_rmutex_free (lock);
 
 3424  if (ready_event_handle)
 
 3425    _dbus_win_event_free (ready_event_handle, 
NULL);
 
 3427  _DBUS_ASSERT_ERROR_XOR_BOOL (error, retval);
 
 
 3455#ifdef HAVE_STDATOMIC_H 
 3457  return atomic_fetch_add (&atomic->
value, 1);
 
 3460  return InterlockedIncrement (&atomic->
value) - 1;
 
 
 3474#ifdef HAVE_STDATOMIC_H 
 3476  return atomic_fetch_sub (&atomic->
value, 1);
 
 3479  return InterlockedDecrement (&atomic->
value) + 1;
 
 
 3493#ifdef HAVE_STDATOMIC_H 
 3495  return atomic_load (&atomic->
value);
 
 3507  InterlockedExchange (&dummy, 1);
 
 3509  return atomic->
value;
 
 
 3521#ifdef HAVE_STDATOMIC_H 
 3523  atomic_store (&atomic->
value, 0);
 
 3525  InterlockedExchange (&atomic->
value, 0);
 
 
 3537#ifdef HAVE_STDATOMIC_H 
 3539  atomic_store (&atomic->
value, 1);
 
 3541  InterlockedExchange (&atomic->
value, 1);
 
 
 3566  return e == WSAEWOULDBLOCK;
 
 
 3580    DWORD pathLength = MAX_PATH;
 
 3581    unsigned char *lastSlash;
 
 3582    unsigned char *prefix;
 
 3594        pathLength = GetModuleFileNameA (_dbus_win_get_dll_hmodule (),
 
 3595            _dbus_string_get_data (str), _dbus_string_get_length (str));
 
 3597        if (pathLength == 0 || GetLastError () != 0)
 
 3606        if (pathLength < (DWORD) _dbus_string_get_length (str))
 
 3625    prefix = _dbus_string_get_udata (str);
 
 3627    lastSlash = _mbsrchr (prefix, 
'\\');
 
 3628    if (lastSlash == 
NULL) {
 
 3641    if (lastSlash - prefix >= 4 && _mbsnicmp (lastSlash - 4, (
const unsigned char *)
"\\bin", 4) == 0)
 
 3643    else if (lastSlash - prefix >= 10 && _mbsnicmp (lastSlash - 10, (
const unsigned char *)
"\\bin\\debug", 10) == 0)
 
 3645    else if (lastSlash - prefix >= 12 && _mbsnicmp (lastSlash - 12, (
const unsigned char *)
"\\bin\\release", 12) == 0)
 
 3684  const char *homepath;
 
 3685  const char *homedrive;
 
 3694  if (homedrive != 
NULL && *homedrive != 
'\0')
 
 3700  if (homepath != 
NULL && *homepath != 
'\0')
 
 3705#ifdef DBUS_ENABLE_EMBEDDED_TESTS 
 3707    const char *
override;
 
 3710    if (
override != 
NULL && *
override != 
'\0')
 
 3716        _dbus_verbose (
"Using fake homedir for testing: %s\n",
 
 3717                       _dbus_string_get_const_data (&homedir));
 
 3724        if (!already_warned)
 
 3726            _dbus_warn (
"Using your real home directory for testing, set DBUS_TEST_HOMEDIR to avoid");
 
 3727            already_warned = 
TRUE;
 
 3736#define KEYRING_DIR "dbus-keyrings" 
 3738#define KEYRING_DIR ".dbus-keyrings" 
 3747                          directory, _dbus_string_get_length (directory))) {
 
 
 3767  DWORD attributes = GetFileAttributesA (file);
 
 3769  if (attributes != INVALID_FILE_ATTRIBUTES && GetLastError() != ERROR_PATH_NOT_FOUND)
 
 
 3783_dbus_strerror (
int error_number)
 
 3791  switch (error_number)
 
 3794      return "Interrupted function call";
 
 3796      return "Permission denied";
 
 3798      return "Bad address";
 
 3800      return "Invalid argument";
 
 3802      return "Too many open files";
 
 3803    case WSAEWOULDBLOCK:
 
 3804      return "Resource temporarily unavailable";
 
 3805    case WSAEINPROGRESS:
 
 3806      return "Operation now in progress";
 
 3808      return "Operation already in progress";
 
 3810      return "Socket operation on nonsocket";
 
 3811    case WSAEDESTADDRREQ:
 
 3812      return "Destination address required";
 
 3814      return "Message too long";
 
 3816      return "Protocol wrong type for socket";
 
 3817    case WSAENOPROTOOPT:
 
 3818      return "Bad protocol option";
 
 3819    case WSAEPROTONOSUPPORT:
 
 3820      return "Protocol not supported";
 
 3821    case WSAESOCKTNOSUPPORT:
 
 3822      return "Socket type not supported";
 
 3824      return "Operation not supported";
 
 3825    case WSAEPFNOSUPPORT:
 
 3826      return "Protocol family not supported";
 
 3827    case WSAEAFNOSUPPORT:
 
 3828      return "Address family not supported by protocol family";
 
 3830      return "Address already in use";
 
 3831    case WSAEADDRNOTAVAIL:
 
 3832      return "Cannot assign requested address";
 
 3834      return "Network is down";
 
 3835    case WSAENETUNREACH:
 
 3836      return "Network is unreachable";
 
 3838      return "Network dropped connection on reset";
 
 3839    case WSAECONNABORTED:
 
 3840      return "Software caused connection abort";
 
 3842      return "Connection reset by peer";
 
 3844      return "No buffer space available";
 
 3846      return "Socket is already connected";
 
 3848      return "Socket is not connected";
 
 3850      return "Cannot send after socket shutdown";
 
 3852      return "Connection timed out";
 
 3853    case WSAECONNREFUSED:
 
 3854      return "Connection refused";
 
 3856      return "Host is down";
 
 3857    case WSAEHOSTUNREACH:
 
 3858      return "No route to host";
 
 3860      return "Too many processes";
 
 3862      return "Graceful shutdown in progress";
 
 3863    case WSATYPE_NOT_FOUND:
 
 3864      return "Class type not found";
 
 3865    case WSAHOST_NOT_FOUND:
 
 3866      return "Host not found";
 
 3868      return "Nonauthoritative host not found";
 
 3869    case WSANO_RECOVERY:
 
 3870      return "This is a nonrecoverable error";
 
 3872      return "Valid name, no data record of requested type";
 
 3873    case WSA_INVALID_HANDLE:
 
 3874      return "Specified event object handle is invalid";
 
 3875    case WSA_INVALID_PARAMETER:
 
 3876      return "One or more parameters are invalid";
 
 3877    case WSA_IO_INCOMPLETE:
 
 3878      return "Overlapped I/O event object not in signaled state";
 
 3879    case WSA_IO_PENDING:
 
 3880      return "Overlapped operations will complete later";
 
 3881    case WSA_NOT_ENOUGH_MEMORY:
 
 3882      return "Insufficient memory available";
 
 3883    case WSA_OPERATION_ABORTED:
 
 3884      return "Overlapped operation aborted";
 
 3885#ifdef WSAINVALIDPROCTABLE 
 3887    case WSAINVALIDPROCTABLE:
 
 3888      return "Invalid procedure table from service provider";
 
 3890#ifdef WSAINVALIDPROVIDER 
 3892    case WSAINVALIDPROVIDER:
 
 3893      return "Invalid service provider version number";
 
 3895#ifdef WSAPROVIDERFAILEDINIT 
 3897    case WSAPROVIDERFAILEDINIT:
 
 3898      return "Unable to initialize a service provider";
 
 3901    case WSASYSCALLFAILURE:
 
 3902      return "System call failure";
 
 3905      msg = strerror (error_number);
 
 3923_dbus_win_set_error_from_win_error (
DBusError *error,
 
 3929  FormatMessageA (FORMAT_MESSAGE_ALLOCATE_BUFFER |
 
 3930                  FORMAT_MESSAGE_IGNORE_INSERTS |
 
 3931                  FORMAT_MESSAGE_FROM_SYSTEM,
 
 3932                  NULL, code, MAKELANGID (LANG_ENGLISH, SUBLANG_ENGLISH_US),
 
 3933                  (LPSTR) &msg, 0, 
NULL);
 
 3940    dbus_set_error (error, 
"win32.error", 
"Unknown error code %d or FormatMessage failed", code);
 
 3944_dbus_win_warn_win_error (
const char *message,
 
 3950  _dbus_win_set_error_from_win_error (&error, code);
 
 3966  const char *filename_c;
 
 3968  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 3970  filename_c = _dbus_string_get_const_data (filename);
 
 3972  if (RemoveDirectoryA (filename_c) == 0)
 
 3974      char *emsg = _dbus_win_error_string (GetLastError ());
 
 3976                      "Failed to remove directory %s: %s",
 
 3978      _dbus_win_free_error_string (emsg);
 
 
 3994  if (_dbus_string_get_length (filename) > 0)
 
 3995    return _dbus_string_get_byte (filename, 1) == 
':' 
 3996           || _dbus_string_get_byte (filename, 0) == 
'\\' 
 3997           || _dbus_string_get_byte (filename, 0) == 
'/';
 
 
 4009_dbus_save_socket_errno (
void)
 
 4015_dbus_restore_socket_errno (
int saved_errno)
 
 4017  _dbus_win_set_errno (saved_errno);
 
 4020static const char *log_tag = 
"dbus";
 
 4021static DBusLogFlags log_flags = DBUS_LOG_FLAGS_STDERR;
 
 4039      (flags & (DBUS_LOG_FLAGS_STDERR | DBUS_LOG_FLAGS_SYSTEM_LOG)) != 0);
 
 
 4062     case DBUS_SYSTEM_LOG_INFO: s = 
"info"; 
break;
 
 4063     case DBUS_SYSTEM_LOG_WARNING: s = 
"warning"; 
break;
 
 4064     case DBUS_SYSTEM_LOG_SECURITY: s = 
"security"; 
break;
 
 4065     case DBUS_SYSTEM_LOG_ERROR: s = 
"error"; 
break;
 
 4069  if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
 
 4072      const char *message = 
NULL;
 
 4073      va_copy (tmp, args);
 
 4081      message = _dbus_string_get_const_data (&out);
 
 4083      if (message != 
NULL)
 
 4085          OutputDebugStringA (message);
 
 4089          OutputDebugStringA (
"Out of memory while formatting message: '''");
 
 4090          OutputDebugStringA (msg);
 
 4091          OutputDebugStringA (
"'''");
 
 4098  if (log_flags & DBUS_LOG_FLAGS_STDERR)
 
 4100      va_copy (tmp, args);
 
 4102      vfprintf (stderr, msg, tmp);
 
 4103      fprintf (stderr, 
"\n");
 
 
 4117_dbus_get_low_level_socket_errno (
void)
 
 4119  return WSAGetLastError ();
 
 4123_dbus_win_set_error_from_last_error (
DBusError *error,
 
 4128  char *message = 
NULL;
 
 4134  name = _dbus_win_error_from_last_error ();
 
 4135  message = _dbus_win_error_string (GetLastError ());
 
 4145          _DBUS_SET_OOM (error);
 
 4149      va_start (args, format);
 
 4154          _DBUS_SET_OOM (error);
 
 4159      dbus_set_error (error, name, 
"%s: %s", _dbus_string_get_const_data (&str), message);
 
 4168  if (message != 
NULL)
 
 4169    _dbus_win_free_error_string (message);
 
 4171  _DBUS_ASSERT_ERROR_IS_SET (error);
 
 4186_dbus_win_event_create_inheritable (
DBusError *error)
 
 4193      _dbus_win_set_error_from_last_error (error, 
"Could not create event");
 
 4196  else if (GetLastError () == ERROR_ALREADY_EXISTS)
 
 4198      _dbus_win_set_error_from_last_error (error, 
"Event already exists");
 
 4202  if (!SetHandleInformation (handle, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT))
 
 4204      _dbus_win_set_error_from_last_error (error, 
"Could not set inheritance for event %p", handle);
 
 4205      CloseHandle (handle);
 
 4219_dbus_win_event_set (HANDLE handle, 
DBusError *error)
 
 4223  if (!SetEvent (handle))
 
 4225      _dbus_win_set_error_from_last_error (error, 
"Could not trigger event (handle %p)", handle);
 
 4242_dbus_win_event_wait (HANDLE handle, 
int timeout, 
DBusError *error)
 
 4248  status = WaitForSingleObject (handle, timeout);
 
 4256          _dbus_win_set_error_from_last_error (error, 
"Unable to wait for event (handle %p)", handle);
 
 4281_dbus_win_event_free (HANDLE handle, 
DBusError *error)
 
 4283  if (handle == 
NULL || handle == INVALID_HANDLE_VALUE)
 
 4286  if (CloseHandle (handle))
 
 4290  if (GetLastError () == ERROR_INVALID_HANDLE)
 
 4293  _dbus_win_set_error_from_last_error (error, 
"Could not close event (handle %p)", handle);
 
 4299_dbus_open_socket (SOCKET           *socket_p,
 
 4305  if (!_dbus_win_startup_winsock ())
 
 4307      _DBUS_SET_OOM (error);
 
 4311  *socket_p = socket (domain, type, protocol);
 
 4312  if (*socket_p == INVALID_SOCKET)
 
 4314      DBUS_SOCKET_SET_ERRNO ();
 
 4316                      "Failed to open socket: %s",
 
 4321  _dbus_win_handle_set_close_on_exec ((HANDLE) *socket_p);
 
 4336_dbus_open_unix_socket (SOCKET           *socket,
 
 4339  return _dbus_open_socket (socket, AF_UNIX, SOCK_STREAM, 0, error);
 
 4365  struct sockaddr_un addr;
 
 4369  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 4371  _dbus_verbose (
"connecting to unix socket %s abstract=%d\n",
 
 4377                      "Failed to connect: UNIX abstract socket is not supported on this system");
 
 4381  path_len = strlen (path);
 
 4385                      "Failed to connect: socket name too long");
 
 4389  if (!_dbus_open_unix_socket (&s.sock, error))
 
 4391      _DBUS_ASSERT_ERROR_IS_SET (error);
 
 4394  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 4397  addr.sun_family = AF_UNIX;
 
 4398  strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
 
 4400  if (connect (s.sock, (
struct sockaddr *) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
 
 4402      DBUS_SOCKET_SET_ERRNO ();
 
 4405                      "Failed to connect to socket %s: %s",
 
 4406                      path, _dbus_strerror (errno));
 
 4417                  "Failed to connect: UNIX socket is not supported with this build");
 
 
 4445  struct sockaddr_un addr;
 
 4449  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 4451  _dbus_verbose (
"listening on unix socket %s abstract=%d\n",
 
 4457                      "Failed to listen: UNIX abstract socket is not supported on this system");
 
 4461  if (!_dbus_open_unix_socket (&s.sock, error))
 
 4463      _DBUS_ASSERT_ERROR_IS_SET (error);
 
 4466  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 4469  addr.sun_family = AF_UNIX;
 
 4470  path_len = strlen (path);
 
 4479                      "Failed to listen: socket name too long");
 
 4484  strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
 
 4486  if (bind (s.sock, (
struct sockaddr *) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
 
 4488      DBUS_SOCKET_SET_ERRNO ();
 
 4490                      "Failed to bind socket \"%s\": %s",
 
 4491                      path, _dbus_strerror (errno));
 
 4496  if (listen (s.sock, SOMAXCONN ) < 0)
 
 4498      DBUS_SOCKET_SET_ERRNO ();
 
 4500                      "Failed to listen on socket \"%s\": %s",
 
 4501                      path, _dbus_strerror (errno));
 
 4508      _DBUS_ASSERT_ERROR_IS_SET (error);
 
 4514                  "Failed to listen: UNIX socket is not supported with this build");
 
 
dbus_bool_t _dbus_credentials_add_windows_sid(DBusCredentials *credentials, const char *windows_sid)
Add a Windows user SID to the credentials.
dbus_bool_t _dbus_credentials_add_pid(DBusCredentials *credentials, dbus_pid_t pid)
Add a UNIX process ID to the credentials.
dbus_bool_t _dbus_credentials_are_anonymous(DBusCredentials *credentials)
Checks whether a credentials object contains a user identity.
void dbus_set_error_const(DBusError *error, const char *name, const char *message)
Assigns an error name and message to a DBusError.
void dbus_error_init(DBusError *error)
Initializes a DBusError structure.
void dbus_set_error(DBusError *error, const char *name, const char *format,...)
Assigns an error name and message to a DBusError.
void dbus_error_free(DBusError *error)
Frees an error that's been set (or just initialized), then reinitializes the error as in dbus_error_i...
dbus_bool_t dbus_error_is_set(const DBusError *error)
Checks whether an error occurred (the error is set).
dbus_bool_t _dbus_file_exists(const char *file)
Checks if a file exists.
dbus_bool_t _dbus_delete_file(const DBusString *filename, DBusError *error)
Deletes the given file.
dbus_bool_t _dbus_make_file_world_readable(const DBusString *filename, DBusError *error)
Makes the file readable by every user in the system.
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
#define _DBUS_UNLOCK(name)
Unlocks a global lock.
#define _DBUS_LOCK(name)
Locks a global lock, initializing it first if necessary.
const char * _dbus_error_from_errno(int error_number)
Converts a UNIX errno, or Windows errno or WinSock error value into a DBusError name.
const char * _dbus_strerror_from_errno(void)
Get error message from errno.
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
#define _DBUS_ZERO(object)
Sets all bits in an object to zero.
void * _dbus_list_pop_first(DBusList **list)
Removes the first value in the list and returns it.
dbus_bool_t _dbus_list_append(DBusList **list, void *data)
Appends a value to the list.
#define NULL
A null pointer, defined appropriately for C or C++.
#define TRUE
Expands to "1".
#define FALSE
Expands to "0".
DBUS_PRIVATE_EXPORT void _dbus_verbose_bytes_of_string(const DBusString *str, int start, int len)
Dump the given part of the string to verbose log.
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
void * dbus_realloc(void *memory, size_t bytes)
Resizes a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
#define dbus_new(type, count)
Safe macro for using dbus_malloc().
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0().
void * dbus_malloc(size_t bytes)
Allocates the given number of bytes, as with standard malloc().
#define DBUS_ERROR_TIMEOUT
Certain timeout errors, possibly ETIMEDOUT on a socket.
#define DBUS_ERROR_NOT_SUPPORTED
Requested operation isn't supported (like ENOSYS on UNIX).
#define DBUS_ERROR_BAD_ADDRESS
A D-Bus bus address was malformed.
#define DBUS_ERROR_IO_ERROR
Something went wrong reading or writing to a socket, for example.
#define DBUS_ERROR_SPAWN_CHILD_EXITED
While starting a new process, the child exited with a status code.
#define DBUS_ERROR_ACCESS_DENIED
Security restrictions don't allow doing what you're trying to do.
#define DBUS_ERROR_FILE_EXISTS
Existing file and the operation you're using does not silently overwrite.
#define DBUS_ERROR_LIMITS_EXCEEDED
Some limited resource is exhausted.
#define DBUS_ERROR_FAILED
A generic error; "something went wrong" - see the error message for more.
#define DBUS_ERROR_NO_MEMORY
There was not enough memory to complete an operation.
#define DBUS_ERROR_INVALID_ARGS
Invalid arguments passed to a method call.
#define DBUS_ERROR_FILE_NOT_FOUND
Missing file.
dbus_bool_t _dbus_sha_compute(const DBusString *data, DBusString *ascii_output)
Computes the ASCII hex-encoded shasum of the given data and appends it to the output string.
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string.
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
dbus_bool_t _dbus_string_copy(const DBusString *source, int start, DBusString *dest, int insert_at)
Like _dbus_string_move(), but does not delete the section of the source string that's copied to the d...
char * _dbus_string_get_data_len(DBusString *str, int start, int len)
Gets a sub-portion of the raw character buffer from the string.
dbus_bool_t _dbus_string_validate_utf8(const DBusString *str, int start, int len)
Checks that the given range of the string is valid UTF-8.
void _dbus_string_init_const_len(DBusString *str, const char *value, int len)
Initializes a constant string with a length.
void _dbus_string_tolower_ascii(const DBusString *str, int start, int len)
Converts the given range of the string to lower case.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init(), and fills it with the same contents as _DBUS_STRING_IN...
void _dbus_string_shorten(DBusString *str, int length_to_remove)
Makes a string shorter by the given number of bytes.
dbus_bool_t _dbus_string_append_printf_valist(DBusString *str, const char *format, va_list args)
Appends a printf-style formatted string to the DBusString.
dbus_bool_t _dbus_string_lengthen(DBusString *str, int additional_length)
Makes a string longer by the given number of bytes.
dbus_bool_t _dbus_string_append_byte(DBusString *str, unsigned char byte)
Appends a single byte to the string, returning FALSE if not enough memory.
dbus_bool_t _dbus_string_append_printf(DBusString *str, const char *format,...)
Appends a printf-style formatted string to the DBusString.
void _dbus_logv(DBusSystemLogSeverity severity, const char *msg, va_list args)
Log a message to the system log file (e.g.
void _dbus_get_monotonic_time(dbus_int64_t *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
dbus_bool_t _dbus_read_local_machine_uuid(DBusGUID *machine_id, dbus_bool_t create_if_not_found, DBusError *error)
Reads the uuid of the machine we're running on from the dbus configuration.
#define _DBUS_POLLOUT
Writing now will not block.
unsigned long dbus_uid_t
A user ID.
dbus_bool_t _dbus_get_is_errno_eagain_or_ewouldblock(int e)
See if errno is EAGAIN or EWOULDBLOCK (this has to be done differently for Winsock so is abstracted)
unsigned long _dbus_pid_for_log(void)
The only reason this is separate from _dbus_getpid() is to allow it on Windows for logging but not fo...
unsigned long dbus_pid_t
A process ID.
int _dbus_read_socket(DBusSocket fd, DBusString *buffer, int count)
Socket interface.
void _dbus_exit(int code)
Exit the process, returning the given value.
#define _DBUS_POLLERR
Error condition.
int _dbus_write_socket(DBusSocket fd, const DBusString *buffer, int start, int len)
Thin wrapper around the write() system call that writes a part of a DBusString and handles EINTR for ...
void _dbus_atomic_set_nonzero(DBusAtomic *atomic)
Atomically set the value of an integer to something nonzero.
dbus_bool_t _dbus_socketpair(DBusSocket *fd1, DBusSocket *fd2, dbus_bool_t blocking, DBusError *error)
Creates pair of connect sockets (as in socketpair()).
dbus_bool_t _dbus_append_keyring_directory_for_credentials(DBusString *directory, DBusCredentials *credentials)
Appends the directory in which a keyring for the given credentials should be stored.
#define DBUS_UID_UNSET
an invalid UID used to represent an uninitialized dbus_uid_t field
dbus_int32_t _dbus_atomic_dec(DBusAtomic *atomic)
Atomically decrement an integer.
dbus_bool_t _dbus_read_credentials_socket(DBusSocket handle, DBusCredentials *credentials, DBusError *error)
Reads a single byte which must be nul (an error occurs otherwise), and reads unix credentials if avai...
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
DBusSocket _dbus_listen_unix_socket(const char *path, dbus_bool_t abstract, DBusError *error)
Creates a socket and binds it to the given path, then listens on the socket.
dbus_pid_t _dbus_getpid(void)
Gets our process ID.
dbus_int32_t _dbus_atomic_get(DBusAtomic *atomic)
Atomically get the value of an integer.
dbus_bool_t _dbus_set_socket_nonblocking(DBusSocket handle, DBusError *error)
Sets a file descriptor to be nonblocking.
dbus_bool_t _dbus_lookup_session_address(dbus_bool_t *supported, DBusString *address, DBusError *error)
Determines the address of the session bus by querying a platform-specific method.
dbus_bool_t _dbus_credentials_add_from_user(DBusCredentials *credentials, const DBusString *username, DBusCredentialsAddFlags flags, DBusError *error)
Adds the credentials corresponding to the given username.
DBusSocket _dbus_connect_tcp_socket(const char *host, const char *port, const char *family, DBusError *error)
Creates a socket and connects to a socket at the given host and port.
void _dbus_disable_sigpipe(void)
signal (SIGPIPE, SIG_IGN);
dbus_bool_t _dbus_check_setuid(void)
NOTE: If you modify this function, please also consider making the corresponding change in GLib.
void _dbus_sleep_milliseconds(int milliseconds)
Sleeps the given number of milliseconds.
dbus_bool_t _dbus_check_dir_is_private_to_user(DBusString *dir, DBusError *error)
Checks to make sure the given directory is private to the user.
dbus_bool_t _dbus_daemon_unpublish_session_bus_address(void)
Clear the platform-specific centralized location where the session bus address is published.
#define _DBUS_POLLIN
There is data to read.
int _dbus_listen_tcp_socket(const char *host, const char *port, const char *family, DBusString *retport, const char **retfamily, DBusSocket **fds_p, DBusError *error)
Creates a socket and binds it to the given path, then listens on the socket.
dbus_bool_t _dbus_send_credentials_socket(DBusSocket handle, DBusError *error)
Sends a single nul byte with our UNIX credentials as ancillary data.
dbus_uid_t _dbus_getuid(void)
Gets our Unix UID.
dbus_bool_t _dbus_credentials_add_from_current_process(DBusCredentials *credentials)
Adds the credentials of the current process to the passed-in credentials object.
dbus_bool_t _dbus_close_socket(DBusSocket *fd, DBusError *error)
Closes a socket and invalidates it.
DBusSocket _dbus_connect_unix_socket(const char *path, dbus_bool_t abstract, DBusError *error)
Creates a socket and connects it to the UNIX domain socket at the given path.
void _dbus_atomic_set_zero(DBusAtomic *atomic)
Atomically set the value of an integer to 0.
dbus_int32_t _dbus_atomic_inc(DBusAtomic *atomic)
Atomically increments an integer.
dbus_bool_t _dbus_generate_random_bytes(DBusString *str, int n_bytes, DBusError *error)
Generates the given number of random bytes, using the best mechanism we can come up with.
int _dbus_printf_string_upper_bound(const char *format, va_list args)
Measure the message length without terminating nul.
dbus_bool_t _dbus_delete_directory(const DBusString *filename, DBusError *error)
Removes a directory; Directory must be empty.
void _dbus_abort(void)
Aborts the program with SIGABRT (dumping core).
int _dbus_poll(DBusPollFD *fds, int n_fds, int timeout_milliseconds)
Wrapper for poll().
dbus_bool_t _dbus_get_autolaunch_address(const char *scope, DBusString *address, DBusError *error)
Returns the address of a new session bus.
int _dbus_write_socket_two(DBusSocket fd, const DBusString *buffer1, int start1, int len1, const DBusString *buffer2, int start2, int len2)
Like _dbus_write() but will use writev() if possible to write both buffers in sequence.
dbus_bool_t _dbus_concat_dir_and_file(DBusString *dir, const DBusString *next_component)
Appends the given filename to the given directory.
void _dbus_get_real_time(dbus_int64_t *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
void _dbus_init_system_log(const char *tag, DBusLogFlags flags)
Initialize the system log.
DBusSocket _dbus_accept(DBusSocket listen_fd)
Accepts a connection on a listening socket.
#define _DBUS_MAX_SUN_PATH_LENGTH
Maximum length of the path to a UNIX domain socket, sockaddr_un::sun_path member.
dbus_bool_t _dbus_append_user_from_current_process(DBusString *str)
Append to the string the identity we would like to have when we authenticate, on UNIX this is the cur...
void _dbus_flush_caches(void)
Called when the bus daemon is signaled to reload its configuration; any caches should be nuked.
const char * _dbus_get_tmpdir(void)
Gets the temporary files directory, using GetTempPath()
dbus_bool_t _dbus_ensure_directory(const DBusString *filename, DBusError *error)
Creates a directory; succeeds if the directory is created or already existed.
dbus_bool_t _dbus_path_is_absolute(const DBusString *filename)
Checks whether the filename is an absolute path.
dbus_bool_t _dbus_create_directory(const DBusString *filename, DBusError *error)
Creates a directory.
_DBUS_GNUC_EXTENSION typedef long dbus_int64_t
A 64-bit signed integer.
unsigned int dbus_uint32_t
A 32-bit unsigned integer on all platforms.
int dbus_int32_t
A 32-bit signed integer on all platforms.
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
_DBUS_GNUC_EXTENSION typedef unsigned long dbus_uint64_t
A 64-bit unsigned integer.
#define DBUS_INT64_CONSTANT(val)
Declare a 64-bit signed integer constant.
An atomic integer safe to increment or decrement from multiple threads.
volatile dbus_int32_t value
Value of the atomic integer.
Object representing an exception.
const char * message
public error message field
short events
Events to poll for.
short revents
Events that occurred.
DBusPollable fd
File descriptor.
A globally unique ID ; we have one for each DBusServer, and also one for each machine with libdbus in...
dbus_uint32_t as_uint32s[DBUS_UUID_LENGTH_WORDS]
guid as four uint32 values