#define socklen_t int
#endif
+#ifdef ENABLE_DBUSSOCKET
_DBUS_DEFINE_GLOBAL_LOCK (win_fds);
+#endif
+
_DBUS_DEFINE_GLOBAL_LOCK (sid_atom_cache);
#ifdef ENABLE_DBUSUSERINFO
} DBusUserInfo;
#endif
+#ifdef ENABLE_DBUSSOCKET
static
void
_dbus_lock_sockets()
_dbus_assert (win_fds!=0);
_DBUS_UNLOCK (win_fds);
}
+#endif
#ifdef _DBUS_WIN_USE_RANDOMIZER
static int win_encap_randomizer;
*
*/
+#ifdef ENABLE_DBUSSOCKET
static DBusSocket *win_fds = NULL;
static int win_n_fds = 0; // is this the size? rename to win_fds_size? #
+
#if 0
#define TO_HANDLE(n) ((n)^win32_encap_randomizer)
#define FROM_HANDLE(n) ((n)^win32_encap_randomizer)
_dbus_unlock_sockets();
}
+
#undef TO_HANDLE
#undef IS_HANDLE
#undef FROM_HANDLE
#define win_fds 1==DBUS_WIN_DONT_USE_win_fds_DIRECTLY
-
+#endif
/**
* Thin wrapper around the read() system call that appends
DBusString *buffer,
int count)
{
+#ifdef ENABLE_DBUSSOCKET
DBusSocket *s;
+#endif
int bytes_read;
int start;
char *data;
data = _dbus_string_get_data_len (buffer, start, count);
+#ifdef ENABLE_DBUSSOCKET
_dbus_handle_to_socket(handle, &s);
if(s->is_used)
{
_dbus_verbose ("recv: count=%d socket=%d\n", count, s->fd);
bytes_read = recv (s->fd, data, count, 0);
+#else
+ if(1)
+ {
+ _dbus_verbose ("recv: count=%d socket=%d\n", count, handle);
+ bytes_read = recv (handle, data, count, 0);
+#endif
if (bytes_read == SOCKET_ERROR)
{
DBUS_SOCKET_SET_ERRNO();
int start,
int len)
{
+#ifdef ENABLE_DBUSSOCKET
DBusSocket *s;
+#endif
int is_used;
const char *data;
int bytes_written;
data = _dbus_string_get_const_data_len (buffer, start, len);
+#ifdef ENABLE_DBUSSOCKET
_dbus_handle_to_socket(handle, &s);
if (s->is_used)
{
_dbus_verbose ("send: len=%d socket=%d\n", len, s->fd);
bytes_written = send (s->fd, data, len, 0);
+#else
+ if (1)
+ {
+ _dbus_verbose ("send: len=%d socket=%d\n", len, handle);
+ bytes_written = send (handle, data, len, 0);
+#endif
if (bytes_written == SOCKET_ERROR)
{
DBUS_SOCKET_SET_ERRNO();
_dbus_close_socket (int handle,
DBusError *error)
{
+#ifdef ENABLE_DBUSSOCKET
DBusSocket *s;
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
return TRUE;
+#else
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+
+ if (1)
+ {
+ if (closesocket (handle) == SOCKET_ERROR)
+ {
+ DBUS_SOCKET_SET_ERRNO ();
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Could not close socket: socket=%d, , %s",
+ handle, _dbus_strerror (errno));
+ return FALSE;
+ }
+ _dbus_verbose ("_dbus_close_socket: socket=%d, \n",
+ handle);
+ }
+ else
+ {
+ _dbus_assert_not_reached ("unhandled fd type");
+ }
+
+ return TRUE;
+#endif
+
}
/**
void
_dbus_fd_set_close_on_exec (int handle)
{
+#ifdef ENABLE_DBUSSOCKET
DBusSocket *s;
if (handle < 0)
return;
s->close_on_exec = TRUE;
_dbus_unlock_sockets();
+#else
+ /* TODO unic code.
+ int val;
+
+ val = fcntl (fd, F_GETFD, 0);
+
+ if (val < 0)
+ return;
+
+ val |= FD_CLOEXEC;
+
+ fcntl (fd, F_SETFD, val);
+ */
+#endif
}
/**
_dbus_set_fd_nonblocking (int handle,
DBusError *error)
{
+#ifdef ENABLE_DBUSSOCKET
DBusSocket *s;
u_long one = 1;
_dbus_unlock_sockets();
return TRUE;
+#else
+ u_long one = 1;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+ if (1)
+ {
+ if (ioctlsocket (handle, FIONBIO, &one) == SOCKET_ERROR)
+ {
+ dbus_set_error (error, _dbus_error_from_errno (WSAGetLastError ()),
+ "Failed to set socket %d:%d to nonblocking: %s", handle,
+ _dbus_strerror (WSAGetLastError ()));
+ return FALSE;
+ }
+ }
+ else
+ {
+ _dbus_assert_not_reached ("unhandled fd type");
+ }
+ return TRUE;
+#endif
}
int start2,
int len2)
{
+#ifdef ENABLE_DBUSSOCKET
DBusSocket *s;
WSABUF vectors[2];
const char *data1;
_dbus_assert_not_reached ("unhandled fd type");
}
return 0;
+#else
+ WSABUF vectors[2];
+ const char *data1;
+ const char *data2;
+ int rc;
+ DWORD bytes_written;
+ int ret1;
+
+ _dbus_assert (buffer1 != NULL);
+ _dbus_assert (start1 >= 0);
+ _dbus_assert (start2 >= 0);
+ _dbus_assert (len1 >= 0);
+ _dbus_assert (len2 >= 0);
+
+
+ data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
+
+ if (buffer2 != NULL)
+ data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
+ else
+ {
+ data2 = NULL;
+ start2 = 0;
+ len2 = 0;
+ }
+
+ if (1)
+ {
+ vectors[0].buf = (char*) data1;
+ vectors[0].len = len1;
+ vectors[1].buf = (char*) data2;
+ vectors[1].len = len2;
+
+ _dbus_verbose ("WSASend: len1+2=%d+%d socket=%d\n", len1, len2, handle);
+ rc = WSASend (handle, vectors, data2 ? 2 : 1, &bytes_written,
+ 0, NULL, NULL);
+ if (rc < 0)
+ {
+ DBUS_SOCKET_SET_ERRNO ();
+ _dbus_verbose ("WSASend: failed: %s\n", _dbus_strerror (errno));
+ bytes_written = -1;
+ }
+ else
+ _dbus_verbose ("WSASend: = %ld\n", bytes_written);
+ return bytes_written;
+ }
+ else
+ {
+ _dbus_assert_not_reached ("unhandled fd type");
+ }
+ return 0;
+#endif
}
#if 0
u_long arg;
fd_set read_set, write_set;
struct timeval tv;
+#ifdef ENABLE_DBUSSOCKET
DBusSocket sock;
+#endif
_dbus_win_startup_winsock ();
}
}
+#ifdef ENABLE_DBUSSOCKET
sock.fd = socket1;
*fd1 = _dbus_socket_to_handle (&sock);
sock.fd = socket2;
*fd2 = _dbus_socket_to_handle (&sock);
+#else
+ *fd1 = socket1;
+ *fd2 = socket2;
+#endif
_dbus_verbose ("full-duplex pipe %d:%d <-> %d:%d\n",
*fd1, socket1, *fd2, socket2);
#else // USE_CHRIS_IMPL
+#ifdef ENABLE_DBUSSOCKET
+
int
_dbus_poll (DBusPollFD *fds,
int n_fds,
}
return ready;
}
+#else // ENABLE_DBUSSOCKET
+
+int
+_dbus_poll (DBusPollFD *fds,
+ int n_fds,
+ int timeout_milliseconds)
+{
+#define DBUS_POLL_CHAR_BUFFER_SIZE 2000
+ char msg[DBUS_POLL_CHAR_BUFFER_SIZE];
+ char *msgp;
+
+ fd_set read_set, write_set, err_set;
+ int max_fd = 0;
+ int i;
+ struct timeval tv;
+ int ready;
+
+ FD_ZERO (&read_set);
+ FD_ZERO (&write_set);
+ FD_ZERO (&err_set);
+
+
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+ msgp = msg;
+ msgp += sprintf (msgp, "select: to=%d\n\t", timeout_milliseconds);
+ for (i = 0; i < n_fds; i++)
+ {
+ static dbus_bool_t warned = FALSE;
+ int fd;
+ DBusPollFD *fdp = &fds[i];
+ fd = fdp->fd;
+
+
+ if (fdp->events & _DBUS_POLLIN)
+ msgp += sprintf (msgp, "R:%d ", fd);
+
+ if (fdp->events & _DBUS_POLLOUT)
+ msgp += sprintf (msgp, "W:%d ", fd);
+
+ msgp += sprintf (msgp, "E:%d\n\t", fd);
+
+ // FIXME: more robust code for long msg
+ // create on heap when msg[] becomes too small
+ if (msgp >= msg + DBUS_POLL_CHAR_BUFFER_SIZE)
+ {
+ _dbus_assert_not_reached ("buffer overflow in _dbus_poll");
+ }
+ }
+
+ msgp += sprintf (msgp, "\n");
+ _dbus_verbose ("%s",msg);
+#endif
+ for (i = 0; i < n_fds; i++)
+ {
+ int fd;
+ DBusPollFD *fdp = &fds[i];
+ fd = fdp->fd;
+
+ if (fdp->events & _DBUS_POLLIN)
+ FD_SET (fd, &read_set);
+
+ if (fdp->events & _DBUS_POLLOUT)
+ FD_SET (fd, &write_set);
+
+ FD_SET (fd, &err_set);
+
+ max_fd = MAX (max_fd, fd);
+ }
+
+
+ tv.tv_sec = timeout_milliseconds / 1000;
+ tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
+
+ ready = select (max_fd + 1, &read_set, &write_set, &err_set,
+ timeout_milliseconds < 0 ? NULL : &tv);
+
+ if (DBUS_SOCKET_API_RETURNS_ERROR (ready))
+ {
+ DBUS_SOCKET_SET_ERRNO ();
+ if (errno != EWOULDBLOCK)
+ _dbus_verbose ("select: failed: %s\n", _dbus_strerror (errno));
+ }
+ else if (ready == 0)
+ _dbus_verbose ("select: = 0\n");
+ else
+ if (ready > 0)
+ {
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+ msgp = msg;
+ msgp += sprintf (msgp, "select: = %d:\n\t", ready);
+
+ for (i = 0; i < n_fds; i++)
+ {
+ int fd;
+ DBusPollFD *fdp = &fds[i];
+ fd = fdp->fd;
+
+ if (FD_ISSET (fd, &read_set))
+ msgp += sprintf (msgp, "R:%d ", fd);
+
+ if (FD_ISSET (fd, &write_set))
+ msgp += sprintf (msgp, "W:%d ", fd);
+
+ if (FD_ISSET (fd, &err_set))
+ msgp += sprintf (msgp, "E:%d\n\t", fd);
+ }
+ msgp += sprintf (msgp, "\n");
+ _dbus_verbose ("%s",msg);
+#endif
+
+ for (i = 0; i < n_fds; i++)
+ {
+ int fd;
+ DBusPollFD *fdp = &fds[i];
+ fd = fdp->fd;
+
+ fdp->revents = 0;
+
+ if (FD_ISSET (fd, &read_set))
+ fdp->revents |= _DBUS_POLLIN;
+
+ if (FD_ISSET (fd, &write_set))
+ fdp->revents |= _DBUS_POLLOUT;
+
+ if (FD_ISSET (fd, &err_set))
+ fdp->revents |= _DBUS_POLLERR;
+ }
+ }
+ return ready;
+}
+
+#endif //ENABLE_DBUSSOCKET
+
#endif // USE_CHRIS_IMPL
dbus_uint32_t port,
DBusError *error)
{
+#ifdef ENABLE_DBUSSOCKET
DBusSocket s;
int handle;
struct sockaddr_in addr;
}
return handle;
+#else
+ int fd;
+ struct sockaddr_in addr;
+ struct hostent *he;
+ struct in_addr *haddr;
+ struct in_addr ina;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+ _dbus_win_startup_winsock ();
+
+ fd = socket (AF_INET, SOCK_STREAM, 0);
+
+ if (DBUS_SOCKET_IS_INVALID (fd))
+ {
+ DBUS_SOCKET_SET_ERRNO ();
+ dbus_set_error (error,
+ _dbus_error_from_errno (errno),
+ "Failed to create socket: %s",
+ _dbus_strerror (errno));
+
+ return -1;
+ }
+
+ if (host == NULL)
+ {
+ host = "localhost";
+ ina.s_addr = htonl (INADDR_LOOPBACK);
+ haddr = &ina;
+ }
+
+ he = gethostbyname (host);
+ if (he == NULL)
+ {
+ DBUS_SOCKET_SET_ERRNO ();
+ dbus_set_error (error,
+ _dbus_error_from_errno (errno),
+ "Failed to lookup hostname: %s",
+ host);
+ DBUS_CLOSE_SOCKET (fd);
+ return -1;
+ }
+
+ haddr = ((struct in_addr *) (he->h_addr_list)[0]);
+
+ _DBUS_ZERO (addr);
+ memcpy (&addr.sin_addr, haddr, sizeof(struct in_addr));
+ addr.sin_family = AF_INET;
+ addr.sin_port = htons (port);
+
+ if (DBUS_SOCKET_API_RETURNS_ERROR
+ (connect (fd, (struct sockaddr*) &addr, sizeof (addr)) < 0))
+ {
+ DBUS_SOCKET_SET_ERRNO ();
+ dbus_set_error (error,
+ _dbus_error_from_errno (errno),
+ "Failed to connect to socket %s:%d %s",
+ host, port, _dbus_strerror (errno));
+
+ DBUS_CLOSE_SOCKET (fd);
+ fd = -1;
+
+ return -1;
+ }
+
+ if (!_dbus_set_fd_nonblocking (fd, error))
+ {
+ _dbus_close_socket (fd, NULL);
+ fd = -1;
+
+ return -1;
+ }
+
+ return fd;
+#endif
}
void
dbus_bool_t inaddr_any,
DBusError *error)
{
+#ifdef ENABLE_DBUSSOCKET
DBusSocket slisten;
int handle;
struct sockaddr_in addr;
}
return handle;
+#else
+ int fd;
+ struct sockaddr_in addr;
+ struct hostent *he;
+ struct in_addr *haddr;
+ socklen_t len = (socklen_t) sizeof (struct sockaddr);
+ struct in_addr ina;
+
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+ _dbus_win_startup_winsock ();
+
+ fd = socket (AF_INET, SOCK_STREAM, 0);
+
+ if (DBUS_SOCKET_IS_INVALID (fd))
+ {
+ DBUS_SOCKET_SET_ERRNO ();
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Failed to create socket \"%s:%d\": %s",
+ host, port, _dbus_strerror (errno));
+ return -1;
+ }
+ if (host == NULL)
+ {
+ host = "localhost";
+ ina.s_addr = htonl (INADDR_LOOPBACK);
+ haddr = &ina;
+ }
+ else if (!host[0])
+ {
+ ina.s_addr = htonl (INADDR_ANY);
+ haddr = &ina;
+ }
+ else
+ {
+ he = gethostbyname (host);
+ if (he == NULL)
+ {
+ DBUS_SOCKET_SET_ERRNO ();
+ dbus_set_error (error,
+ _dbus_error_from_errno (errno),
+ "Failed to lookup hostname: %s",
+ host);
+ DBUS_CLOSE_SOCKET (fd);
+ return -1;
+ }
+
+ haddr = ((struct in_addr *) (he->h_addr_list)[0]);
+ }
+
+ _DBUS_ZERO (addr);
+ memcpy (&addr.sin_addr, haddr, sizeof (struct in_addr));
+ addr.sin_family = AF_INET;
+ addr.sin_port = htons (*port);
+
+ if (bind (fd, (struct sockaddr*) &addr, sizeof (struct sockaddr)))
+ {
+ DBUS_SOCKET_SET_ERRNO ();
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Failed to bind socket \"%s:%d\": %s",
+ host, *port, _dbus_strerror (errno));
+ DBUS_CLOSE_SOCKET (fd);
+ return -1;
+ }
+
+ if (DBUS_SOCKET_API_RETURNS_ERROR (listen (fd, 30 /* backlog */)))
+ {
+ DBUS_SOCKET_SET_ERRNO ();
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Failed to listen on socket \"%s:%d\": %s",
+ host, *port, _dbus_strerror (errno));
+ DBUS_CLOSE_SOCKET (fd);
+ return -1;
+ }
+
+ getsockname(fd, (struct sockaddr*) &addr, &len);
+ *port = (dbus_uint32_t) ntohs(addr.sin_port);
+
+ _dbus_daemon_init(host, ntohs(addr.sin_port));
+
+ if (!_dbus_set_fd_nonblocking (fd, error))
+ {
+ _dbus_close_socket (fd, NULL);
+ return -1;
+ }
+
+ return fd;
+#endif
}
+
/**
* Accepts a connection on a listening socket.
* Handles EINTR for you.
int
_dbus_accept (int listen_handle)
{
+#ifdef ENABLE_DBUSSOCKET
DBusSocket *slisten;
DBusSocket sclient;
struct sockaddr addr;
}
return _dbus_socket_to_handle (&sclient);
+#else
+ int fd;
+ int sclient;
+ struct sockaddr addr;
+ socklen_t addrlen;
+
+ fd = listen_handle;
+
+ addrlen = sizeof (addr);
+
+ //FIXME: why do we not try it again on Windows?
+#if !defined(DBUS_WIN) && !defined(DBUS_WINCE)
+retry:
+#endif
+
+ sclient = accept (fd, &addr, &addrlen);
+
+ if (DBUS_SOCKET_IS_INVALID (sclient))
+ {
+ DBUS_SOCKET_SET_ERRNO ();
+#if !defined(DBUS_WIN) && !defined(DBUS_WINCE)
+ if (errno == EINTR)
+ goto retry;
+#else
+ return -1;
+#endif
+ }
+
+ return sclient;
+#endif
}
+
dbus_bool_t
_dbus_send_credentials_socket (int handle,
DBusError *error)
projects / platform / upstream / dbus.git / commitdiff