static void
on_connect(uv_connect_t *connection_request, int status)
{
rig_pb_stream_t *stream = connection_request->data;
c_return_if_fail(stream->connecting);
stream->connecting = false;
if (status < 0) {
c_warning("Failed to connect to %s:%s - %s",
stream->hostname,
stream->port,
uv_strerror(status));
rut_closure_list_invoke(&stream->on_error_closures,
rig_pb_stream_callback_t,
stream);
goto exit;
}
stream->type = STREAM_TYPE_TCP;
set_connected(stream);
exit:
/* NB: we were at least keeping the stream alive while
* waiting for the connection request to finish... */
stream->connecting = false;
rut_object_unref(stream);
}
void asio_rpc_session::connect()
{
if (try_connecting())
{
boost::asio::ip::tcp::endpoint ep(
boost::asio::ip::address_v4(_remote_addr.ip()), _remote_addr.port());
add_ref();
_socket->async_connect(ep, [this](boost::system::error_code ec)
{
if (!ec)
{
dinfo("client session %s connected",
_remote_addr.to_string()
);
set_options();
set_connected();
on_send_completed();
do_read();
}
else
{
derror("client session connect to %s failed, error = %s",
_remote_addr.to_string(),
ec.message().c_str()
);
on_failure();
}
release_ref();
});
}
}
/**
* __connman_network_disconnect:
* @network: network structure
*
* Disconnect network
*/
int __connman_network_disconnect(struct connman_network *network)
{
int err;
_DBG_NETWORK("network %p", network);
if (network->connected == FALSE && network->connecting == FALSE &&
network->associating == FALSE)
return -ENOTCONN;
if (network->driver == NULL)
return -EUNATCH;
if (network->driver->disconnect == NULL)
return -ENOSYS;
network->connecting = FALSE;
err = network->driver->disconnect(network);
if (err == 0) {
network->connected = FALSE;
set_connected(network);
}
return err;
}
void hpc_rpc_session::on_connect_events_ready(uintptr_t lolp_or_events)
{
dassert(is_connecting(), "session must be connecting at this time");
struct kevent& e = *((struct kevent*)lolp_or_events);
dinfo("(s = %d) epoll for connect to %s:%hu, events = %x",
_socket,
_remote_addr.name(),
_remote_addr.port(),
e.filter
);
if ((e.filter == EVFILT_WRITE)
&& ((e.flags & EV_ERROR) == 0)
&& ((e.flags & EV_EOF) == 0)
)
{
socklen_t addr_len = (socklen_t)sizeof(_peer_addr);
if (getpeername(_socket, (struct sockaddr*)&_peer_addr, &addr_len) == -1)
{
dassert(false, "(s = %d) (client) getpeername failed, err = %s",
_socket, strerror(errno));
}
dinfo("(s = %d) client session %s:%hu connected",
_socket,
_remote_addr.name(),
_remote_addr.port()
);
set_connected();
if (_looper->bind_io_handle(
(dsn_handle_t)(intptr_t)_socket,
&_ready_event,
EVFILT_READ_WRITE
) != ERR_OK)
{
on_failure();
return;
}
// start first round send
do_safe_write(nullptr);
}
else
{
int err = 0;
socklen_t err_len = (socklen_t)sizeof(err);
if (getsockopt(_socket, SOL_SOCKET, SO_ERROR, (void*)&err, &err_len) < 0)
{
dassert(false, "getsockopt for SO_ERROR failed, err = %s", strerror(errno));
}
derror("(s = %d) connect failed (in epoll), err = %s", _socket, strerror(err));
on_failure();
}
}
void NanostackSocket::event_connect_done(socket_callback_t *sock_cb)
{
nanostack_assert_locked();
MBED_ASSERT(SOCKET_MODE_CONNECTING == mode);
set_connected();
signal_event();
}
static void
stream_set_connected_idle(void *user_data)
{
rig_pb_stream_t *stream = user_data;
rut_poll_shell_remove_idle_FIXME(stream->shell, stream->buffer.connect_idle);
stream->buffer.connect_idle = NULL;
set_connected(stream);
}
void
rig_pb_stream_set_wslay_server_event_ctx(rig_pb_stream_t *stream,
struct wslay_event_context *ctx)
{
c_return_if_fail(stream->type == STREAM_TYPE_DISCONNECTED);
stream->type = STREAM_TYPE_WEBSOCKET_SERVER;
stream->websocket_server.ctx = ctx;
set_connected(stream);
}
/**
* connman_network_set_connected:
* @network: network structure
* @connected: connected state
*
* Change connected state of network
*/
int connman_network_set_connected(struct connman_network *network,
connman_bool_t connected)
{
DBusMessage *signal;
DBusMessageIter entry, value;
const char *key = "Connected";
_DBG_NETWORK("network %p connected %d", network, connected);
if ((network->connecting == TRUE || network->associating == TRUE) &&
connected == FALSE) {
connman_element_set_error(&network->element,
CONNMAN_ELEMENT_ERROR_CONNECT_FAILED);
__connman_network_disconnect(network);
}
if (network->connected == connected) {
_DBG_NETWORK("%s: already %sconnected", __func__,
connected ? "" : "!");
return -EALREADY;
}
network->connected = connected;
if (network->registered == FALSE) {
_DBG_NETWORK("not registered; defer");
g_idle_add(set_connected, network);
return 0;
}
signal = dbus_message_new_signal(network->element.path,
CONNMAN_NETWORK_INTERFACE, "PropertyChanged");
if (signal == NULL) {
connman_error("%s: cannot allocate signal", __func__);
/* XXX? defer to idle loop */
return 0;
}
dbus_message_iter_init_append(signal, &entry);
dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
DBUS_TYPE_BOOLEAN_AS_STRING, &value);
dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &connected);
dbus_message_iter_close_container(&entry, &value);
g_dbus_send_message(connection, signal);
set_connected(network);
return 0;
}
void
rig_pb_stream_set_in_worker(rig_pb_stream_t *stream, bool in_worker)
{
c_return_if_fail(stream->type == STREAM_TYPE_DISCONNECTED);
stream->type = STREAM_TYPE_WORKER_IPC;
stream->worker_ipc.in_worker = in_worker;
_rig_worker_stream = stream;
set_connected(stream);
}
void hpc_rpc_session::connect()
{
if (!try_connecting())
return;
_connect_event.callback = [this](int err, uint32_t io_size, uintptr_t lpolp)
{
//dinfo("ConnectEx completed, err = %d, size = %u", err, io_size);
if (err != ERROR_SUCCESS)
{
dwarn("ConnectEx failed, err = %d", err);
this->on_failure();
}
else
{
dinfo("client session %s:%hu connected",
_remote_addr.name(),
_remote_addr.port()
);
set_connected();
on_send_completed(nullptr);
do_read();
}
this->release_ref(); // added before ConnectEx
};
memset(&_connect_event.olp, 0, sizeof(_connect_event.olp));
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(_remote_addr.ip());
addr.sin_port = htons(_remote_addr.port());
this->add_ref(); // released in _connect_event.callback
BOOL rt = s_lpfnConnectEx(
_socket,
(struct sockaddr*)&addr,
(int)sizeof(addr),
0,
0,
0,
&_connect_event.olp
);
if (!rt && (WSAGetLastError() != ERROR_IO_PENDING))
{
dwarn("ConnectEx failed, err = %d", ::WSAGetLastError());
this->release_ref();
on_failure();
}
}
void
rig_pb_stream_accept_tcp_connection(rig_pb_stream_t *stream,
uv_tcp_t *server)
{
uv_loop_t *loop = rut_uv_shell_get_loop(stream->shell);
struct sockaddr name;
int namelen;
int err;
c_return_if_fail(stream->type == STREAM_TYPE_DISCONNECTED);
c_return_if_fail(stream->hostname == NULL);
c_return_if_fail(stream->port == NULL);
c_return_if_fail(stream->resolving == false);
uv_tcp_init(loop, &stream->tcp.socket);
stream->tcp.socket.data = stream;
err = uv_accept((uv_stream_t *)server, (uv_stream_t *)&stream->tcp.socket);
if (err != 0) {
c_warning("Failed to accept tcp connection: %s", uv_strerror(err));
uv_close((uv_handle_t *)&stream->tcp.socket, NULL);
return;
}
err = uv_tcp_getpeername(&stream->tcp.socket, &name, &namelen);
if (err != 0) {
c_warning("Failed to query peer address of tcp socket: %s",
uv_strerror(err));
stream->hostname = c_strdup("unknown");
stream->port = c_strdup("0");
} else if (name.sa_family != AF_INET) {
c_warning("Accepted connection isn't ipv4");
stream->hostname = c_strdup("unknown");
stream->port = c_strdup("0");
} else {
struct sockaddr_in *addr = (struct sockaddr_in *)&name;
char ip_address[17] = {'\0'};
uv_ip4_name(addr, ip_address, 16);
stream->hostname = c_strdup(ip_address);
stream->port = c_strdup_printf("%u", ntohs(addr->sin_port));
}
stream->type = STREAM_TYPE_TCP;
set_connected(stream);
}
void
rig_pb_stream_set_worker(rig_pb_stream_t *stream,
rig_worker_t worker)
{
c_return_if_fail(stream->type == STREAM_TYPE_DISCONNECTED);
stream->type = STREAM_TYPE_WORKER_IPC;
stream->worker_ipc.worker = worker;
rig_emscripten_worker_set_main_onmessage(worker,
rig_pb_stream_main_onmessage,
stream);
set_connected(stream);
}
void
rig_pb_stream_set_fd_transport(rig_pb_stream_t *stream, int fd)
{
uv_loop_t *loop = rut_uv_shell_get_loop(stream->shell);
c_return_if_fail(stream->type == STREAM_TYPE_DISCONNECTED);
stream->type = STREAM_TYPE_FD;
uv_pipe_init(loop, &stream->fd.uv_fd_pipe, true /* enable handle passing */);
stream->fd.uv_fd_pipe.data = stream;
uv_pipe_open(&stream->fd.uv_fd_pipe, fd);
set_connected(stream);
}
/**
* __connman_network_connect:
* @network: network structure
*
* Connect network
*/
int __connman_network_connect(struct connman_network *network)
{
int err;
DBG("network %p", network);
if (network->connected == TRUE)
return -EISCONN;
if (network->connecting == TRUE || network->associating == TRUE)
return -EALREADY;
if (network->driver == NULL)
return -EUNATCH;
if (network->driver->connect == NULL)
return -ENOSYS;
if (network->device == NULL)
return -ENODEV;
network->connecting = TRUE;
#if defined TIZEN_EXT
if (network->type != CONNMAN_NETWORK_TYPE_CELLULAR)
#endif
__connman_device_disconnect(network->device);
err = network->driver->connect(network);
if (err < 0) {
if (err == -EINPROGRESS)
connman_network_set_associating(network, TRUE);
else {
network->connecting = FALSE;
}
return err;
}
network->connected = TRUE;
set_connected(network);
return err;
}
/**
* connman_network_set_connected:
* @network: network structure
* @connected: connected state
*
* Change connected state of network
*/
int connman_network_set_connected(struct connman_network *network,
connman_bool_t connected)
{
DBG("network %p connected %d", network, connected);
if ((network->connecting == TRUE || network->associating == TRUE) &&
connected == FALSE) {
connman_network_set_error(network,
CONNMAN_NETWORK_ERROR_CONNECT_FAIL);
__connman_network_disconnect(network);
}
if (network->connected == connected)
return -EALREADY;
network->connected = connected;
set_connected(network);
return 0;
}
void
rig_pb_stream_set_websocket_client_fd(rig_pb_stream_t *stream,
int fd)
{
c_return_if_fail(stream->type == STREAM_TYPE_DISCONNECTED);
stream->type = STREAM_TYPE_WEBSOCKET_CLIENT;
stream->websocket_client.socket = fd;
#warning "FIXME: support multiple websocket based streams"
/* XXX: These are global callbacks and so is the user data
* so we need some way to lookup a stream based on a
* socket fd within the callbacks */
emscripten_set_socket_error_callback(stream /* user data */,
rig_pb_stream_websocket_error_cb);
emscripten_set_socket_open_callback(stream /* user data */,
rig_pb_stream_websocket_ready_cb);
emscripten_set_socket_message_callback(stream /* user data */,
rig_pb_stream_websocket_ready_cb);
set_connected(stream);
}
/**
* __connman_network_connect:
* @network: network structure
*
* Connect network
*/
int __connman_network_connect(struct connman_network *network)
{
int err;
_DBG_NETWORK("network %p", network);
if (network->connected == TRUE)
return -EISCONN;
if (network->connecting == TRUE || network->associating == TRUE)
return -EALREADY;
if (network->driver == NULL)
return -EUNATCH;
if (network->driver->connect == NULL)
return -ENOSYS;
__connman_device_disconnect(network->device);
network->connecting = TRUE;
err = network->driver->connect(network);
if (err < 0) {
if (err == -EINPROGRESS)
connman_network_set_associating(network, TRUE);
else
network->hidden = FALSE;
return err;
}
network->connected = TRUE;
set_connected(network);
return err;
}
int main(int argc, char** argv) {
int c;
while ((c = getopt(argc, argv, "v:")) != -1) {
switch (c) {
case 'v':
verbose = atoi(optarg);
break;
default:
usage(argv[0]);
}
}
if (optind != argc-1)
usage(argv[0]);
char* display = argv[optind];
trueorabort(display[0] == ':', "Invalid display: '%s'", display);
char* endptr;
int displaynum = (int)strtol(display+1, &endptr, 10);
trueorabort(display+1 != endptr && (*endptr == '\0' || *endptr == '.'),
"Invalid display number: '%s'", display);
init_display(display);
socket_server_init(PORT_BASE + displaynum);
unsigned char buffer[BUFFERSIZE];
int length;
while (1) {
set_connected(dpy, False);
socket_server_accept(VERSION);
write_init();
set_connected(dpy, True);
while (1) {
length = socket_client_read_frame((char*)buffer, sizeof(buffer));
if (length < 0) {
socket_client_close(1);
break;
}
if (length < 1) {
error("Invalid packet from client (size <1).");
socket_client_close(0);
break;
}
switch (buffer[0]) {
case 'S': /* Screen */
if (!check_size(length, sizeof(struct screen), "screen"))
break;
write_image((struct screen*)buffer);
break;
case 'P': /* Cursor */
if (!check_size(length, sizeof(struct cursor), "cursor"))
break;
write_cursor();
break;
case 'R': /* Resolution */
if (!check_size(length, sizeof(struct resolution),
"resolution"))
break;
change_resolution((struct resolution*)buffer);
break;
case 'K': { /* Key */
if (!check_size(length, sizeof(struct key), "key"))
break;
struct key* k = (struct key*)buffer;
log(2, "Key: kc=%04x\n", k->keycode);
XTestFakeKeyEvent(dpy, k->keycode, k->down, CurrentTime);
if (k->down) {
kb_add(KEYBOARD, k->keycode);
} else {
kb_remove(KEYBOARD, k->keycode);
}
break;
}
case 'C': { /* Click */
if (!check_size(length, sizeof(struct mouseclick),
"mouseclick"))
break;
struct mouseclick* mc = (struct mouseclick*)buffer;
XTestFakeButtonEvent(dpy, mc->button, mc->down, CurrentTime);
if (mc->down) {
kb_add(MOUSE, mc->button);
} else {
kb_remove(MOUSE, mc->button);
}
break;
}
case 'M': { /* Mouse move */
if (!check_size(length, sizeof(struct mousemove), "mousemove"))
break;
struct mousemove* mm = (struct mousemove*)buffer;
XTestFakeMotionEvent(dpy, 0, mm->x, mm->y, CurrentTime);
break;
}
case 'Q': /* "Quit": release all keys */
kb_release_all();
break;
default:
error("Invalid packet from client (%d).", buffer[0]);
socket_client_close(0);
}
}
socket_client_close(0);
kb_release_all();
close_mmap(&cache[0]);
close_mmap(&cache[1]);
}
return 0;
}
static void outbox_sent_handler(DictionaryIterator *failed, void *context) {
set_connected();
}
void sim_client_session::connect()
{
if (try_connecting())
set_connected();
}
