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; }
static void read_test(void *v_t) { struct read_test *t = v_t; enum stream_result sres; ssize_t res; switch (t->step) { case 0: t->stream = delim_read_next(t->dr); t->pos = 0; STEP: res = read_some(t, 8); if (res == STREAM_WAITING) return; assert(res == 7); assert(!memcmp(t->buf, "hello, ", 7)); 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_read_next(t->dr); t->pos = 0; STEP: res = read_some(t, 7); if (res == STREAM_WAITING) return; assert(res == 6); assert(!memcmp(t->buf, "world!", 6)); 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(); }
bool async_file::open(int fd, OpenMode mode) { logger::debug() << "Open fd " << fd << " mode " << mode; assert(mode & ReadWrite); if (sd.is_open()) { set_error("async_file already open"); logger::debug() << error_string(); return false; } sd.assign(::dup(fd)); // Place the file descriptor in nonblocking mode sd.non_blocking(true); mode_ = mode; if (mode & Read) { boost::system::error_code ec; read_some(ec, 0); } if (mode & Write) { // snout = new QSocketNotifier(fd, QSocketNotifier::Write, this); // connect(snout, SIGNAL(activated(int)), // this, SLOT(readyWrite())); } return true; }
size_t read_some( AsyncReadStream& s, boost::asio::streambuf& buf ) { char buffer[1024]; size_t bytes_read = read_some( s, boost::asio::buffer( buffer, sizeof(buffer) ) ); buf.sputn( buffer, bytes_read ); return bytes_read; }
Udp::Udp( const char *ipAddress, const char *pRemPort, const char *pLocPort, boost::lockfree::queue<MsgData_t> *pQueue ) : m_pQueue(NULL), m_io(), m_socket( m_io ), m_rem_endpoint(boost::asio::ip::address::from_string(ipAddress), atoi(pRemPort)), m_loc_endpoint(boost::asio::ip::udp::v4(), atoi(pLocPort)) { boost::system::error_code myError; m_socket.open( boost::asio::ip::udp::v4(), myError); if (myError) { std::cout << "Open - " << myError.message() << std::endl; exit(1); } m_socket.bind( m_loc_endpoint, myError ); if (myError) { std::cout << "Bind - " << myError.message() << std::endl; exit(1); } this->m_pQueue = pQueue; /* Set the pointer to the queue */ read_some(); // run the IO service as a separate thread, so the main thread can do others boost::thread t(boost::bind(&boost::asio::io_service::run, &m_io)); }
void Udp::read_handler( const boost::system::error_code& error, size_t bytes_transferred ) { if ( !error ) { /* Data received with no error */ /* Construct a new msg event indicating that a msg has been received */ MsgData_t msg; memset(&msg, 0, sizeof(msg)); msg.src = _DC3_EthCli; msg.dst = _DC3_EthCli; msg.dataLen = bytes_transferred; memcpy( msg.dataBuf, read_msg_, msg.dataLen ); /* Put the data into the queue for ClientApi to read */ if(!this->m_pQueue->push(msg)) { ERR_printf( m_pLog, "Unable to push data into queue."); } } else { ERR_printf(this->m_pLog, "Unable to read UDP data"); } read_some(); /* Continue reading */ }
std::size_t file_handle::read_some(const MutableBufferSequence& buffers) { error_code ec; std::size_t s = read_some(buffers, ec); detail::throw_error(ec); return s; }
void async_read_some(const MutableBufferSequence& buffers, Handler handler) { boost::system::error_code ec; std::size_t bytes_transferred = read_some(buffers, ec); io_service_.post(boost::asio::detail::bind_handler( handler, ec, bytes_transferred)); }
std::size_t read_some(const MutableBufferSequence& buffers) { boost::system::error_code ec; std::size_t bytes_read = read_some(buffers, ec); detail::throw_error(ec); return bytes_read; }
void tryHttpRequest() { try { HttpRequestPtr request(new HttpRequest(work_in_progress_)); // TODO: buffer_ may contain multiple requests at the same time // HttpRequest() should take one off of it and return the length read work_in_progress_.clear(); HttpResponsePtr response = request_exception_wrapper(request, delegate_); respond(response); read_some(); } catch(HttpMessage::IncompleteHttpMessageException &) { read_some(); } catch(HttpRequest::InvalidHttpMessageException &e) { std::cerr << "Parse Error: " << e.what() << std::endl; // TODO: send back Bad Request and close the connection } }
size_t stream_socket::read_some(mutable_buffer const &buffer) { system::error_code e; size_t r=read_some(buffer,e); if(e) throw system::system_error(e); return r; }
events::events(io::io_service &service, events::callback _callback) : on_ready(std::move(_callback)),fd(createfd(true)), ioEntry(service, fd, EPOLLIN, [this](uint32_t) { uint64_t res; read_some(fd, &res, sizeof(res)); this->on_ready(res); }) { }
std::size_t read_some(const MutableBufferSequence& buffers) { asio::error_code ec; std::size_t bytes_transferred = read_some(buffers, ec); if (ec) { asio::system_error ex(ec); // boost::throw_exception(ex); } return bytes_transferred; }
std::size_t read_some(const MutableBufferSequence& buffers) { asio::error_code ec; std::size_t bytes_transferred = read_some(buffers, ec); if (ec) { std::system_error ex(ec); throw ex; } return bytes_transferred; }
size_t tcp_stream::read_explicit(io::buffer buffer, const size_t bytes_requested) { size_t bytes_transferred = 0; while (bytes_transferred < bytes_requested) { bytes_transferred += read_some(buffer, bytes_requested); buffer.ptr += bytes_transferred; buffer.capacity -= bytes_transferred; } return bytes_transferred; }
size_t stream_socket::read(mutable_buffer const &buffer,system::error_code &e) { mutable_buffer tmp = buffer; size_t count = 0; while(!tmp.empty()) { size_t n = read_some(tmp,e); count+=n; if(e) return count; tmp+=n; } return count; }
int main(void) { char buf[20]; while (3==read_some(buf,3,'\n',0)) { buf[3] = 0; if (strcmp(buf,"DEF") ==0) { printf("\n%s",buf); while(1==read_some(buf,1,'\"',1)) { if (buf[0] == ')') break; }} if (strcmp(buf,"DO_") ==0) {printf("\n%s",buf); read_some(buf,0,'\n',1); ungetc('\n',stdin); } } printf("\n"); exit(0); }
void async_file::write_some( boost::system::error_code const& error, // Result of operation. std::size_t bytes_transferred) // Number of bytes read. { if (bytes_transferred > 0) on_bytes_written(bytes_transferred); inq.emplace_back(256); sd.async_write_some( boost::asio::buffer(inq.back().as_vector()), [this](boost::system::error_code const& error, std::size_t bytes_transferred) { read_some(error, bytes_transferred); }); }
// Load data from the file. bool JsonLoader::Reader::read_some() { if (_fd < 0) { // loading from a string. return false; } ssize_t nr = _file_buf.append_from_file_descriptor(_fd, 65536); if (nr < 0) { if (errno == EINTR) { return read_some(); } PLOG(ERROR) << "Fail to read fd=" << _fd; return false; } else if (nr == 0) { return false; } else { return true; } }
void stream_socket::async_read_some(mutable_buffer const &buffer,io_handler const &h) { if(!dont_block(h)) return; #ifdef BOOSTER_AIO_FORCE_POLL reader_some::pointer reader(new reader_some(h,buffer,this)); on_readable(reader); #else system::error_code e; size_t n = read_some(buffer,e); if(e && would_block(e)) { reader_some::pointer reader(new reader_some(h,buffer,this)); on_readable(reader); } else { io_binder::pointer binder(new io_binder( h,n,e )); get_io_service().post(binder); } #endif }
std::size_t read_some(const MutableBufferSequence& buffers , boost::system::error_code& ec) { ec = boost::system::error_code(); typename MutableBufferSequence::const_iterator iter = buffers.begin(); typename MutableBufferSequence::const_iterator end = buffers.end(); DWORD i = 0; size_t buffer_size = 0; size_t bytes_transferred = 0; size_t total_bytes_transferred = 0; for (; !ec && iter != end && i < max_buffers; ++iter, ++i) { boost::asio::mutable_buffer buffer(*iter); buffer_size = boost::asio::buffer_size(buffer); bytes_transferred = read_some( boost::asio::buffer_cast<char*>(buffer), buffer_size , ec); if (bytes_transferred < buffer_size) return bytes_transferred; total_bytes_transferred += buffer_size; } return total_bytes_transferred; }
// Separate jsons with closed braces. bool JsonLoader::Reader::get_next_json(butil::IOBuf* json1) { if (_file_buf.empty()) { if (!read_some()) { return false; } } json1->clear(); while (1) { butil::IOBufAsZeroCopyInputStream it(_file_buf); const void* data = NULL; int size = 0; int total_size = 0; int skipped = 0; for (; it.Next(&data, &size); total_size += size) { for (int i = 0; i < size; ++i) { const char c = ((const char*)data)[i]; if (_brace_depth == 0) { // skip any character until the first left brace is found. if (c != '{') { ++skipped; continue; } } switch (c) { case '{': if (!_quoted) { ++_brace_depth; } else { VLOG(1) << "Quoted left brace"; } break; case '}': if (!_quoted) { --_brace_depth; if (_brace_depth == 0) { // the braces are closed, a complete object. _file_buf.cutn(json1, total_size + i + 1); json1->pop_front(skipped); return possibly_valid_json(*json1); } else if (_brace_depth < 0) { LOG(ERROR) << "More right braces than left braces"; return false; } } else { VLOG(1) << "Quoted right brace"; } break; case '"': if (_quoted) { if (_quote_char == '"') { _quoted = false; } } else { _quoted = true; _quote_char = '"'; } break; case '\'': if (_quoted) { if (_quote_char == '\'') { _quoted = false; } } else { _quoted = true; _quote_char = '\''; } break; default: break; // just skip } } } if (!_file_buf.empty()) { json1->append(_file_buf); _file_buf.clear(); } if (!read_some()) { json1->pop_front(skipped); if (!json1->empty()) { return possibly_valid_json(*json1); } return false; } } return false; }
void bind(endpoint_type const& endpoint); std::size_t available() const; #endif void open(protocol_type const& p, error_code& ec); void close(error_code& ec); endpoint_type local_endpoint(error_code& ec) const; endpoint_type remote_endpoint(error_code& ec) const; 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)
void start() { auto that = shared_from_this(); socket_->async_start( [that]() { that->read_some(); } ); }