/* read_packet - Read a packet from the server and store it in the buffer This method reads the bytes sent by the server as a packet. All packets have a packet header defined as follows. Bytes Name ----- ---- 3 Packet Length 1 Packet Number Thus, the length of the packet (not including the packet header) can be found by reading the first 4 bytes from the server then reading N bytes for the packet payload. */ void MySQL_Packet::read_packet() { byte local[4]; if (buffer != NULL) free(buffer); int avail_bytes = wait_for_client(); while (avail_bytes < 4) { avail_bytes = wait_for_client(); } // Read packet header for (int i = 0; i < 4; i++) { // Wait for client. Abort if no data after TIMEOUT_DATA milliseconds if (!wait_for_data()) { return; } local[i] = client->read(); } // Get packet length packet_len = local[0]; packet_len += (local[1] << 8); packet_len += ((uint32_t)local[2] << 16); // We must wait for slow arriving packets for Ethernet shields only. avail_bytes = wait_for_client(); while (avail_bytes < packet_len) { avail_bytes = wait_for_client(); } // Check for valid packet. if (packet_len < 0) { show_error(PACKET_ERROR, true); packet_len = 0; } buffer = (byte *)malloc(packet_len+4); if (buffer == NULL) { show_error(MEMORY_ERROR, true); return; } for (int i = 0; i < 4; i++) buffer[i] = local[i]; for (int i = 4; i < packet_len+4; i++) { // Wait for client. Abort if no data after TIMEOUT_DATA milliseconds if (!wait_for_data()) { return; } buffer[i] = client->read(); } }
void Client::handle_connect(Connection::connection_ptr connection, const boost::system::error_code& error) { if (!error) { std::cout << "Connected" << std::endl; m_state = StateController::INITIALIZING; wait_for_data(); m_drive_events(); } }
/* * read one byte from any source; whether from the controller, * the keyboard, or the aux device */ int read_controller_data(KBDC p) { if (availq(&kbdcp(p)->kbd)) return removeq(&kbdcp(p)->kbd); if (availq(&kbdcp(p)->aux)) return removeq(&kbdcp(p)->aux); if (!wait_for_data(kbdcp(p))) return -1; /* timeout */ return read_data(kbdcp(p)); }
void watch(const FuncT& f) { for(;;) { wait_for_data(); f( wetness(), temperature(), atmospheric_pressure(), illumination() ); } }
void DecoderStack::decode_proc() { optional<int64_t> sample_count; srd_session *session; srd_decoder_inst *prev_di = NULL; assert(_snapshot); // Create the session srd_session_new(&session); assert(session); // Create the decoders const unsigned int unit_size = _snapshot->unit_size(); for (const shared_ptr<decode::Decoder> &dec : _stack) { srd_decoder_inst *const di = dec->create_decoder_inst(session, unit_size); if (!di) { _error_message = tr("Failed to create decoder instance"); srd_session_destroy(session); return; } if (prev_di) srd_inst_stack (session, prev_di, di); prev_di = di; } // Get the intial sample count { unique_lock<mutex> input_lock(_input_mutex); sample_count = _sample_count = _snapshot->get_sample_count(); } // Start the session srd_session_metadata_set(session, SRD_CONF_SAMPLERATE, g_variant_new_uint64((uint64_t)_samplerate)); srd_pd_output_callback_add(session, SRD_OUTPUT_ANN, DecoderStack::annotation_callback, this); srd_session_start(session); do { decode_data(*sample_count, unit_size, session); } while(_error_message.isEmpty() && (sample_count = wait_for_data())); // Destroy the session srd_session_destroy(session); }
static int wait_for_output(void) { int r; do { r = wait_for_data(ftp->data, false); if(r == -1) return -1; if(r == 0 && foo_hookf) foo_hookf(&ftp->ti); } while(r == 0); return 0; }
void PubSubClient::stop() { if ((!available() && !connected()) || !json_enabled) { PubNub_BASE_CLIENT::stop(); return; } /* We are still connected. Read the rest of the stream so that * we catch the timetoken. */ while (wait_for_data()) { char ch = read(); this->_state_input(ch, NULL, 0); } json_enabled = false; }
static int wait_for_input(void) { int r; do { r = wait_for_data(ftp->data, true); if(r == -1) { if(errno == EINTR) ftp->ti.interrupted = true; return -1; } if(r == 0 && foo_hookf) foo_hookf(&ftp->ti); } while(r == 0); return 0; }
static int handshake (struct stream_data *data) { int ret; int finished; SSL_library_init(); SSL_load_error_strings(); data->ssl_ctx = SSL_CTX_new(TLSv1_method()); if(!data->ssl_ctx) return IKS_NOMEM; data->ssl = SSL_new(data->ssl_ctx); if(!data->ssl) return IKS_NOMEM; if( SSL_set_fd(data->ssl, (int)(intptr_t)data->sock) != 1 ) return IKS_NOMEM; /* Set both the read and write BIO's to non-blocking mode */ BIO_set_nbio(SSL_get_rbio(data->ssl), 1); BIO_set_nbio(SSL_get_wbio(data->ssl), 1); finished = 0; do { ret = SSL_connect(data->ssl); if( ret != 1 ) { if( wait_for_data(data, ret, 1) != IKS_OK ) { finished = 1; SSL_free(data->ssl); } } } while( ret != 1 && finished != 1 ); if( ret == 1 ) { data->flags &= (~SF_TRY_SECURE); data->flags |= SF_SECURE; iks_send_header (data->prs, data->server); } return ret == 1 ? IKS_OK : IKS_NET_TLSFAIL; }
static SSL * open_ssl_connection (rfbClient *client, int sockfd, rfbBool anonTLS) { SSL_CTX *ssl_ctx = NULL; SSL *ssl = NULL; int n, finished = 0; BIO *sbio; ssl_ctx = SSL_CTX_new (SSLv23_client_method ()); SSL_CTX_set_default_verify_paths (ssl_ctx); SSL_CTX_set_verify (ssl_ctx, SSL_VERIFY_NONE, &ssl_verify); ssl = SSL_new (ssl_ctx); /* TODO: finetune this list, take into account anonTLS bool */ SSL_set_cipher_list(ssl, "ALL"); SSL_set_fd (ssl, sockfd); SSL_CTX_set_app_data (ssl_ctx, client); do { n = SSL_connect(ssl); if (n != 1) { if (wait_for_data(ssl, n, 1) != 1) { finished = 1; if (ssl->ctx) SSL_CTX_free (ssl->ctx); SSL_free(ssl); SSL_shutdown (ssl); return NULL; } } } while( n != 1 && finished != 1 ); return ssl; }
mailbox_element* pop() { wait_for_data(); return try_pop(); }
T* pop() { wait_for_data(); T* result = m_head; m_head = m_head->next; return result; }
std::unique_ptr<node> wait_pop_head() { std::unique_lock<std::mutex> head_lock(wait_for_data()); return pop_head(); }
/* Fork a new child with a pty. */ gboolean pty_child_fork(struct child* c, gint new_stdin_fd, gint new_stdout_fd, gint new_stderr_fd) { gint pty_slave_fd = -1; gint pty_master_fd = -1; const gchar* pty_slave_name = NULL; c->args.argv[0] = c->exec_name; /* Delimit the args with NULL. */ args_add(&(c->args), NULL); /* Setup a pty for the new shell. */ /* Get master (pty) */ if ((pty_master_fd = rxvt_get_pty(&pty_slave_fd, &pty_slave_name)) < 0) { g_critical("Could not open master side of pty"); c->pid = -1; c->fd_in = -1; c->fd_out = -1; return FALSE; } /* Turn on non-blocking -- probably not necessary since we're in raw terminal mode. */ fcntl(pty_master_fd, F_SETFL, O_NDELAY); /* This will be the interface with the new shell. */ c->fd_in = pty_master_fd; c->fd_out = pty_master_fd; switch (c->pid = fork()) { case -1: g_critical("Could not fork process: %s", g_strerror(errno)); return FALSE; /*break;*/ case 0: if (setsid() == -1) { g_critical("pty_child_fork(): setsid(): %s", g_strerror(errno)); goto child_fail; } /* Get slave (tty) */ if (pty_slave_fd < 0) { if ((pty_slave_fd = rxvt_get_tty(pty_slave_name)) < 0) { (void) close(pty_master_fd); g_critical("Could not open slave tty \"%s\"", pty_slave_name); goto child_fail; } } if (rxvt_control_tty(pty_slave_fd, pty_slave_name) < 0) { g_critical("Could not obtain control of tty \"%s\"", pty_slave_name); goto child_fail; } /* A parameter of NEW_PTY_FD means to use the slave side of the new pty. A parameter of CLOSE_FD means to just close that fd right out. */ if (new_stdin_fd == NEW_PTY_FD) new_stdin_fd = pty_slave_fd; if (new_stdout_fd == NEW_PTY_FD) new_stdout_fd = pty_slave_fd; if (new_stderr_fd == NEW_PTY_FD) new_stderr_fd = pty_slave_fd; if (new_stdin_fd == CLOSE_FD) (void)close(STDIN_FILENO); else if (dup2(new_stdin_fd, STDIN_FILENO) == -1) { g_critical("Could not replace stdin in child process: %s", g_strerror(errno)); goto child_fail; } if (new_stdout_fd == CLOSE_FD) (void)close(STDOUT_FILENO); else if (dup2(new_stdout_fd, STDOUT_FILENO) == -1) { g_critical("Could not replace stdout in child process: %s", g_strerror(errno)); goto child_fail; } if (new_stderr_fd == CLOSE_FD) (void)close(STDERR_FILENO); else if (dup2(new_stderr_fd, STDERR_FILENO) == -1) { g_critical("Could not replace stderr in child process: %s", g_strerror(errno)); goto child_fail; } (void)close(pty_slave_fd); execvp(c->exec_name, c->args.argv); child_fail: g_critical("Exec failed: %s", g_strerror(errno)); g_critical("If vgseer does not exit, you should do so manually"); _exit(EXIT_FAILURE); break; } if (!wait_for_data(c->fd_out)) { g_critical("Did not receive go-ahead from child shell"); return FALSE; } return TRUE; }
int qse_nwio_init ( qse_nwio_t* nwio, qse_mmgr_t* mmgr, const qse_nwad_t* nwad, int flags, const qse_nwio_tmout_t* tmout) { qse_skad_t addr; qse_sck_len_t addrlen; int family, type, tmp; QSE_MEMSET (nwio, 0, QSE_SIZEOF(*nwio)); nwio->mmgr = mmgr; nwio->flags = flags; nwio->errnum = QSE_NWIO_ENOERR; if (tmout) nwio->tmout = *tmout; else { nwio->tmout.r.sec = -1; nwio->tmout.w.sec = -1; nwio->tmout.c.sec = -1; nwio->tmout.a.sec = -1; } tmp = qse_nwadtoskad (nwad, &addr); if (tmp <= -1) { nwio->errnum = QSE_NWIO_EINVAL; return -1; } addrlen = tmp; #if defined(SOCK_STREAM) && defined(SOCK_DGRAM) if (flags & QSE_NWIO_TCP) type = SOCK_STREAM; else if (flags & QSE_NWIO_UDP) type = SOCK_DGRAM; else #endif { nwio->errnum = QSE_NWIO_EINVAL; return -1; } family = qse_skadfamily (&addr); #if defined(_WIN32) nwio->handle = socket (family, type, 0); if (nwio->handle == INVALID_SOCKET) { nwio->errnum = skerr_to_errnum (WSAGetLastError()); goto oops; } if ((flags & QSE_NWIO_TCP) && (flags & QSE_NWIO_KEEPALIVE)) { int optval = 1; setsockopt (nwio->handle, SOL_SOCKET, SO_KEEPALIVE, (void*)&optval, QSE_SIZEOF(optval)); } if (flags & QSE_NWIO_PASSIVE) { qse_nwio_hnd_t handle; if (flags & QSE_NWIO_REUSEADDR) { int optval = 1; setsockopt (nwio->handle, SOL_SOCKET, SO_REUSEADDR, (void*)&optval, QSE_SIZEOF(optval)); } if (bind (nwio->handle, (struct sockaddr*)&addr, addrlen) == SOCKET_ERROR) { nwio->errnum = skerr_to_errnum (WSAGetLastError()); goto oops; } if (flags & QSE_NWIO_TCP) { if (listen (nwio->handle, 10) == SOCKET_ERROR) { nwio->errnum = skerr_to_errnum (WSAGetLastError()); goto oops; } if (TMOUT_ENABLED(nwio->tmout.a) && wait_for_data (nwio, &nwio->tmout.a, 0) <= -1) goto oops; handle = accept (nwio->handle, (struct sockaddr*)&addr, &addrlen); if (handle == INVALID_SOCKET) { nwio->errnum = skerr_to_errnum (WSAGetLastError()); goto oops; } closesocket (nwio->handle); nwio->handle = handle; } else if (flags & QSE_NWIO_UDP) { nwio->status |= STATUS_UDP_CONNECT; } } else { int xret; if (TMOUT_ENABLED(nwio->tmout.c) && (flags & QSE_NWIO_TCP)) { unsigned long cmd = 1; if (ioctlsocket(nwio->handle, FIONBIO, &cmd) == SOCKET_ERROR) { nwio->errnum = skerr_to_errnum (WSAGetLastError()); goto oops; } } xret = connect (nwio->handle, (struct sockaddr*)&addr, addrlen); if (TMOUT_ENABLED(nwio->tmout.c) && (flags & QSE_NWIO_TCP)) { unsigned long cmd = 0; if ((xret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK) || ioctlsocket (nwio->handle, FIONBIO, &cmd) == SOCKET_ERROR) { nwio->errnum = skerr_to_errnum (WSAGetLastError()); goto oops; } if (wait_for_data (nwio, &nwio->tmout.c, 1) <= -1) goto oops; else { int xlen; DWORD xerr; xlen = QSE_SIZEOF(xerr); if (getsockopt (nwio->handle, SOL_SOCKET, SO_ERROR, (char*)&xerr, &xlen) == SOCKET_ERROR) { nwio->errnum = skerr_to_errnum (WSAGetLastError()); goto oops; } else if (xerr != 0) { nwio->errnum = skerr_to_errnum (xerr); goto oops; } } } else { if (xret == SOCKET_ERROR) { nwio->errnum = skerr_to_errnum (WSAGetLastError()); goto oops; } } } #elif defined(__OS2__) nwio->handle = socket (family, type, 0); if (nwio->handle <= -1) { nwio->errnum = skerr_to_errnum (sock_errno()); goto oops; } if ((flags & QSE_NWIO_TCP) && (flags & QSE_NWIO_KEEPALIVE)) { int optval = 1; setsockopt (nwio->handle, SOL_SOCKET, SO_KEEPALIVE, (void*)&optval, QSE_SIZEOF(optval)); } if (flags & QSE_NWIO_PASSIVE) { qse_nwio_hnd_t handle; if (flags & QSE_NWIO_REUSEADDR) { int optval = 1; setsockopt (nwio->handle, SOL_SOCKET, SO_REUSEADDR, (void*)&optval, QSE_SIZEOF(optval)); } if (bind (nwio->handle, (struct sockaddr*)&addr, addrlen) <= -1) { nwio->errnum = skerr_to_errnum (sock_errno()); goto oops; } if (flags & QSE_NWIO_TCP) { if (listen (nwio->handle, 10) <= -1) { nwio->errnum = skerr_to_errnum (sock_errno()); goto oops; } if (TMOUT_ENABLED(nwio->tmout.a) && wait_for_data (nwio, &nwio->tmout.a, 0) <= -1) goto oops; handle = accept (nwio->handle, (struct sockaddr*)&addr, &addrlen); if (handle <= -1) { nwio->errnum = skerr_to_errnum (sock_errno()); goto oops; } soclose (nwio->handle); nwio->handle = handle; } else if (flags & QSE_NWIO_UDP) { nwio->status |= STATUS_UDP_CONNECT; } } else { int xret; if (TMOUT_ENABLED(nwio->tmout.c) && (flags & QSE_NWIO_TCP)) { int noblk = 1; if (ioctl (nwio->handle, FIONBIO, (void*)&noblk, QSE_SIZEOF(noblk)) <= -1) { nwio->errnum = skerr_to_errnum (sock_errno()); goto oops; } } xret = connect (nwio->handle, (struct sockaddr*)&addr, addrlen); if (TMOUT_ENABLED(nwio->tmout.c) && (flags & QSE_NWIO_TCP)) { int noblk = 0; if ((xret <= -1 && sock_errno() != SOCEINPROGRESS) || ioctl (nwio->handle, FIONBIO, (void*)&noblk, QSE_SIZEOF(noblk)) <= -1) { nwio->errnum = skerr_to_errnum (sock_errno()); goto oops; } if (wait_for_data (nwio, &nwio->tmout.c, 1) <= -1) goto oops; else { int xlen, xerr; xlen = QSE_SIZEOF(xerr); if (getsockopt (nwio->handle, SOL_SOCKET, SO_ERROR, (char*)&xerr, &xlen) <= -1) { nwio->errnum = skerr_to_errnum (sock_errno()); goto oops; } else if (xerr != 0) { nwio->errnum = skerr_to_errnum (xerr); goto oops; } } } else { if (xret <= -1) { nwio->errnum = skerr_to_errnum (sock_errno()); goto oops; } } } #elif defined(__DOS__) nwio->handle = socket (family, type, 0); if (nwio->handle <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } if ((flags & QSE_NWIO_TCP) && (flags & QSE_NWIO_KEEPALIVE)) { int optval = 1; setsockopt (nwio->handle, SOL_SOCKET, SO_KEEPALIVE, (void*)&optval, QSE_SIZEOF(optval)); } if (flags & QSE_NWIO_PASSIVE) { qse_nwio_hnd_t handle; #if defined(SO_REUSEADDR) if (flags & QSE_NWIO_REUSEADDR) { int optval = 1; setsockopt (nwio->handle, SOL_SOCKET, SO_REUSEADDR, (void*)&optval, QSE_SIZEOF(optval)); } #endif if (bind (nwio->handle, (struct sockaddr*)&addr, addrlen) <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } if (flags & QSE_NWIO_TCP) { if (listen (nwio->handle, 10) <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } if (TMOUT_ENABLED(nwio->tmout.a) && wait_for_data (nwio, &nwio->tmout.a, 0) <= -1) goto oops; handle = accept (nwio->handle, (struct sockaddr*)&addr, &addrlen); if (handle <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } close_s (nwio->handle); nwio->handle = handle; } else if (flags & QSE_NWIO_UDP) { nwio->status |= STATUS_UDP_CONNECT; } } else { int xret; if (TMOUT_ENABLED(nwio->tmout.c) && (flags & QSE_NWIO_TCP)) { int cmd = 1; if (ioctlsocket(nwio->handle, FIONBIO, (char*)&cmd) == SOCKET_ERROR) { nwio->errnum = skerr_to_errnum (errno); goto oops; } } xret = connect (nwio->handle, (struct sockaddr*)&addr, addrlen); if (TMOUT_ENABLED(nwio->tmout.c) && (flags & QSE_NWIO_TCP)) { int cmd = 0; if ((xret == SOCKET_ERROR && errno != EWOULDBLOCK) || ioctlsocket (nwio->handle, FIONBIO, (char*)&cmd) == SOCKET_ERROR) { nwio->errnum = skerr_to_errnum (errno); goto oops; } if (wait_for_data (nwio, &nwio->tmout.c, 1) <= -1) goto oops; else { int xlen, xerr; xlen = QSE_SIZEOF(xerr); if (getsockopt (nwio->handle, SOL_SOCKET, SO_ERROR, (char*)&xerr, &xlen) <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } else if (xerr != 0) { nwio->errnum = skerr_to_errnum (xerr); goto oops; } } } else { if (xret <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } } } #elif defined(USE_TLI) { static const qse_mchar_t* dev_path[2][2] = { { "/dev/tcp", "/dev/inet/tcp" }, { "/dev/udp", "/dev/inet/tcp" } }; int dev_id; if (flags & QSE_NWIO_TCP) dev_id = 0; else { QSE_ASSERT (flags & QSE_NWIO_UDP); dev_id = 1; } nwio->handle = t_open (dev_path[dev_id][0], O_RDWR, QSE_NULL); if (nwio->handle <= -1) { nwio->handle = t_open (dev_path[dev_id][1], O_RDWR, QSE_NULL); if (nwio->handle <= -1) { nwio->errnum = tlierr_to_errnum (t_errno, errno); goto oops; } } if (flags & QSE_NWIO_PASSIVE) { /* TODO: */ nwio->errnum = QSE_NWIO_ENOIMPL; goto oops; } else { struct t_call call; /* for connecting */ struct t_bind req, ret; /* for binding */ qse_skad_t reqaddr, retaddr; qse_nwad_t reqnwad; /* call = t_alloc (nwio->handle, T_CALL, T_ADDR); if (!call) { nwio->errnum = tlierr_to_errnum (t_errno, errno); goto oops; }*/ qse_clearnwad (&reqnwad, nwad->type); qse_nwadtoskad (&reqnwad, &reqaddr); QSE_MEMSET (&ret, 0, QSE_SIZEOF(req)); req.addr.maxlen = addrlen; req.addr.len = addrlen; req.addr.buf = &reqaddr; QSE_MEMSET (&ret, 0, QSE_SIZEOF(ret)); ret.addr.maxlen = addrlen; ret.addr.len = addrlen; ret.addr.buf = &retaddr; if (t_bind (nwio->handle, &req, &ret) <= -1) { nwio->errnum = tlierr_to_errnum (t_errno, errno); goto oops; } /* TODO: should i use t_alloc() and t_free for call, ret, req? */ QSE_MEMSET (&call, 0, QSE_SIZEOF(call)); call.addr.maxlen = addrlen; call.addr.len = addrlen; call.addr.buf = &addr; if (TMOUT_ENABLED(nwio->tmout.c) && (flags & QSE_NWIO_TCP)) { int orgfl; orgfl = fcntl (nwio->handle, F_GETFL, 0); if (orgfl <= -1 || fcntl (nwio->handle, F_SETFL, orgfl | O_NONBLOCK) <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } if (t_connect (nwio->handle, &call, 0) <= -1) { if (t_errno != TNODATA) { nwio->errnum = tlierr_to_errnum (t_errno, errno); goto oops; } /* TODO: this doesn't seem to work wel... REDO THE WORK */ if (wait_for_data (nwio, &nwio->tmout.c, 0) <= -1) goto oops; if (t_rcvconnect (nwio->handle, QSE_NULL) <= -1) { nwio->errnum = tlierr_to_errnum (t_errno, errno); goto oops; } } if (fcntl (nwio->handle, F_SETFL, orgfl) <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } } else { if (t_connect (nwio->handle, &call, 0) <= -1) { nwio->errnum = tlierr_to_errnum (t_errno, errno); goto oops; } } } } #else #if defined(SOCK_CLOEXEC) nwio->handle = socket (family, type | SOCK_CLOEXEC, 0); #else nwio->handle = socket (family, type, 0); #endif if (nwio->handle <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } #if !defined(SOCK_CLOEXEC) && defined(FD_CLOEXEC) { int tmp = fcntl (nwio->handle, F_GETFD); if (tmp >= 0) fcntl (nwio->handle, F_SETFD, tmp | FD_CLOEXEC); } #endif if ((flags & QSE_NWIO_TCP) && (flags & QSE_NWIO_KEEPALIVE)) { int optval = 1; setsockopt (nwio->handle, SOL_SOCKET, SO_KEEPALIVE, (void*)&optval, QSE_SIZEOF(optval)); } if (flags & QSE_NWIO_PASSIVE) { qse_nwio_hnd_t handle; #if defined(SO_REUSEADDR) if (flags & QSE_NWIO_REUSEADDR) { int optval = 1; setsockopt (nwio->handle, SOL_SOCKET, SO_REUSEADDR, (void*)&optval, QSE_SIZEOF(optval)); } #endif if (bind (nwio->handle, (struct sockaddr*)&addr, addrlen) <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } if (flags & QSE_NWIO_TCP) { if (listen (nwio->handle, 10) <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } if (TMOUT_ENABLED(nwio->tmout.a) && wait_for_data (nwio, &nwio->tmout.a, 0) <= -1) goto oops; handle = accept (nwio->handle, (struct sockaddr*)&addr, &addrlen); if (handle <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } qse_closesckhnd (nwio->handle); /* close the listening socket */ nwio->handle = handle; /* set the handle to the accepted socket */ } else if (flags & QSE_NWIO_UDP) { nwio->status |= STATUS_UDP_CONNECT; } } else { int xret; if (TMOUT_ENABLED(nwio->tmout.c) && (flags & QSE_NWIO_TCP)) { int orgfl; orgfl = fcntl (nwio->handle, F_GETFL, 0); if (orgfl <= -1 || fcntl (nwio->handle, F_SETFL, orgfl | O_NONBLOCK) <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } xret = connect (nwio->handle, (struct sockaddr*)&addr, addrlen); if ((xret <= -1 && errno != EINPROGRESS) || fcntl (nwio->handle, F_SETFL, orgfl) <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } if (wait_for_data (nwio, &nwio->tmout.c, 1) <= -1) goto oops; else { qse_sck_len_t xlen; xlen = QSE_SIZEOF(xret); if (getsockopt (nwio->handle, SOL_SOCKET, SO_ERROR, (char*)&xret, &xlen) <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } else if (xret != 0) { nwio->errnum = skerr_to_errnum (xret); goto oops; } } } else { xret = connect (nwio->handle, (struct sockaddr*)&addr, addrlen); if (xret <= -1) { nwio->errnum = skerr_to_errnum (errno); goto oops; } } } #endif if (flags & QSE_NWIO_TEXT) { int topt = 0; if (flags & QSE_NWIO_IGNOREMBWCERR) topt |= QSE_TIO_IGNOREMBWCERR; if (flags & QSE_NWIO_NOAUTOFLUSH) topt |= QSE_TIO_NOAUTOFLUSH; nwio->tio = qse_tio_open (mmgr, QSE_SIZEOF(qse_nwio_t*), topt); if (nwio->tio == QSE_NULL) { nwio->errnum = QSE_NWIO_ENOMEM; goto oops; } /* store the back-reference to nwio in the extension area.*/ *(qse_nwio_t**)QSE_XTN(nwio->tio) = nwio; if (qse_tio_attachin (nwio->tio, socket_input, QSE_NULL, 4096) <= -1 || qse_tio_attachout (nwio->tio, socket_output, QSE_NULL, 4096) <= -1) { if (nwio->errnum == QSE_NWIO_ENOERR) nwio->errnum = tio_errnum_to_nwio_errnum (nwio->tio); goto oops; } }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { int test_failed = 0; u_long mask = ACE_LOG_MSG->priority_mask(ACE_Log_Msg::PROCESS) ; ACE_LOG_MSG->priority_mask(mask | LM_TRACE | LM_DEBUG, ACE_Log_Msg::PROCESS) ; ACE_DEBUG((LM_DEBUG,"(%P|%t) FooTest5_0 main\n")); try { ::DDS::DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv); if (CORBA::is_nil (dpf.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) creating the DomainParticipantFactory failed.\n"))); return 1 ; } // let the Service_Participant (in above line) strip out -DCPSxxx parameters // and then get application specific parameters. parse_args (argc, argv); ::Xyz::FooTypeSupport_var fts (new ::Xyz::FooTypeSupportImpl); ::DDS::DomainParticipant_var dp = dpf->create_participant(MY_DOMAIN, PARTICIPANT_QOS_DEFAULT, ::DDS::DomainParticipantListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (dp.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) create_participant failed.\n"))); return 1 ; } if (::DDS::RETCODE_OK != fts->register_type(dp.in (), MY_TYPE)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to register the FooTypeSupport."))); return 1; } ::DDS::TopicQos topic_qos; dp->get_default_topic_qos(topic_qos); topic_qos.resource_limits.max_samples_per_instance = max_samples_per_instance ; topic_qos.history.depth = history_depth; ::DDS::Topic_var topic = dp->create_topic (MY_TOPIC, MY_TYPE, topic_qos, ::DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (topic.in ())) { return 1 ; } ::DDS::TopicDescription_var description = dp->lookup_topicdescription(MY_TOPIC); if (CORBA::is_nil (description.in ())) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) lookup_topicdescription failed.\n")), 1); } // Create the subscriber ::DDS::Subscriber_var sub = dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT, ::DDS::SubscriberListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (sub.in ())) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) create_subscriber failed.\n")), 1); } // Create the publisher ::DDS::Publisher_var pub = dp->create_publisher(PUBLISHER_QOS_DEFAULT, ::DDS::PublisherListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (pub.in ())) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) create_publisher failed.\n")), 1); } // Initialize the transport if (0 != ::init_tranport() ) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) init_transport failed!\n")), 1); } // Attach the subscriber to the transport. OpenDDS::DCPS::SubscriberImpl* sub_impl = dynamic_cast<OpenDDS::DCPS::SubscriberImpl*> (sub.in ()); if (0 == sub_impl) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) Failed to obtain servant ::OpenDDS::DCPS::SubscriberImpl\n")), 1); } sub_impl->attach_transport(reader_transport_impl.in()); // Attach the publisher to the transport. OpenDDS::DCPS::PublisherImpl* pub_impl = dynamic_cast<OpenDDS::DCPS::PublisherImpl*> (pub.in ()); if (0 == pub_impl) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) Failed to obtain servant ::OpenDDS::DCPS::PublisherImpl\n")), 1); } pub_impl->attach_transport(writer_transport_impl.in()); // Create the datawriter ::DDS::DataWriterQos dw_qos; pub->get_default_datawriter_qos (dw_qos); dw_qos.history.depth = history_depth ; dw_qos.resource_limits.max_samples_per_instance = max_samples_per_instance ; ::DDS::DataWriter_var dw = pub->create_datawriter(topic.in (), dw_qos, ::DDS::DataWriterListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (dw.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) create_datawriter failed.\n"))); return 1 ; } // Create the Datareader ::DDS::DataReaderQos dr_qos; sub->get_default_datareader_qos (dr_qos); dr_qos.history.depth = history_depth ; dr_qos.resource_limits.max_samples_per_instance = max_samples_per_instance ; ::DDS::DataReader_var dr = sub->create_datareader(description.in (), dr_qos, ::DDS::DataReaderListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (dr.in ())) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) create_datareader failed.\n")), 1); } ::Xyz::FooDataWriter_var foo_dw = ::Xyz::FooDataWriter::_narrow(dw.in ()); if (CORBA::is_nil (foo_dw.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) ::Xyz::FooDataWriter::_narrow failed.\n"))); return 1; // failure } ::Xyz::FooDataWriterImpl* fast_dw = dynamic_cast<Xyz::FooDataWriterImpl*>(foo_dw.in()); ::Xyz::FooDataReader_var foo_dr = ::Xyz::FooDataReader::_narrow(dr.in ()); if (CORBA::is_nil (foo_dr.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) ::Xyz::FooDataReader::_narrow failed.\n"))); return 1; // failure } ::Xyz::FooDataReaderImpl* fast_dr = dynamic_cast<Xyz::FooDataReaderImpl*>(foo_dr.in()); // wait for association establishement before writing. ACE_OS::sleep(5); //REMOVE if not needed // =============== do the test ==== ::DDS::OfferedIncompatibleQosStatus incomp; if (foo_dw->get_offered_incompatible_qos_status (incomp) != ::DDS::RETCODE_OK) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT ("ERROR: failed to get offered incompatible qos status\n")), 1); } int incompatible_transport_found = 0; for (CORBA::ULong ii =0; ii < incomp.policies.length (); ii++) { if (incomp.policies[ii].policy_id == ::OpenDDS::TRANSPORTTYPE_QOS_POLICY_ID) incompatible_transport_found = 1; } ::DDS::SubscriptionMatchedStatus matched; if (foo_dr->get_subscription_matched_status (matched) != ::DDS::RETCODE_OK) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT ("ERROR: failed to get subscription matched status\n")), 1); } ::DDS::InstanceHandle_t handle; if (pub_using_udp != sub_using_udp) { if (!incompatible_transport_found) ACE_ERROR_RETURN((LM_ERROR, "TEST ERROR: Expected offered_incompatible_qos" " with TRANSPORTTYPE_QOS_POLICY_ID" " but did not get it. %d incompatible_qos values.\n", incomp.policies.length ()), 7); else { ACE_DEBUG((LM_DEBUG, "Got expected offered_incompatible_qos" " with TRANSPORTTYPE_QOS_POLICY_ID" " existing with success.\n")); goto cleanup; } } else { if (incompatible_transport_found) ACE_ERROR_RETURN((LM_ERROR, "TEST ERROR: Did not expect offered_incompatible_qos" " with TRANSPORTTYPE_QOS_POLICY_ID" " but got it. %d incompatible_qos values.\n", incomp.policies.length ()), 8); if (matched.total_count != 1) ACE_ERROR_RETURN((LM_ERROR, "TEST ERROR: expected subscription_match" " with count 1 but got %d\n", matched.total_count), 9); } ::Xyz::Foo foo; foo.key = 10101; foo.x = -1; foo.y = -1; handle = fast_dw->register_instance(foo); foo.x = 7; fast_dw->write(foo, handle); ::Xyz::Foo sample; ::DDS::SampleInfo info ; // wait for new data for upto 10 seconds if (!wait_for_data(sub.in (), 5)) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: timeout waiting for data.\n")), 1); DDS::ReturnCode_t status ; status = fast_dr->read_next_sample(sample, info) ; if (status == ::DDS::RETCODE_OK) { ACE_DEBUG((LM_DEBUG, "read foo.x = %f foo.y = %f, foo.key = %d\n", sample.x, sample.y, sample.key)); ACE_DEBUG((LM_DEBUG, "read SampleInfo.sample_rank = %d\n", info.sample_rank)); if (foo.x != sample.x) { ACE_ERROR((LM_ERROR, "ERROR: unexpected foo value wrote %f got %f\n", foo.x, sample.x)); test_failed = 1; } } else if (status == ::DDS::RETCODE_NO_DATA) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: reader received ::DDS::RETCODE_NO_DATA!\n") )); test_failed = 1; } else { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: unexpected status %d!\n"), status )); test_failed = 1; } //======== clean up ============ cleanup: // Clean up publisher objects // pub->delete_contained_entities() ; pub->delete_datawriter(dw.in ()); dp->delete_publisher(pub.in ()); //clean up subscriber objects // sub->delete_contained_entities() ; sub->delete_datareader(dr.in ()); dp->delete_subscriber(sub.in ()); // clean up common objects dp->delete_topic(topic.in ()); dpf->delete_participant(dp.in ()); reader_transport_impl = 0; writer_transport_impl = 0; TheTransportFactory->release(); TheServiceParticipant->shutdown (); } catch (const TestException&) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) TestException caught in main.cpp. "))); return 1; } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught in main.cpp:"); return 1; } return test_failed; }
void Client::handle_read(const boost::system::error_code& error) { if (!error) { switch (m_downMessage.m_type) { case DownMessage::PLAYER_CONNECTED : case DownMessage::PLAYER_LEFT : std::cout << "Room event : " << m_downMessage.m_info << std::endl; break; case DownMessage::WORLD_STATE : if (StateController::PLAYING == m_state) { std::cout << "World state" << std::endl; for (std::vector<Player>::iterator it = m_downMessage.m_players.begin(); m_downMessage.m_players.end() != it; it++) { std::cout << it->m_area << it->m_tile.x << it->m_tile.y << it->m_zone.x << it->m_zone.y << std::endl; if (it->m_number == m_player->m_number) { m_player->m_area = it->m_area; m_player->m_tile = it->m_tile; m_player->m_zone = it->m_zone; } } SDL_FillRect(m_screen, 0, SDL_MapRGB(m_screen->format, 0, 0, 0)); m_zoneDisplayZone->render(m_screen, m_world->getArea(m_player->m_area), m_downMessage.m_players); SDL_Flip(m_screen); } break; case DownMessage::DEFAULT_TYPE : std::cout << "Default message" << std::endl; break; case DownMessage::WELCOME : if (StateController::INITIALIZING == m_state) { m_world = new StaticWorld("scenario1", "data"); m_player = new Player(m_downMessage.m_players.front()); m_state = StateController::PLAYING; std::cout << "Welcome message" << std::endl; } break; default: std::cout << "???" << std::endl; break; } wait_for_data(); } else { std::cout << error.message() << std::endl; } }
std::unique_ptr<node> wait_pop_head(T& value) { std::unique_lock<std::mutex> head_lock(wait_for_data()); value = std::move(*head->data); return pop_head(); }