int main(int argc, const char *argv[]) { fd_set allreads; fd_set readmask; int socket = 0; int rc = 0; RingBuffer *in_rb = RingBuffer_create(1024 * 10); RingBuffer *sock_rb = RingBuffer_create(1024 * 10); check(argc == 3, "USAGE: netclient HOST PORT"); socket = client_connect(argv[1], argv[2]); check(socket >= 0, "Connect to %s:%s failed.", argv[1], argv[2]); FD_ZERO(&allreads); FD_SET(socket, &allreads); FD_SET(0, &allreads); while(1) { readmask = allreads; rc = select(socket + 1, &readmask, NULL, NULL, NULL); check(rc >= 0, "Select failed"); if(FD_ISSET(0, &readmask)) { rc = read_some(in_rb, 0, 0); check_debug(rc != -1, "failed to read from stdin."); } if(FD_ISSET(socket, &readmask)) { rc = read_some(sock_rb, socket, 0); check_debug(rc != -1, "failed to read from socket."); } while(!RingBuffer_empty(sock_rb)) { rc = write_some(sock_rb, 1, 0); check_debug(rc != -1, "failed to write to stdout."); } while(!RingBuffer_empty(in_rb)) { rc = write_some(in_rb, socket, 1); check_debug(rc != -1, "failed to write to socket."); } } RingBuffer_destroy(in_rb); RingBuffer_destroy(sock_rb); return 0; error: return -1; }
std::size_t file_handle::write_some(const ConstBufferSequence& buffers) { error_code ec; std::size_t s = write_some(buffers, ec); detail::throw_error(ec); return s; }
std::size_t write_some(const ConstBufferSequence& buffers) { asio::error_code ec; std::size_t n = write_some(buffers, ec); asio::detail::throw_error(ec, "write_some"); return n; }
static void write_test(void *v_t) { struct write_test *t = v_t; enum stream_result sres; switch (t->step) { case 0: t->stream = delim_write_next(t->dw); t->pos = 0; STEP: sres = write_some(t, "hello, ", 7); if (sres == STREAM_WAITING) return; assert(sres == STREAM_OK); STEP: sres = stream_close(t->stream, &t->tasklet, &t->err); if (sres == STREAM_WAITING) return; assert(sres == STREAM_OK); stream_destroy(t->stream); t->stream = delim_write_next(t->dw); t->pos = 0; STEP: sres = write_some(t, "world!", 6); if (sres == STREAM_WAITING) return; assert(sres == STREAM_OK); STEP: sres = stream_close(t->stream, &t->tasklet, &t->err); if (sres == STREAM_WAITING) return; assert(sres == STREAM_OK); stream_destroy(t->stream); } tasklet_stop(&t->tasklet); application_stop(); }
size_t stream_socket::write_some(const_buffer const &buffer) { system::error_code e; size_t r=write_some(buffer,e); if(e) throw system::system_error(e); return r; }
size_t stream_socket::write(const_buffer const &buffer,system::error_code &e) { const_buffer tmp = buffer; size_t count = 0; while(!tmp.empty()) { size_t n = write_some(tmp,e); count+=n; if(e) return count; tmp+=n; } return count; }
static void channel_readable (LmChannel *channel) { char buf[1024]; gsize read_len; g_print ("Attempting to read\n"); lm_channel_read (channel, buf, 1023, &read_len, NULL); buf[read_len] = '\0'; g_print ("Read: %s\n", buf); write_some (channel); }
std::size_t write_some(ConstBufferSequence& buf , boost::system::error_code& ec) { ec = boost::system::error_code(); std::size_t bytes_transferred(0); for(typename ConstBufferSequence::const_iterator i = buf.begin(), end (buf.end()) ; !ec && i != end; ++i) { std::size_t buf_len = boost::asio::buffer_size(*i); bytes_transferred += write_some(boost::asio::buffer_cast<const char *>(*i), buf_len, ec); } return bytes_transferred; }
void stream_socket::async_write_some(const_buffer const &buffer,io_handler const &h) { if(!dont_block(h)) return; #ifdef BOOSTER_AIO_FORCE_POLL writer_some::pointer writer(new writer_some(h,buffer,this)); on_writeable(writer); #else system::error_code e; size_t n = write_some(buffer,e); if(e && would_block(e)) { writer_some::pointer writer(new writer_some(h,buffer,this)); on_writeable(writer); } else { io_binder::pointer binder(new io_binder( h,n,e )); get_io_service().post(binder); } #endif }
void send( SyncWriteStream& stream, message<isRequest, Body, Fields> const& m) { // Check the template types static_assert(is_sync_write_stream<SyncWriteStream>::value, "SyncWriteStream requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter requirements not met"); // Create the instance of serializer for the message serializer<isRequest, Body, Fields> sr{m}; // Loop until the serializer is finished do { // This call guarantees it will make some // forward progress, or otherwise return an error. write_some(stream, sr); } while(! sr.is_done()); }
void events::add(uint64_t i) { write_some(fd, &i, sizeof(i)); }
void bind(endpoint_type const& endpoint, error_code& ec); std::size_t available(error_code& ec) const; int type() const; template <class Mutable_Buffers> std::size_t read_some(Mutable_Buffers const& buffers, error_code& ec) { TORRENT_SOCKTYPE_FORWARD_RET(read_some(buffers, ec), 0) } template <class Mutable_Buffers, class Handler> void async_read_some(Mutable_Buffers const& buffers, Handler const& handler) { TORRENT_SOCKTYPE_FORWARD(async_read_some(buffers, handler)) } template <class Const_Buffers> std::size_t write_some(Const_Buffers const& buffers, error_code& ec) { TORRENT_SOCKTYPE_FORWARD_RET(write_some(buffers, ec), 0) } template <class Const_Buffers, class Handler> void async_write_some(Const_Buffers const& buffers, Handler const& handler) { TORRENT_SOCKTYPE_FORWARD(async_write_some(buffers, handler)) } template <class Handler> void async_connect(endpoint_type const& endpoint, Handler const& handler) { TORRENT_SOCKTYPE_FORWARD(async_connect(endpoint, handler)) } #ifndef BOOST_NO_EXCEPTIONS template <class IO_Control_Command> void io_control(IO_Control_Command& ioc) { TORRENT_SOCKTYPE_FORWARD(io_control(ioc)) } template <class Mutable_Buffers>