31 #define STRSAFE_NO_DEPRECATE 
   35 #define _WIN32_WINNT 0x0501 
   39 #include "dbus-internals.h" 
   41 #include "dbus-sysdeps.h" 
   42 #include "dbus-threads.h" 
   43 #include "dbus-protocol.h" 
   44 #include "dbus-string.h" 
   45 #include "dbus-sysdeps.h" 
   46 #include "dbus-sysdeps-win.h" 
   47 #include "dbus-protocol.h" 
   48 #include "dbus-hash.h" 
   49 #include "dbus-sockets-win.h" 
   50 #include "dbus-list.h" 
   51 #include "dbus-nonce.h" 
   52 #include "dbus-credentials.h" 
   59 extern BOOL WINAPI ConvertStringSidToSidA (LPCSTR  StringSid, PSID *Sid);
 
   60 extern BOOL WINAPI ConvertSidToStringSidA (PSID Sid, LPSTR *StringSid);
 
   72 #include <sys/types.h> 
   75 #ifdef HAVE_WS2TCPIP_H 
   84 #ifndef PROCESS_QUERY_LIMITED_INFORMATION 
   86 #define PROCESS_QUERY_LIMITED_INFORMATION (0x1000) 
   89 typedef int socklen_t;
 
   93 _dbus_win_set_errno (
int err)
 
  102 static BOOL is_winxp_sp3_or_lower (
void);
 
  108 typedef MIB_TCPROW_OWNER_PID _MIB_TCPROW_EX;
 
  109 typedef MIB_TCPTABLE_OWNER_PID MIB_TCPTABLE_EX;
 
  110 typedef PMIB_TCPTABLE_OWNER_PID PMIB_TCPTABLE_EX;
 
  111 typedef DWORD (WINAPI *ProcAllocateAndGetTcpExtTableFromStack)(PMIB_TCPTABLE_EX*,BOOL,HANDLE,DWORD,DWORD);
 
  112 static ProcAllocateAndGetTcpExtTableFromStack lpfnAllocateAndGetTcpExTableFromStack = 
NULL;
 
  120 load_ex_ip_helper_procedures(
void)
 
  122   HMODULE hModule = LoadLibrary (
"iphlpapi.dll");
 
  125       _dbus_verbose (
"could not load iphlpapi.dll\n");
 
  129   lpfnAllocateAndGetTcpExTableFromStack = (ProcAllocateAndGetTcpExtTableFromStack)GetProcAddress (hModule, 
"AllocateAndGetTcpExTableFromStack");
 
  130   if (lpfnAllocateAndGetTcpExTableFromStack == 
NULL)
 
  132       _dbus_verbose (
"could not find function AllocateAndGetTcpExTableFromStack in iphlpapi.dll\n");
 
  145 get_pid_from_extended_tcp_table(
int peer_port)
 
  148   DWORD errorCode, size = 0, i;
 
  149   MIB_TCPTABLE_OWNER_PID *tcp_table;
 
  152        GetExtendedTcpTable (
NULL, &size, 
TRUE, AF_INET, TCP_TABLE_OWNER_PID_ALL, 0)) == ERROR_INSUFFICIENT_BUFFER)
 
  154       tcp_table = (MIB_TCPTABLE_OWNER_PID *) 
dbus_malloc (size);
 
  155       if (tcp_table == 
NULL)
 
  157           _dbus_verbose (
"Error allocating memory\n");
 
  163       _dbus_win_warn_win_error (
"unexpected error returned from GetExtendedTcpTable", errorCode);
 
  167   if ((errorCode = GetExtendedTcpTable (tcp_table, &size, 
TRUE, AF_INET, TCP_TABLE_OWNER_PID_ALL, 0)) != NO_ERROR)
 
  169       _dbus_verbose (
"Error fetching tcp table %d\n", (
int)errorCode);
 
  175   for (i = 0; i < tcp_table->dwNumEntries; i++)
 
  177       MIB_TCPROW_OWNER_PID *p = &tcp_table->table[i];
 
  178       int local_address = ntohl (p->dwLocalAddr);
 
  179       int local_port = ntohs (p->dwLocalPort);
 
  180       if (p->dwState == MIB_TCP_STATE_ESTAB
 
  181           && local_address == INADDR_LOOPBACK && local_port == peer_port)
 
  182          result = p->dwOwningPid;
 
  186   _dbus_verbose (
"got pid %lu\n", result);
 
  198 get_pid_from_tcp_ex_table(
int peer_port)
 
  202   PMIB_TCPTABLE_EX tcp_table = 
NULL;
 
  204   if (!load_ex_ip_helper_procedures ())
 
  207         (
"Error not been able to load iphelper procedures\n");
 
  211   errorCode = lpfnAllocateAndGetTcpExTableFromStack (&tcp_table, 
TRUE, GetProcessHeap(), 0, 2);
 
  213   if (errorCode != NO_ERROR)
 
  216         (
"Error not been able to call AllocateAndGetTcpExTableFromStack()\n");
 
  221   for (i = 0; i < tcp_table->dwNumEntries; i++)
 
  223       _MIB_TCPROW_EX *p = &tcp_table->table[i];
 
  224       int local_port = ntohs (p->dwLocalPort);
 
  225       int local_address = ntohl (p->dwLocalAddr);
 
  226       if (local_address == INADDR_LOOPBACK && local_port == peer_port)
 
  228           result = p->dwOwningPid;
 
  233   HeapFree (GetProcessHeap(), 0, tcp_table);
 
  234   _dbus_verbose (
"got pid %lu\n", result);
 
  244 _dbus_get_peer_pid_from_tcp_handle (
int handle)
 
  246   struct sockaddr_storage addr;
 
  247   socklen_t len = 
sizeof (addr);
 
  253   getpeername (handle, (
struct sockaddr *) &addr, &len);
 
  255   if (addr.ss_family == AF_INET)
 
  257       struct sockaddr_in *s = (
struct sockaddr_in *) &addr;
 
  258       peer_port = ntohs (s->sin_port);
 
  259       is_localhost = (ntohl (s->sin_addr.s_addr) == INADDR_LOOPBACK);
 
  261   else if (addr.ss_family == AF_INET6)
 
  263       _dbus_verbose (
"FIXME [61922]: IPV6 support not working on windows\n");
 
  274       _dbus_verbose (
"no idea what address family %d is\n", addr.ss_family);
 
  280       _dbus_verbose (
"could not fetch process id from remote process\n");
 
  287         (
"Error not been able to fetch tcp peer port from connection\n");
 
  291   _dbus_verbose (
"trying to get peer's pid\n");
 
  293   result = get_pid_from_extended_tcp_table (peer_port);
 
  296   result = get_pid_from_tcp_ex_table (peer_port);
 
  302 _dbus_win_error_from_last_error (
void)
 
  304   switch (GetLastError())
 
  309     case ERROR_NO_MORE_FILES:
 
  310     case ERROR_TOO_MANY_OPEN_FILES:
 
  313     case ERROR_ACCESS_DENIED:
 
  314     case ERROR_CANNOT_MAKE:
 
  317     case ERROR_NOT_ENOUGH_MEMORY:
 
  320     case ERROR_FILE_EXISTS:
 
  323     case ERROR_FILE_NOT_FOUND:
 
  324     case ERROR_PATH_NOT_FOUND:
 
  334 _dbus_win_error_string (
int error_number)
 
  338   FormatMessageA (FORMAT_MESSAGE_ALLOCATE_BUFFER |
 
  339                   FORMAT_MESSAGE_IGNORE_INSERTS |
 
  340                   FORMAT_MESSAGE_FROM_SYSTEM,
 
  341                   NULL, error_number, 0,
 
  342                   (LPSTR) &msg, 0, 
NULL);
 
  344   if (msg[strlen (msg) - 1] == 
'\n')
 
  345     msg[strlen (msg) - 1] = 
'\0';
 
  346   if (msg[strlen (msg) - 1] == 
'\r')
 
  347     msg[strlen (msg) - 1] = 
'\0';
 
  353 _dbus_win_free_error_string (
char *
string)
 
  389   start = _dbus_string_get_length (buffer);
 
  393       _dbus_win_set_errno (ENOMEM);
 
  401   _dbus_verbose (
"recv: count=%d fd=%Iu\n", count, fd.sock);
 
  402   bytes_read = recv (fd.sock, data, count, 0);
 
  404   if (bytes_read == SOCKET_ERROR)
 
  406           DBUS_SOCKET_SET_ERRNO();
 
  407           _dbus_verbose (
"recv: failed: %s (%d)\n", _dbus_strerror (errno), errno);
 
  411           _dbus_verbose (
"recv: = %d\n", bytes_read);
 
  457   data = _dbus_string_get_const_data_len (buffer, start, len);
 
  461   _dbus_verbose (
"send: len=%d fd=%Iu\n", len, fd.sock);
 
  462   bytes_written = send (fd.sock, data, len, 0);
 
  464   if (bytes_written == SOCKET_ERROR)
 
  466       DBUS_SOCKET_SET_ERRNO();
 
  471       _dbus_verbose (
"send: = %d\n", bytes_written);
 
  473   if (bytes_written < 0 && errno == EINTR)
 
  477   if (bytes_written > 0)
 
  481   return bytes_written;
 
  496   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
  499   if (closesocket (fd.sock) == SOCKET_ERROR)
 
  501       DBUS_SOCKET_SET_ERRNO ();
 
  507                       "Could not close socket: socket=%Iu, , %s",
 
  511   _dbus_verbose (
"socket=%Iu, \n", fd.sock);
 
  524 _dbus_win_handle_set_close_on_exec (HANDLE handle)
 
  526   if ( !SetHandleInformation( (HANDLE) handle,
 
  527                         HANDLE_FLAG_INHERIT | HANDLE_FLAG_PROTECT_FROM_CLOSE,
 
  530       _dbus_win_warn_win_error (
"Disabling socket handle inheritance failed:", GetLastError());
 
  547   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
  549   if (ioctlsocket (handle.sock, FIONBIO, &one) == SOCKET_ERROR)
 
  551       DBUS_SOCKET_SET_ERRNO ();
 
  553                       "Failed to set socket %Iu to nonblocking: %s",
 
  604   data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
 
  607     data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
 
  615   vectors[0].buf = (
char*) data1;
 
  616   vectors[0].len = len1;
 
  617   vectors[1].buf = (
char*) data2;
 
  618   vectors[1].len = len2;
 
  622   _dbus_verbose (
"WSASend: len1+2=%d+%d fd=%Iu\n", len1, len2, fd.sock);
 
  623   rc = WSASend (fd.sock,
 
  631   if (rc == SOCKET_ERROR)
 
  633       DBUS_SOCKET_SET_ERRNO ();
 
  635       bytes_written = (DWORD) -1;
 
  638     _dbus_verbose (
"WSASend: = %ld\n", bytes_written);
 
  640   if (bytes_written == (DWORD) -1 && errno == EINTR)
 
  643   return bytes_written;
 
  657 _dbus_connect_named_pipe (
const char     *path,
 
  669 _dbus_win_startup_winsock (
void)
 
  676   WORD wVersionRequested;
 
  686   wVersionRequested = MAKEWORD (2, 0);
 
  688   err = WSAStartup (wVersionRequested, &wsaData);
 
  700   if (LOBYTE (wsaData.wVersion) != 2 ||
 
  701       HIBYTE (wsaData.wVersion) != 0)
 
  740   bufsize = 
sizeof (buf);
 
  741   DBUS_VA_COPY (args_copy, args);
 
  742   len = _vsnprintf (buf, bufsize - 1, format, args_copy);
 
  751       p = malloc (bufsize);
 
  756       DBUS_VA_COPY (args_copy, args);
 
  757       len = _vsnprintf (p, bufsize - 1, format, args_copy);
 
  774 _dbus_win_utf8_to_utf16 (
const char *str,
 
  789   n = MultiByteToWideChar (CP_UTF8, 0, str, -1, 
NULL, 0);
 
  793       _dbus_win_set_error_from_win_error (error, GetLastError ());
 
  801       _DBUS_SET_OOM (error);
 
  805   if (MultiByteToWideChar (CP_UTF8, 0, str, -1, retval, n) != n)
 
  823 _dbus_win_utf16_to_utf8 (
const wchar_t *str,
 
  829   n = WideCharToMultiByte (CP_UTF8, 0, str, -1, 
NULL, 0, 
NULL, 
NULL);
 
  833       _dbus_win_set_error_from_win_error (error, GetLastError ());
 
  841       _DBUS_SET_OOM (error);
 
  845   if (WideCharToMultiByte (CP_UTF8, 0, str, -1, retval, n, 
NULL, 
NULL) != n)
 
  866 _dbus_win_account_to_sid (
const wchar_t *waccount,
 
  871   DWORD sid_length, wdomain_length;
 
  879   if (!LookupAccountNameW (
NULL, waccount, 
NULL, &sid_length,
 
  880                            NULL, &wdomain_length, &use) &&
 
  881       GetLastError () != ERROR_INSUFFICIENT_BUFFER)
 
  883       _dbus_win_set_error_from_win_error (error, GetLastError ());
 
  890       _DBUS_SET_OOM (error);
 
  894   wdomain = 
dbus_new (
wchar_t, wdomain_length);
 
  897       _DBUS_SET_OOM (error);
 
  901   if (!LookupAccountNameW (
NULL, waccount, (PSID) *ppsid, &sid_length,
 
  902                            wdomain, &wdomain_length, &use))
 
  904       _dbus_win_set_error_from_win_error (error, GetLastError ());
 
  908   if (!IsValidSid ((PSID) *ppsid))
 
  946 is_winxp_sp3_or_lower (
void)
 
  948    OSVERSIONINFOEX osvi;
 
  949    DWORDLONG dwlConditionMask = 0;
 
  950    int op=VER_LESS_EQUAL;
 
  954    ZeroMemory(&osvi, 
sizeof(OSVERSIONINFOEX));
 
  955    osvi.dwOSVersionInfoSize = 
sizeof(OSVERSIONINFOEX);
 
  956    osvi.dwMajorVersion = 5;
 
  957    osvi.dwMinorVersion = 1;
 
  958    osvi.wServicePackMajor = 3;
 
  959    osvi.wServicePackMinor = 0;
 
  963    VER_SET_CONDITION( dwlConditionMask, VER_MAJORVERSION, op );
 
  964    VER_SET_CONDITION( dwlConditionMask, VER_MINORVERSION, op );
 
  965    VER_SET_CONDITION( dwlConditionMask, VER_SERVICEPACKMAJOR, op );
 
  966    VER_SET_CONDITION( dwlConditionMask, VER_SERVICEPACKMINOR, op );
 
  970    return VerifyVersionInfo(
 
  972       VER_MAJORVERSION | VER_MINORVERSION |
 
  973       VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 
  983 _dbus_getsid(
char **sid, 
dbus_pid_t process_id)
 
  985   HANDLE process_token = INVALID_HANDLE_VALUE;
 
  986   TOKEN_USER *token_user = 
NULL;
 
  991   HANDLE process_handle;
 
  993     process_handle = GetCurrentProcess();
 
  994   else if (is_winxp_sp3_or_lower())
 
  995     process_handle = OpenProcess(PROCESS_QUERY_INFORMATION, 
FALSE, process_id);
 
  997     process_handle = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 
FALSE, process_id);
 
  999   if (!OpenProcessToken (process_handle, TOKEN_QUERY, &process_token))
 
 1001       _dbus_win_warn_win_error (
"OpenProcessToken failed", GetLastError ());
 
 1004   if ((!GetTokenInformation (process_token, TokenUser, 
NULL, 0, &n)
 
 1005             && GetLastError () != ERROR_INSUFFICIENT_BUFFER)
 
 1006            || (token_user = alloca (n)) == 
NULL 
 1007            || !GetTokenInformation (process_token, TokenUser, token_user, n, &n))
 
 1009       _dbus_win_warn_win_error (
"GetTokenInformation failed", GetLastError ());
 
 1012   psid = token_user->User.Sid;
 
 1013   if (!IsValidSid (psid))
 
 1015       _dbus_verbose(
"%s invalid sid\n",__FUNCTION__);
 
 1018   if (!ConvertSidToStringSidA (psid, sid))
 
 1020       _dbus_verbose(
"%s invalid sid\n",__FUNCTION__);
 
 1027   CloseHandle (process_handle);
 
 1028   if (process_token != INVALID_HANDLE_VALUE)
 
 1029     CloseHandle (process_token);
 
 1031   _dbus_verbose(
"_dbus_getsid() got '%s' and returns %d\n", *sid, retval);
 
 1060   SOCKET temp, socket1 = -1, socket2 = -1;
 
 1061   struct sockaddr_in saddr;
 
 1065   if (!_dbus_win_startup_winsock ())
 
 1067       _DBUS_SET_OOM (error);
 
 1071   temp = socket (AF_INET, SOCK_STREAM, 0);
 
 1072   if (temp == INVALID_SOCKET)
 
 1074       DBUS_SOCKET_SET_ERRNO ();
 
 1079   saddr.sin_family = AF_INET;
 
 1081   saddr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
 
 1083   if (bind (temp, (
struct sockaddr *)&saddr, 
sizeof (saddr)) == SOCKET_ERROR)
 
 1085       DBUS_SOCKET_SET_ERRNO ();
 
 1089   if (listen (temp, 1) == SOCKET_ERROR)
 
 1091       DBUS_SOCKET_SET_ERRNO ();
 
 1095   len = 
sizeof (saddr);
 
 1096   if (getsockname (temp, (
struct sockaddr *)&saddr, &len) == SOCKET_ERROR)
 
 1098       DBUS_SOCKET_SET_ERRNO ();
 
 1102   socket1 = socket (AF_INET, SOCK_STREAM, 0);
 
 1103   if (socket1 == INVALID_SOCKET)
 
 1105       DBUS_SOCKET_SET_ERRNO ();
 
 1109   if (connect (socket1, (
struct sockaddr  *)&saddr, len) == SOCKET_ERROR)
 
 1111       DBUS_SOCKET_SET_ERRNO ();
 
 1115   socket2 = accept (temp, (
struct sockaddr *) &saddr, &len);
 
 1116   if (socket2 == INVALID_SOCKET)
 
 1118       DBUS_SOCKET_SET_ERRNO ();
 
 1125       if (ioctlsocket (socket1, FIONBIO, &arg) == SOCKET_ERROR)
 
 1127           DBUS_SOCKET_SET_ERRNO ();
 
 1132       if (ioctlsocket (socket2, FIONBIO, &arg) == SOCKET_ERROR)
 
 1134           DBUS_SOCKET_SET_ERRNO ();
 
 1139   fd1->sock = socket1;
 
 1140   fd2->sock = socket2;
 
 1142   _dbus_verbose (
"full-duplex pipe %Iu:%Iu <-> %Iu:%Iu\n",
 
 1143                  fd1->sock, socket1, fd2->sock, socket2);
 
 1150   closesocket (socket2);
 
 1152   closesocket (socket1);
 
 1157                   "Could not setup socket pair: %s",
 
 1174             int         timeout_milliseconds)
 
 1176 #define USE_CHRIS_IMPL 0 
 1180 #define DBUS_POLL_CHAR_BUFFER_SIZE 2000 
 1181   char msg[DBUS_POLL_CHAR_BUFFER_SIZE];
 
 1189 #define DBUS_STACK_WSAEVENTS 256 
 1190   WSAEVENT eventsOnStack[DBUS_STACK_WSAEVENTS];
 
 1191   WSAEVENT *pEvents = 
NULL;
 
 1192   if (n_fds > DBUS_STACK_WSAEVENTS)
 
 1193     pEvents = calloc(
sizeof(WSAEVENT), n_fds);
 
 1195     pEvents = eventsOnStack;
 
 1198 #ifdef DBUS_ENABLE_VERBOSE_MODE 
 1200   msgp += sprintf (msgp, 
"WSAEventSelect: to=%d\n\t", timeout_milliseconds);
 
 1201   for (i = 0; i < n_fds; i++)
 
 1207         msgp += sprintf (msgp, 
"R:%Iu ", fdp->
fd.sock);
 
 1210         msgp += sprintf (msgp, 
"W:%Iu ", fdp->
fd.sock);
 
 1212       msgp += sprintf (msgp, 
"E:%Iu\n\t", fdp->
fd.sock);
 
 1216       if (msgp >= msg + DBUS_POLL_CHAR_BUFFER_SIZE)
 
 1222   msgp += sprintf (msgp, 
"\n");
 
 1223   _dbus_verbose (
"%s",msg);
 
 1225   for (i = 0; i < n_fds; i++)
 
 1229       long lNetworkEvents = FD_OOB;
 
 1231       ev = WSACreateEvent();
 
 1234         lNetworkEvents |= FD_READ | FD_ACCEPT | FD_CLOSE;
 
 1237         lNetworkEvents |= FD_WRITE | FD_CONNECT;
 
 1239       WSAEventSelect(fdp->
fd.sock, ev, lNetworkEvents);
 
 1245   ready = WSAWaitForMultipleEvents (n_fds, pEvents, 
FALSE, timeout_milliseconds, 
FALSE);
 
 1247   if (DBUS_SOCKET_API_RETURNS_ERROR (ready))
 
 1249       DBUS_SOCKET_SET_ERRNO ();
 
 1250       if (errno != WSAEWOULDBLOCK)
 
 1254   else if (ready == WSA_WAIT_TIMEOUT)
 
 1256       _dbus_verbose (
"WSAWaitForMultipleEvents: WSA_WAIT_TIMEOUT\n");
 
 1259   else if (ready >= WSA_WAIT_EVENT_0 && ready < (
int)(WSA_WAIT_EVENT_0 + n_fds))
 
 1262       msgp += sprintf (msgp, 
"WSAWaitForMultipleEvents: =%d\n\t", ready);
 
 1264       for (i = 0; i < n_fds; i++)
 
 1267           WSANETWORKEVENTS ne;
 
 1271           WSAEnumNetworkEvents(fdp->
fd.sock, pEvents[i], &ne);
 
 1273           if (ne.lNetworkEvents & (FD_READ | FD_ACCEPT | FD_CLOSE))
 
 1276           if (ne.lNetworkEvents & (FD_WRITE | FD_CONNECT))
 
 1279           if (ne.lNetworkEvents & (FD_OOB))
 
 1282           if (ne.lNetworkEvents & (FD_READ | FD_ACCEPT | FD_CLOSE))
 
 1283               msgp += sprintf (msgp, 
"R:%Iu ", fdp->
fd.sock);
 
 1285           if (ne.lNetworkEvents & (FD_WRITE | FD_CONNECT))
 
 1286               msgp += sprintf (msgp, 
"W:%Iu ", fdp->
fd.sock);
 
 1288           if (ne.lNetworkEvents & (FD_OOB))
 
 1289               msgp += sprintf (msgp, 
"E:%Iu ", fdp->
fd.sock);
 
 1291           msgp += sprintf (msgp, 
"lNetworkEvents:%d ", ne.lNetworkEvents);
 
 1293           if(ne.lNetworkEvents)
 
 1296           WSAEventSelect(fdp->
fd.sock, pEvents[i], 0);
 
 1299       msgp += sprintf (msgp, 
"\n");
 
 1300       _dbus_verbose (
"%s",msg);
 
 1304       _dbus_verbose (
"WSAWaitForMultipleEvents: failed for unknown reason!");
 
 1308   for(i = 0; i < n_fds; i++)
 
 1310       WSACloseEvent(pEvents[i]);
 
 1313   if (n_fds > DBUS_STACK_WSAEVENTS)
 
 1320 #ifdef DBUS_ENABLE_VERBOSE_MODE 
 1321 #define DBUS_POLL_CHAR_BUFFER_SIZE 2000 
 1322   char msg[DBUS_POLL_CHAR_BUFFER_SIZE];
 
 1326   fd_set read_set, write_set, err_set;
 
 1332   FD_ZERO (&read_set);
 
 1333   FD_ZERO (&write_set);
 
 1337 #ifdef DBUS_ENABLE_VERBOSE_MODE 
 1339   msgp += sprintf (msgp, 
"select: to=%d\n\t", timeout_milliseconds);
 
 1340   for (i = 0; i < n_fds; i++)
 
 1346         msgp += sprintf (msgp, 
"R:%Iu ", fdp->
fd.sock);
 
 1349         msgp += sprintf (msgp, 
"W:%Iu ", fdp->
fd.sock);
 
 1351       msgp += sprintf (msgp, 
"E:%Iu\n\t", fdp->
fd.sock);
 
 1355       if (msgp >= msg + DBUS_POLL_CHAR_BUFFER_SIZE)
 
 1361   msgp += sprintf (msgp, 
"\n");
 
 1362   _dbus_verbose (
"%s",msg);
 
 1364   for (i = 0; i < n_fds; i++)
 
 1369         FD_SET (fdp->
fd.sock, &read_set);
 
 1372         FD_SET (fdp->
fd.sock, &write_set);
 
 1374       FD_SET (fdp->
fd.sock, &err_set);
 
 1376       max_fd = MAX (max_fd, fdp->
fd.sock);
 
 1380   tv.tv_sec = timeout_milliseconds < 0 ? 1 : timeout_milliseconds / 1000;
 
 1381   tv.tv_usec = timeout_milliseconds < 0 ? 0 : (timeout_milliseconds % 1000) * 1000;
 
 1383   ready = select (max_fd + 1, &read_set, &write_set, &err_set, &tv);
 
 1385   if (DBUS_SOCKET_API_RETURNS_ERROR (ready))
 
 1387       DBUS_SOCKET_SET_ERRNO ();
 
 1388       if (errno != WSAEWOULDBLOCK)
 
 1391   else if (ready == 0)
 
 1392     _dbus_verbose (
"select: = 0\n");
 
 1396 #ifdef DBUS_ENABLE_VERBOSE_MODE 
 1398         msgp += sprintf (msgp, 
"select: = %d:\n\t", ready);
 
 1400         for (i = 0; i < n_fds; i++)
 
 1404             if (FD_ISSET (fdp->
fd.sock, &read_set))
 
 1405               msgp += sprintf (msgp, 
"R:%Iu ", fdp->
fd.sock);
 
 1407             if (FD_ISSET (fdp->
fd.sock, &write_set))
 
 1408               msgp += sprintf (msgp, 
"W:%Iu ", fdp->
fd.sock);
 
 1410             if (FD_ISSET (fdp->
fd.sock, &err_set))
 
 1411               msgp += sprintf (msgp, 
"E:%Iu\n\t", fdp->
fd.sock);
 
 1413         msgp += sprintf (msgp, 
"\n");
 
 1414         _dbus_verbose (
"%s",msg);
 
 1417         for (i = 0; i < n_fds; i++)
 
 1423             if (FD_ISSET (fdp->
fd.sock, &read_set))
 
 1426             if (FD_ISSET (fdp->
fd.sock, &write_set))
 
 1429             if (FD_ISSET (fdp->
fd.sock, &err_set))
 
 1499   return _dbus_connect_tcp_socket_with_nonce (host, port, family, (
const char*)
NULL, error);
 
 1503 _dbus_connect_tcp_socket_with_nonce (
const char     *host,
 
 1506                                      const char     *noncefile,
 
 1511   struct addrinfo hints;
 
 1512   struct addrinfo *ai, *tmp;
 
 1514   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 1516   if (!_dbus_win_startup_winsock ())
 
 1518       _DBUS_SET_OOM (error);
 
 1519       return _dbus_socket_get_invalid ();
 
 1525     hints.ai_family = AF_UNSPEC;
 
 1526   else if (!strcmp(family, 
"ipv4"))
 
 1527     hints.ai_family = AF_INET;
 
 1528   else if (!strcmp(family, 
"ipv6"))
 
 1529     hints.ai_family = AF_INET6;
 
 1534                       "Unknown address family %s", family);
 
 1535       return _dbus_socket_get_invalid ();
 
 1537   hints.ai_protocol = IPPROTO_TCP;
 
 1538   hints.ai_socktype = SOCK_STREAM;
 
 1539 #ifdef AI_ADDRCONFIG 
 1540   hints.ai_flags = AI_ADDRCONFIG;
 
 1545   if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
 
 1549                       "Failed to lookup host/port: \"%s:%s\": %s (%d)",
 
 1550                       host, port, _dbus_strerror(res), res);
 
 1551       return _dbus_socket_get_invalid ();
 
 1557       if ((fd.sock = socket (tmp->ai_family, SOCK_STREAM, 0)) == INVALID_SOCKET)
 
 1559           DBUS_SOCKET_SET_ERRNO ();
 
 1562                           "Failed to open socket: %s",
 
 1565           return _dbus_socket_get_invalid ();
 
 1567       _DBUS_ASSERT_ERROR_IS_CLEAR(error);
 
 1569       if (connect (fd.sock, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) == SOCKET_ERROR)
 
 1571           DBUS_SOCKET_SET_ERRNO ();
 
 1572           closesocket(fd.sock);
 
 1573           fd.sock = INVALID_SOCKET;
 
 1582   if (!_dbus_socket_is_valid (fd))
 
 1586                       "Failed to connect to socket \"%s:%s\" %s",
 
 1588       return _dbus_socket_get_invalid ();
 
 1591   if (noncefile != 
NULL)
 
 1598           closesocket (fd.sock);
 
 1600           return _dbus_socket_get_invalid ();
 
 1603       ret = _dbus_send_nonce (fd, &noncefileStr, error);
 
 1609           closesocket (fd.sock);
 
 1610           return _dbus_socket_get_invalid ();
 
 1615   _dbus_win_handle_set_close_on_exec ((HANDLE) fd.sock);
 
 1619       closesocket (fd.sock);
 
 1620       return _dbus_socket_get_invalid ();
 
 1650   int nlisten_fd = 0, res, i, port_num = -1;
 
 1651   struct addrinfo hints;
 
 1652   struct addrinfo *ai, *tmp;
 
 1659         struct sockaddr Address;
 
 1660         struct sockaddr_in AddressIn;
 
 1661         struct sockaddr_in6 AddressIn6;
 
 1665   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 1667   if (!_dbus_win_startup_winsock ())
 
 1669       _DBUS_SET_OOM (error);
 
 1676     hints.ai_family = AF_INET;
 
 1677   else if (!strcmp(family, 
"ipv4"))
 
 1678     hints.ai_family = AF_INET;
 
 1679   else if (!strcmp(family, 
"ipv6"))
 
 1680     hints.ai_family = AF_INET6;
 
 1685                       "Unknown address family %s", family);
 
 1689   hints.ai_protocol = IPPROTO_TCP;
 
 1690   hints.ai_socktype = SOCK_STREAM;
 
 1691 #ifdef AI_ADDRCONFIG 
 1692   hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
 
 1694   hints.ai_flags = AI_PASSIVE;
 
 1697  redo_lookup_with_port:
 
 1698   if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
 
 1702                       "Failed to lookup host/port: \"%s:%s\": %s (%d)",
 
 1703                       host ? host : 
"*", port, _dbus_strerror(res), res);
 
 1710       DBusSocket fd = DBUS_SOCKET_INIT, *newlisten_fd;
 
 1711       if ((fd.sock = socket (tmp->ai_family, SOCK_STREAM, 0)) == INVALID_SOCKET)
 
 1713           DBUS_SOCKET_SET_ERRNO ();
 
 1716                          "Failed to open socket: %s",
 
 1720       _DBUS_ASSERT_ERROR_IS_CLEAR(error);
 
 1722       if (bind (fd.sock, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) == SOCKET_ERROR)
 
 1724           DBUS_SOCKET_SET_ERRNO ();
 
 1725           closesocket (fd.sock);
 
 1726           if (errno == WSAEADDRINUSE)
 
 1736                           "Failed to bind socket \"%s:%s\": %s",
 
 1741       if (listen (fd.sock, 30 ) == SOCKET_ERROR)
 
 1743           DBUS_SOCKET_SET_ERRNO ();
 
 1745                           "Failed to listen on socket \"%s:%s\": %s",
 
 1747           closesocket (fd.sock);
 
 1754           closesocket (fd.sock);
 
 1756                           "Failed to allocate file handle array");
 
 1759       listen_fd = newlisten_fd;
 
 1760       listen_fd[nlisten_fd] = fd;
 
 1763       if (!_dbus_string_get_length(retport))
 
 1769           if (!port || !strcmp(port, 
"0"))
 
 1771               mysockaddr_gen addr;
 
 1772               socklen_t addrlen = 
sizeof(addr);
 
 1773               char portbuf[NI_MAXSERV];
 
 1775               if (getsockname(fd.sock, &addr.Address, &addrlen) == SOCKET_ERROR ||
 
 1776                 (res = getnameinfo (&addr.Address, addrlen, 
NULL, 0,
 
 1777                                     portbuf, 
sizeof(portbuf),
 
 1778                                     NI_NUMERICSERV)) != 0)
 
 1780                   DBUS_SOCKET_SET_ERRNO ();
 
 1782                                   "Failed to resolve port \"%s:%s\": %s",
 
 1793               port = _dbus_string_get_const_data(retport);
 
 1795               goto redo_lookup_with_port;
 
 1814       _dbus_win_set_errno (WSAEADDRINUSE);
 
 1816                       "Failed to bind socket \"%s:%s\": %s",
 
 1821   sscanf(_dbus_string_get_const_data(retport), 
"%d", &port_num);
 
 1823   for (i = 0 ; i < nlisten_fd ; i++)
 
 1825       _dbus_win_handle_set_close_on_exec ((HANDLE) listen_fd[i].sock);
 
 1839   for (i = 0 ; i < nlisten_fd ; i++)
 
 1840     closesocket (listen_fd[i].sock);
 
 1859   client_fd.sock = accept (listen_fd.sock, 
NULL, 
NULL);
 
 1861   if (!_dbus_socket_is_valid (client_fd))
 
 1863       DBUS_SOCKET_SET_ERRNO ();
 
 1868   _dbus_verbose (
"client fd %Iu accepted\n", client_fd.sock);
 
 1910   if (bytes_written < 0 && errno == EINTR)
 
 1913   if (bytes_written < 0)
 
 1916                       "Failed to write credentials byte: %s",
 
 1920   else if (bytes_written == 0)
 
 1923                       "wrote zero bytes writing credentials byte");
 
 1929       _dbus_verbose (
"wrote 1 zero byte, credential sending isn't implemented yet\n");
 
 1971         _dbus_verbose (
"got one zero byte from server\n");
 
 1976   pid = _dbus_get_peer_pid_from_tcp_handle (handle.sock);
 
 1982   if (_dbus_getsid (&sid, pid))
 
 2009   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 2031   if (_dbus_string_get_length (dir) == 0 ||
 
 2032       _dbus_string_get_length (next_component) == 0)
 
 2036     (
'/' == _dbus_string_get_byte (dir, _dbus_string_get_length (dir) - 1) ||
 
 2037      '\\' == _dbus_string_get_byte (dir, _dbus_string_get_length (dir) - 1));
 
 2039   file_starts_with_slash =
 
 2040     (
'/' == _dbus_string_get_byte (next_component, 0) ||
 
 2041      '\\' == _dbus_string_get_byte (next_component, 0));
 
 2043   if (dir_ends_in_slash && file_starts_with_slash)
 
 2047   else if (!(dir_ends_in_slash || file_starts_with_slash))
 
 2054                             _dbus_string_get_length (dir));
 
 2071                     _dbus_string_get_const_data(username));
 
 2142   return GetCurrentProcessId ();
 
 2155 #define NANOSECONDS_PER_SECOND       1000000000 
 2157 #define MICROSECONDS_PER_SECOND      1000000 
 2159 #define MILLISECONDS_PER_SECOND      1000 
 2161 #define NANOSECONDS_PER_MILLISECOND  1000000 
 2163 #define MICROSECONDS_PER_MILLISECOND 1000 
 2172   Sleep (milliseconds);
 
 2190   GetSystemTimeAsFileTime (&ft);
 
 2192   memcpy (&time64, &ft, 
sizeof (time64));
 
 2201     *tv_sec = time64 / 1000000;
 
 2204     *tv_usec = time64 % 1000000;
 
 2242   const char *filename_c;
 
 2244   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 2246   filename_c = _dbus_string_get_const_data (filename);
 
 2248   if (!CreateDirectoryA (filename_c, 
NULL))
 
 2251                       "Failed to create directory %s: %s\n",
 
 2271   const char *filename_c;
 
 2273   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 2275   filename_c = _dbus_string_get_const_data (filename);
 
 2277   if (!CreateDirectoryA (filename_c, 
NULL))
 
 2279       if (GetLastError () == ERROR_ALREADY_EXISTS)
 
 2283                       "Failed to create directory %s: %s\n",
 
 2310   old_len = _dbus_string_get_length (str);
 
 2314       _DBUS_SET_OOM (error);
 
 2318   p = _dbus_string_get_udata_len (str, old_len, n_bytes);
 
 2320   if (!CryptAcquireContext (&hprov, 
NULL, 
NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
 
 2322       _DBUS_SET_OOM (error);
 
 2326   if (!CryptGenRandom (hprov, n_bytes, p))
 
 2328       _DBUS_SET_OOM (error);
 
 2329       CryptReleaseContext (hprov, 0);
 
 2333   CryptReleaseContext (hprov, 0);
 
 2348   static const char* tmpdir = 
NULL;
 
 2349   static char buf[1000];
 
 2356       unsigned char *last_slash;
 
 2357       unsigned char *p = (
unsigned char *)buf;
 
 2359       if (!GetTempPathA (
sizeof (buf), buf))
 
 2366       last_slash = _mbsrchr (p, 
'\\');
 
 2367       if (last_slash > p && last_slash[1] == 
'\0')
 
 2368         last_slash[0] = 
'\0';
 
 2369       last_slash = _mbsrchr (p, 
'/');
 
 2370       if (last_slash > p && last_slash[1] == 
'\0')
 
 2371         last_slash[0] = 
'\0';
 
 2396   const char *filename_c;
 
 2398   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 2400   filename_c = _dbus_string_get_const_data (filename);
 
 2402   if (DeleteFileA (filename_c) == 0)
 
 2405                       "Failed to delete file %s: %s\n",
 
 2413 #if !defined (DBUS_DISABLE_ASSERT) || defined(DBUS_ENABLE_EMBEDDED_TESTS) 
 2415 #if defined(_MSC_VER) || defined(DBUS_WINCE) 
 2446 #include <imagehlp.h> 
 2449 #define DPRINTF(fmt, ...) fprintf (stderr, fmt, ##__VA_ARGS__) 
 2457 static void dump_backtrace_for_thread (HANDLE hThread)
 
 2459   ADDRESS old_address;
 
 2465   SymSetOptions (SYMOPT_UNDNAME | SYMOPT_LOAD_LINES);
 
 2466   SymInitialize (GetCurrentProcess (), 
NULL, 
TRUE);
 
 2471   if (hThread == GetCurrentThread())
 
 2474   DPRINTF (
"Backtrace:\n");
 
 2478   context.ContextFlags = CONTEXT_FULL;
 
 2480   SuspendThread (hThread);
 
 2482   if (!GetThreadContext (hThread, &context))
 
 2484       DPRINTF (
"Couldn't get thread context (error %ld)\n", GetLastError ());
 
 2485       ResumeThread (hThread);
 
 2492   dwImageType         = IMAGE_FILE_MACHINE_I386;
 
 2493   sf.AddrFrame.Offset = context.Ebp;
 
 2494   sf.AddrFrame.Mode   = AddrModeFlat;
 
 2495   sf.AddrPC.Offset    = context.Eip;
 
 2496   sf.AddrPC.Mode      = AddrModeFlat;
 
 2497 #elif defined(_M_X64) 
 2498   dwImageType         = IMAGE_FILE_MACHINE_AMD64;
 
 2499   sf.AddrPC.Offset    = context.Rip;
 
 2500   sf.AddrPC.Mode      = AddrModeFlat;
 
 2501   sf.AddrFrame.Offset = context.Rsp;
 
 2502   sf.AddrFrame.Mode   = AddrModeFlat;
 
 2503   sf.AddrStack.Offset = context.Rsp;
 
 2504   sf.AddrStack.Mode   = AddrModeFlat;
 
 2505 #elif defined(_M_IA64) 
 2506   dwImageType         = IMAGE_FILE_MACHINE_IA64;
 
 2507   sf.AddrPC.Offset    = context.StIIP;
 
 2508   sf.AddrPC.Mode      = AddrModeFlat;
 
 2509   sf.AddrFrame.Offset = context.IntSp;
 
 2510   sf.AddrFrame.Mode   = AddrModeFlat;
 
 2511   sf.AddrBStore.Offset= context.RsBSP;
 
 2512   sf.AddrBStore.Mode  = AddrModeFlat;
 
 2513   sf.AddrStack.Offset = context.IntSp;
 
 2514   sf.AddrStack.Mode   = AddrModeFlat;
 
 2516 # error You need to fill in the STACKFRAME structure for your architecture 
 2525   while (StackWalk (dwImageType, GetCurrentProcess (),
 
 2526                     hThread, &sf, &context, 
NULL, SymFunctionTableAccess,
 
 2527                     SymGetModuleBase, 
NULL))
 
 2529       char buffer[
sizeof(SYMBOL_INFO) + MAX_SYM_NAME * 
sizeof(
char)];
 
 2530       PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)buffer;
 
 2531       DWORD64 displacement;
 
 2533       DWORD dwDisplacement;
 
 2534       IMAGEHLP_MODULE moduleInfo;
 
 2542       if (old_address.Offset == sf.AddrPC.Offset)
 
 2548       pSymbol->SizeOfStruct = 
sizeof(SYMBOL_INFO);
 
 2549       pSymbol->MaxNameLen = MAX_SYM_NAME;
 
 2551       if (SymFromAddr (GetCurrentProcess (), sf.AddrPC.Offset, &displacement, pSymbol))
 
 2554             DPRINTF (
"%3d %s+0x%I64x", i++, pSymbol->Name, displacement);
 
 2556             DPRINTF (
"%3d %s", i++, pSymbol->Name);
 
 2559         DPRINTF (
"%3d 0x%Ix", i++, sf.AddrPC.Offset);
 
 2561       line.SizeOfStruct = 
sizeof(IMAGEHLP_LINE);
 
 2562       if (SymGetLineFromAddr (GetCurrentProcess (), sf.AddrPC.Offset, &dwDisplacement, &line))
 
 2564           DPRINTF (
" [%s:%ld]", line.FileName, line.LineNumber);
 
 2567       moduleInfo.SizeOfStruct = 
sizeof(moduleInfo);
 
 2568       if (SymGetModuleInfo (GetCurrentProcess (), sf.AddrPC.Offset, &moduleInfo))
 
 2570           DPRINTF (
" in %s", moduleInfo.ModuleName);
 
 2573       old_address = sf.AddrPC;
 
 2575   ResumeThread (hThread);
 
 2578 static DWORD WINAPI dump_thread_proc (LPVOID lpParameter)
 
 2580   dump_backtrace_for_thread ((HANDLE) lpParameter);
 
 2587 dump_backtrace (
void)
 
 2589   HANDLE hCurrentThread;
 
 2592   DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
 
 2593                    GetCurrentProcess (), &hCurrentThread,
 
 2594                    0, 
FALSE, DUPLICATE_SAME_ACCESS);
 
 2595   hThread = CreateThread (
NULL, 0, dump_thread_proc, (LPVOID)hCurrentThread,
 
 2597   WaitForSingleObject (hThread, INFINITE);
 
 2598   CloseHandle (hThread);
 
 2599   CloseHandle (hCurrentThread);
 
 2612   _dbus_verbose (
"  D-Bus not compiled with backtrace support\n");
 
 2618     if(ascii >= 
'0' && ascii <= 
'9')
 
 2620     if(ascii >= 
'A' && ascii <= 
'F')
 
 2621         return ascii - 
'A' + 10;
 
 2622     if(ascii >= 
'a' && ascii <= 
'f')
 
 2623         return ascii - 
'a' + 10;
 
 2635     HW_PROFILE_INFOA info;
 
 2636     char *lpc = &info.szHwProfileGuid[0];
 
 2640     if(!GetCurrentHwProfileA(&info))
 
 2649     u = ((fromAscii(lpc[0]) <<  0) |
 
 2650          (fromAscii(lpc[1]) <<  4) |
 
 2651          (fromAscii(lpc[2]) <<  8) |
 
 2652          (fromAscii(lpc[3]) << 12) |
 
 2653          (fromAscii(lpc[4]) << 16) |
 
 2654          (fromAscii(lpc[5]) << 20) |
 
 2655          (fromAscii(lpc[6]) << 24) |
 
 2656          (fromAscii(lpc[7]) << 28));
 
 2661     u = ((fromAscii(lpc[0]) <<  0) |
 
 2662          (fromAscii(lpc[1]) <<  4) |
 
 2663          (fromAscii(lpc[2]) <<  8) |
 
 2664          (fromAscii(lpc[3]) << 12) |
 
 2665          (fromAscii(lpc[5]) << 16) |
 
 2666          (fromAscii(lpc[6]) << 20) |
 
 2667          (fromAscii(lpc[7]) << 24) |
 
 2668          (fromAscii(lpc[8]) << 28));
 
 2673     u = ((fromAscii(lpc[0]) <<  0) |
 
 2674          (fromAscii(lpc[1]) <<  4) |
 
 2675          (fromAscii(lpc[2]) <<  8) |
 
 2676          (fromAscii(lpc[3]) << 12) |
 
 2677          (fromAscii(lpc[5]) << 16) |
 
 2678          (fromAscii(lpc[6]) << 20) |
 
 2679          (fromAscii(lpc[7]) << 24) |
 
 2680          (fromAscii(lpc[8]) << 28));
 
 2685     u = ((fromAscii(lpc[0]) <<  0) |
 
 2686          (fromAscii(lpc[1]) <<  4) |
 
 2687          (fromAscii(lpc[2]) <<  8) |
 
 2688          (fromAscii(lpc[3]) << 12) |
 
 2689          (fromAscii(lpc[4]) << 16) |
 
 2690          (fromAscii(lpc[5]) << 20) |
 
 2691          (fromAscii(lpc[6]) << 24) |
 
 2692          (fromAscii(lpc[7]) << 28));
 
 2699 HANDLE _dbus_global_lock (
const char *mutexname)
 
 2704   mutex = CreateMutexA( 
NULL, 
FALSE, mutexname );
 
 2710    gotMutex = WaitForSingleObject( mutex, INFINITE );
 
 2713        case WAIT_ABANDONED:
 
 2714                ReleaseMutex (mutex);
 
 2715                CloseHandle (mutex);
 
 2726 void _dbus_global_unlock (HANDLE mutex)
 
 2728   ReleaseMutex (mutex);
 
 2729   CloseHandle (mutex); 
 
 2733 static HANDLE hDBusDaemonMutex = 
NULL;
 
 2734 static HANDLE hDBusSharedMem = 
NULL;
 
 2736 static const char *cUniqueDBusInitMutex = 
"UniqueDBusInitMutex";
 
 2738 static const char *cDBusAutolaunchMutex = 
"DBusAutolaunchMutex";
 
 2740 static const char *cDBusDaemonMutex = 
"DBusDaemonMutex";
 
 2742 static const char *cDBusDaemonAddressInfo = 
"DBusDaemonAddressInfo";
 
 2745 _dbus_get_install_root_as_hash(
DBusString *out)
 
 2751     if (!_dbus_get_install_root (&install_path) ||
 
 2752         _dbus_string_get_length (&install_path) == 0)
 
 2765 _dbus_get_address_string (
DBusString *out, 
const char *basestring, 
const char *scope)
 
 2774   else if (strcmp(scope,
"*install-path") == 0
 
 2776         || strcmp(scope,
"install-path") == 0)
 
 2779       if (!_dbus_get_install_root_as_hash(&temp))
 
 2788   else if (strcmp(scope,
"*user") == 0)
 
 2797   else if (strlen(scope) > 0)
 
 2807 _dbus_get_shm_name (
DBusString *out,
const char *scope)
 
 2809   return _dbus_get_address_string (out,cDBusDaemonAddressInfo,scope);
 
 2813 _dbus_get_mutex_name (
DBusString *out,
const char *scope)
 
 2815   return _dbus_get_address_string (out,cDBusDaemonMutex,scope);
 
 2819 _dbus_daemon_is_session_bus_address_published (
const char *scope)
 
 2824   if (!_dbus_get_mutex_name(&mutex_name,scope))
 
 2830   if (hDBusDaemonMutex)
 
 2834   lock = _dbus_global_lock( cUniqueDBusInitMutex );
 
 2838   hDBusDaemonMutex = CreateMutexA( 
NULL, 
FALSE, _dbus_string_get_const_data(&mutex_name) );
 
 2844   _dbus_global_unlock( lock );
 
 2848   if (hDBusDaemonMutex  == 
NULL)
 
 2850   if (GetLastError() == ERROR_ALREADY_EXISTS)
 
 2852       CloseHandle(hDBusDaemonMutex);
 
 2853       hDBusDaemonMutex = 
NULL;
 
 2863 _dbus_daemon_publish_session_bus_address (
const char* address, 
const char *scope)
 
 2866   char *shared_addr = 
NULL;
 
 2873   if (!_dbus_get_mutex_name(&mutex_name,scope))
 
 2880   lock = _dbus_global_lock( cUniqueDBusInitMutex );
 
 2882   if (!hDBusDaemonMutex)
 
 2884       hDBusDaemonMutex = CreateMutexA( 
NULL, 
FALSE, _dbus_string_get_const_data(&mutex_name) );
 
 2889   if (WaitForSingleObject( hDBusDaemonMutex, 10 ) != WAIT_OBJECT_0)
 
 2891       _dbus_global_unlock( lock );
 
 2892       CloseHandle( hDBusDaemonMutex );
 
 2896   if (!_dbus_get_shm_name(&shm_name,scope))
 
 2899       _dbus_global_unlock( lock );
 
 2904   len = strlen (address) + 1;
 
 2906   hDBusSharedMem = CreateFileMappingA( INVALID_HANDLE_VALUE, 
NULL, PAGE_READWRITE,
 
 2907                                        len >> 32, len & 0xffffffffu,
 
 2908                                        _dbus_string_get_const_data(&shm_name) );
 
 2911   shared_addr = MapViewOfFile( hDBusSharedMem, FILE_MAP_WRITE, 0, 0, 0 );
 
 2915   strcpy( shared_addr, address);
 
 2918   UnmapViewOfFile( shared_addr );
 
 2920   _dbus_global_unlock( lock );
 
 2921   _dbus_verbose( 
"published session bus address at %s\n",_dbus_string_get_const_data (&shm_name) );
 
 2928 _dbus_daemon_unpublish_session_bus_address (
void)
 
 2933   lock = _dbus_global_lock( cUniqueDBusInitMutex );
 
 2935   CloseHandle( hDBusSharedMem );
 
 2937   hDBusSharedMem = 
NULL;
 
 2939   ReleaseMutex( hDBusDaemonMutex );
 
 2941   CloseHandle( hDBusDaemonMutex );
 
 2943   hDBusDaemonMutex = 
NULL;
 
 2945   _dbus_global_unlock( lock );
 
 2958       sharedMem = OpenFileMappingA( FILE_MAP_READ, 
FALSE, _dbus_string_get_const_data(shm_name));
 
 2959       if( sharedMem == 0 )
 
 2961       if ( sharedMem != 0)
 
 2965   if( sharedMem == 0 )
 
 2968   shared_addr = MapViewOfFile( sharedMem, FILE_MAP_READ, 0, 0, 0 );
 
 2978   UnmapViewOfFile( shared_addr );
 
 2980   CloseHandle( sharedMem );
 
 2993   if (!_dbus_get_mutex_name(&mutex_name,scope))
 
 3000   lock = _dbus_global_lock( cUniqueDBusInitMutex );
 
 3003   daemon = CreateMutexA( 
NULL, 
FALSE, _dbus_string_get_const_data(&mutex_name) );
 
 3004   if(WaitForSingleObject( daemon, 10 ) != WAIT_TIMEOUT)
 
 3006       ReleaseMutex (daemon);
 
 3007       CloseHandle (daemon);
 
 3009       _dbus_global_unlock( lock );
 
 3015   bRet = _dbus_get_autolaunch_shm( address, shm_name );
 
 3018   CloseHandle ( daemon );
 
 3020   _dbus_global_unlock( lock );
 
 3032   PROCESS_INFORMATION pi;
 
 3035   char dbus_exe_path[MAX_PATH];
 
 3036   char dbus_args[MAX_PATH * 2];
 
 3037   const char * daemon_name = DBUS_DAEMON_NAME 
".exe";
 
 3040   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 3042   if (!_dbus_get_shm_name(&shm_name,scope))
 
 3048   mutex = _dbus_global_lock ( cDBusAutolaunchMutex );
 
 3050   if (_dbus_daemon_already_runs(address,&shm_name,scope))
 
 3052         _dbus_verbose( 
"found running dbus daemon for scope '%s' at %s\n",
 
 3053                        scope ? scope : 
"", _dbus_string_get_const_data (&shm_name) );
 
 3058   if (!SearchPathA(
NULL, daemon_name, 
NULL, 
sizeof(dbus_exe_path), dbus_exe_path, &lpFile))
 
 3062       char dbus_module_path[MAX_PATH];
 
 3065       _dbus_verbose( 
"did not found dbus daemon executable on default search path, " 
 3066             "trying path where dbus shared library is located");
 
 3068       hmod = _dbus_win_get_dll_hmodule();
 
 3069       rc = GetModuleFileNameA(hmod, dbus_module_path, 
sizeof(dbus_module_path));
 
 3078           char *ext_idx = strrchr(dbus_module_path, 
'\\');
 
 3081           if (!SearchPathA(dbus_module_path, daemon_name, 
NULL, 
sizeof(dbus_exe_path), dbus_exe_path, &lpFile))
 
 3085               printf (
"please add the path to %s to your PATH environment variable\n", daemon_name);
 
 3086               printf (
"or start the daemon manually\n\n");
 
 3089           _dbus_verbose( 
"found dbus daemon executable at %s",dbus_module_path);
 
 3095   ZeroMemory( &si, 
sizeof(si) );
 
 3097   ZeroMemory( &pi, 
sizeof(pi) );
 
 3099   _snprintf(dbus_args, 
sizeof(dbus_args) - 1, 
"\"%s\" %s", dbus_exe_path,  
" --session");
 
 3103   if(CreateProcessA(dbus_exe_path, dbus_args, 
NULL, 
NULL, 
FALSE, CREATE_NO_WINDOW, 
NULL, 
NULL, &si, &pi))
 
 3105       CloseHandle (pi.hThread);
 
 3106       CloseHandle (pi.hProcess);
 
 3107       retval = _dbus_get_autolaunch_shm( address, &shm_name );
 
 3108       if (retval == 
FALSE)
 
 3119     _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 3121     _DBUS_ASSERT_ERROR_IS_SET (error);
 
 3123   _dbus_global_unlock (mutex);
 
 3156   return InterlockedIncrement (&atomic->
value) - 1;
 
 3171   return InterlockedDecrement (&atomic->
value) + 1;
 
 3194   InterlockedExchange (&dummy, 1);
 
 3196   return atomic->
value;
 
 3220   return e == WSAEWOULDBLOCK;
 
 3234     DWORD pathLength = MAX_PATH;
 
 3235     unsigned char *lastSlash;
 
 3236     unsigned char *prefix;
 
 3248         pathLength = GetModuleFileNameA (_dbus_win_get_dll_hmodule (),
 
 3249             _dbus_string_get_data (str), _dbus_string_get_length (str));
 
 3251         if (pathLength == 0 || GetLastError () != 0)
 
 3260         if (pathLength < (DWORD) _dbus_string_get_length (str))
 
 3279     prefix = _dbus_string_get_udata (str);
 
 3281     lastSlash = _mbsrchr (prefix, 
'\\');
 
 3282     if (lastSlash == 
NULL) {
 
 3295     if (lastSlash - prefix >= 4 && _mbsnicmp (lastSlash - 4, (
const unsigned char *)
"\\bin", 4) == 0)
 
 3297     else if (lastSlash - prefix >= 10 && _mbsnicmp (lastSlash - 10, (
const unsigned char *)
"\\bin\\debug", 10) == 0)
 
 3299     else if (lastSlash - prefix >= 12 && _mbsnicmp (lastSlash - 12, (
const unsigned char *)
"\\bin\\release", 12) == 0)
 
 3338   const char *homepath;
 
 3339   const char *homedrive;
 
 3348   if (homedrive != 
NULL && *homedrive != 
'\0')
 
 3354   if (homepath != 
NULL && *homepath != 
'\0')
 
 3359 #ifdef DBUS_ENABLE_EMBEDDED_TESTS 
 3361     const char *
override;
 
 3364     if (
override != 
NULL && *
override != 
'\0')
 
 3370         _dbus_verbose (
"Using fake homedir for testing: %s\n",
 
 3371                        _dbus_string_get_const_data (&homedir));
 
 3378         if (!already_warned)
 
 3380             _dbus_warn (
"Using your real home directory for testing, set DBUS_TEST_HOMEDIR to avoid");
 
 3381             already_warned = 
TRUE;
 
 3390 #define KEYRING_DIR "dbus-keyrings" 
 3392 #define KEYRING_DIR ".dbus-keyrings" 
 3401                           directory, _dbus_string_get_length (directory))) {
 
 3421   DWORD attributes = GetFileAttributesA (file);
 
 3423   if (attributes != INVALID_FILE_ATTRIBUTES && GetLastError() != ERROR_PATH_NOT_FOUND)
 
 3437 _dbus_strerror (
int error_number)
 
 3445   switch (error_number)
 
 3448       return "Interrupted function call";
 
 3450       return "Permission denied";
 
 3452       return "Bad address";
 
 3454       return "Invalid argument";
 
 3456       return "Too many open files";
 
 3457     case WSAEWOULDBLOCK:
 
 3458       return "Resource temporarily unavailable";
 
 3459     case WSAEINPROGRESS:
 
 3460       return "Operation now in progress";
 
 3462       return "Operation already in progress";
 
 3464       return "Socket operation on nonsocket";
 
 3465     case WSAEDESTADDRREQ:
 
 3466       return "Destination address required";
 
 3468       return "Message too long";
 
 3470       return "Protocol wrong type for socket";
 
 3471     case WSAENOPROTOOPT:
 
 3472       return "Bad protocol option";
 
 3473     case WSAEPROTONOSUPPORT:
 
 3474       return "Protocol not supported";
 
 3475     case WSAESOCKTNOSUPPORT:
 
 3476       return "Socket type not supported";
 
 3478       return "Operation not supported";
 
 3479     case WSAEPFNOSUPPORT:
 
 3480       return "Protocol family not supported";
 
 3481     case WSAEAFNOSUPPORT:
 
 3482       return "Address family not supported by protocol family";
 
 3484       return "Address already in use";
 
 3485     case WSAEADDRNOTAVAIL:
 
 3486       return "Cannot assign requested address";
 
 3488       return "Network is down";
 
 3489     case WSAENETUNREACH:
 
 3490       return "Network is unreachable";
 
 3492       return "Network dropped connection on reset";
 
 3493     case WSAECONNABORTED:
 
 3494       return "Software caused connection abort";
 
 3496       return "Connection reset by peer";
 
 3498       return "No buffer space available";
 
 3500       return "Socket is already connected";
 
 3502       return "Socket is not connected";
 
 3504       return "Cannot send after socket shutdown";
 
 3506       return "Connection timed out";
 
 3507     case WSAECONNREFUSED:
 
 3508       return "Connection refused";
 
 3510       return "Host is down";
 
 3511     case WSAEHOSTUNREACH:
 
 3512       return "No route to host";
 
 3514       return "Too many processes";
 
 3516       return "Graceful shutdown in progress";
 
 3517     case WSATYPE_NOT_FOUND:
 
 3518       return "Class type not found";
 
 3519     case WSAHOST_NOT_FOUND:
 
 3520       return "Host not found";
 
 3522       return "Nonauthoritative host not found";
 
 3523     case WSANO_RECOVERY:
 
 3524       return "This is a nonrecoverable error";
 
 3526       return "Valid name, no data record of requested type";
 
 3527     case WSA_INVALID_HANDLE:
 
 3528       return "Specified event object handle is invalid";
 
 3529     case WSA_INVALID_PARAMETER:
 
 3530       return "One or more parameters are invalid";
 
 3531     case WSA_IO_INCOMPLETE:
 
 3532       return "Overlapped I/O event object not in signaled state";
 
 3533     case WSA_IO_PENDING:
 
 3534       return "Overlapped operations will complete later";
 
 3535     case WSA_NOT_ENOUGH_MEMORY:
 
 3536       return "Insufficient memory available";
 
 3537     case WSA_OPERATION_ABORTED:
 
 3538       return "Overlapped operation aborted";
 
 3539 #ifdef WSAINVALIDPROCTABLE 
 3541     case WSAINVALIDPROCTABLE:
 
 3542       return "Invalid procedure table from service provider";
 
 3544 #ifdef WSAINVALIDPROVIDER 
 3546     case WSAINVALIDPROVIDER:
 
 3547       return "Invalid service provider version number";
 
 3549 #ifdef WSAPROVIDERFAILEDINIT 
 3551     case WSAPROVIDERFAILEDINIT:
 
 3552       return "Unable to initialize a service provider";
 
 3555     case WSASYSCALLFAILURE:
 
 3556       return "System call failure";
 
 3559       msg = strerror (error_number);
 
 3577 _dbus_win_set_error_from_win_error (
DBusError *error,
 
 3583   FormatMessageA (FORMAT_MESSAGE_ALLOCATE_BUFFER |
 
 3584                   FORMAT_MESSAGE_IGNORE_INSERTS |
 
 3585                   FORMAT_MESSAGE_FROM_SYSTEM,
 
 3586                   NULL, code, MAKELANGID (LANG_ENGLISH, SUBLANG_ENGLISH_US),
 
 3587                   (LPSTR) &msg, 0, 
NULL);
 
 3594     dbus_set_error (error, 
"win32.error", 
"Unknown error code %d or FormatMessage failed", code);
 
 3598 _dbus_win_warn_win_error (
const char *message,
 
 3604   _dbus_win_set_error_from_win_error (&error, code);
 
 3620   const char *filename_c;
 
 3622   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 3624   filename_c = _dbus_string_get_const_data (filename);
 
 3626   if (RemoveDirectoryA (filename_c) == 0)
 
 3628       char *emsg = _dbus_win_error_string (GetLastError ());
 
 3630                       "Failed to remove directory %s: %s",
 
 3632       _dbus_win_free_error_string (emsg);
 
 3648   if (_dbus_string_get_length (filename) > 0)
 
 3649     return _dbus_string_get_byte (filename, 1) == 
':' 
 3650            || _dbus_string_get_byte (filename, 0) == 
'\\' 
 3651            || _dbus_string_get_byte (filename, 0) == 
'/';
 
 3663 _dbus_save_socket_errno (
void)
 
 3669 _dbus_restore_socket_errno (
int saved_errno)
 
 3671   _dbus_win_set_errno (saved_errno);
 
 3674 static const char *log_tag = 
"dbus";
 
 3675 static DBusLogFlags log_flags = DBUS_LOG_FLAGS_STDERR;
 
 3693       (flags & (DBUS_LOG_FLAGS_STDERR | DBUS_LOG_FLAGS_SYSTEM_LOG)) != 0);
 
 3716      case DBUS_SYSTEM_LOG_INFO: s = 
"info"; 
break;
 
 3717      case DBUS_SYSTEM_LOG_WARNING: s = 
"warning"; 
break;
 
 3718      case DBUS_SYSTEM_LOG_SECURITY: s = 
"security"; 
break;
 
 3719      case DBUS_SYSTEM_LOG_ERROR: s = 
"error"; 
break;
 
 3723   if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
 
 3728       DBUS_VA_COPY (tmp, args);
 
 3729       snprintf (format, 
sizeof (format), 
"%s: %s", s, msg);
 
 3730       vsnprintf(buf, 
sizeof(buf), format, tmp);
 
 3731       OutputDebugStringA(buf);
 
 3735   if (log_flags & DBUS_LOG_FLAGS_STDERR)
 
 3737       DBUS_VA_COPY (tmp, args);
 
 3739       vfprintf (stderr, msg, tmp);
 
 3740       fprintf (stderr, 
"\n");