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>
