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(); }