stream.c File Reference

#include <assert.h>
#include "uv.h"
#include "internal.h"
#include "handle-inl.h"
#include "req-inl.h"

Go to the source code of this file.

Functions
int	uv_listen (uv_stream_t *stream, int backlog, uv_connection_cb cb)
int	uv_accept (uv_stream_t *server, uv_stream_t *client)
int	uv_read_start (uv_stream_t *handle, uv_alloc_cb alloc_cb, uv_read_cb read_cb)
int	uv_read_stop (uv_stream_t *handle)
int	uv_write (uv_write_t *req, uv_stream_t *handle, const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb)
int	uv_write2 (uv_write_t *req, uv_stream_t *handle, const uv_buf_t bufs[], unsigned int nbufs, uv_stream_t *send_handle, uv_write_cb cb)
int	uv_try_write (uv_stream_t *stream, const uv_buf_t bufs[], unsigned int nbufs)
int	uv_shutdown (uv_shutdown_t *req, uv_stream_t *handle, uv_shutdown_cb cb)
int	uv_is_readable (const uv_stream_t *handle)
int	uv_is_writable (const uv_stream_t *handle)
int	uv_stream_set_blocking (uv_stream_t *handle, int blocking)

Function Documentation

uv_accept()

int uv_accept	(	uv_stream_t *	server,
		uv_stream_t *	client
	)

Definition at line 49 of file stream.c.

                                                        {
  int err;
 
  err = ERROR_INVALID_PARAMETER;
  switch (server->type) {
    case UV_TCP:
      err = uv_tcp_accept((uv_tcp_t*)server, (uv_tcp_t*)client);
      break;
    case UV_NAMED_PIPE:
      err = uv_pipe_accept((uv_pipe_t*)server, client);
      break;
    default:
      assert(0);
  }
 
  return uv_translate_sys_error(err);
}

References assert(), done, err, uv__stream_queued_fds_s::fds, NULL, uv__stream_queued_fds_s::offset, uv__close(), uv__free(), uv__io_start(), uv__stream_open(), UV_HANDLE_BOUND, UV_HANDLE_READABLE, UV_HANDLE_WRITABLE, uv_pipe_accept(), uv_tcp_accept(), uv_translate_sys_error(), and uv_udp_open().

Referenced by on_new_connection().

uv_is_readable()

int uv_is_readable

(

const uv_stream_t *

handle

)

Definition at line 223 of file stream.c.

                                              {
  return !!(handle->flags & UV_HANDLE_READABLE);
}

References handle, and UV_HANDLE_READABLE.

uv_is_writable()

int uv_is_writable

(

const uv_stream_t *

handle

)

Definition at line 228 of file stream.c.

                                              {
  return !!(handle->flags & UV_HANDLE_WRITABLE);
}

References handle, and UV_HANDLE_WRITABLE.

uv_listen()

int uv_listen	(	uv_stream_t *	stream,
		int	backlog,
		uv_connection_cb	cb
	)

Definition at line 30 of file stream.c.

                                                                     {
  int err;
 
  err = ERROR_INVALID_PARAMETER;
  switch (stream->type) {
    case UV_TCP:
      err = uv_tcp_listen((uv_tcp_t*)stream, backlog, cb);
      break;
    case UV_NAMED_PIPE:
      err = uv_pipe_listen((uv_pipe_t*)stream, backlog, cb);
      break;
    default:
      assert(0);
  }
 
  return uv_translate_sys_error(err);
}

References assert(), cb, err, uv__handle_start, uv_pipe_listen(), uv_tcp_listen(), and uv_translate_sys_error().

Referenced by main().

uv_read_start()

int uv_read_start	(	uv_stream_t *	handle,
		uv_alloc_cb	alloc_cb,
		uv_read_cb	read_cb
	)

Definition at line 68 of file stream.c.

                        {
  int err;
 
  if (handle->flags & UV_HANDLE_READING) {
    return UV_EALREADY;
  }
 
  if (!(handle->flags & UV_HANDLE_READABLE)) {
    return UV_ENOTCONN;
  }
 
  err = ERROR_INVALID_PARAMETER;
  switch (handle->type) {
    case UV_TCP:
      err = uv_tcp_read_start((uv_tcp_t*)handle, alloc_cb, read_cb);
      break;
    case UV_NAMED_PIPE:
      err = uv_pipe_read_start((uv_pipe_t*)handle, alloc_cb, read_cb);
      break;
    case UV_TTY:
      err = uv_tty_read_start((uv_tty_t*) handle, alloc_cb, read_cb);
      break;
    default:
      assert(0);
  }
 
  return uv_translate_sys_error(err);
}

References assert(), err, handle, uv__handle_start, uv__io_start(), uv__stream_fd, uv__stream_osx_interrupt_select(), UV_HANDLE_CLOSING, UV_HANDLE_READABLE, UV_HANDLE_READING, uv_pipe_read_start(), uv_tcp_read_start(), uv_translate_sys_error(), and uv_tty_read_start().

Referenced by main(), on_connect(), and on_new_connection().

uv_read_stop()

int uv_read_stop

(

uv_stream_t *

handle

)

Definition at line 99 of file stream.c.

                                      {
  int err;
 
  if (!(handle->flags & UV_HANDLE_READING))
    return 0;
 
  err = 0;
  if (handle->type == UV_TTY) {
    err = uv_tty_read_stop((uv_tty_t*) handle);
  } else if (handle->type == UV_NAMED_PIPE) {
    uv__pipe_read_stop((uv_pipe_t*) handle);
  } else {
    handle->flags &= ~UV_HANDLE_READING;
    DECREASE_ACTIVE_COUNT(handle->loop, handle);
  }
 
  return uv_translate_sys_error(err);
}

References DECREASE_ACTIVE_COUNT, err, handle, NULL, uv__handle_stop, uv__io_active(), uv__io_stop(), uv__pipe_read_stop(), uv__stream_osx_interrupt_select(), UV_HANDLE_READING, uv_translate_sys_error(), and uv_tty_read_stop().

Referenced by eof_timer_cb(), uv_pipe_read_eof(), and uv_pipe_read_error().

uv_shutdown()

int uv_shutdown	(	uv_shutdown_t *	req,
		uv_stream_t *	handle,
		uv_shutdown_cb	cb
	)

Definition at line 198 of file stream.c.

                                                                            {
  uv_loop_t* loop = handle->loop;
 
  if (!(handle->flags & UV_HANDLE_WRITABLE) ||
      handle->flags & UV_HANDLE_SHUTTING ||
      uv__is_closing(handle)) {
    return UV_ENOTCONN;
  }
 
  UV_REQ_INIT(req, UV_SHUTDOWN);
  req->handle = handle;
  req->cb = cb;
 
  handle->flags &= ~UV_HANDLE_WRITABLE;
  handle->flags |= UV_HANDLE_SHUTTING;
  handle->stream.conn.shutdown_req = req;
  handle->reqs_pending++;
  REGISTER_HANDLE_REQ(loop, handle, req);
 
  uv_want_endgame(loop, (uv_handle_t*)handle);
 
  return 0;
}

References assert(), cb, handle, loop, REGISTER_HANDLE_REQ, req, uv__io_start(), uv__is_closing, uv__req_init, uv__stream_fd, uv__stream_osx_interrupt_select(), UV_HANDLE_SHUT, UV_HANDLE_SHUTTING, UV_HANDLE_WRITABLE, UV_REQ_INIT, and uv_want_endgame().

uv_stream_set_blocking()

int uv_stream_set_blocking	(	uv_stream_t *	handle,
		int	blocking
	)

Definition at line 233 of file stream.c.

                                                              {
  if (handle->type != UV_NAMED_PIPE)
    return UV_EINVAL;
 
  if (blocking != 0)
    handle->flags |= UV_HANDLE_BLOCKING_WRITES;
  else
    handle->flags &= ~UV_HANDLE_BLOCKING_WRITES;
 
  return 0;
}

References handle, uv__nonblock, uv__stream_fd, and UV_HANDLE_BLOCKING_WRITES.

uv_try_write()

int uv_try_write	(	uv_stream_t *	stream,
		const uv_buf_t	bufs[],
		unsigned int	nbufs
	)

Definition at line 176 of file stream.c.

                                     {
  if (stream->flags & UV_HANDLE_CLOSING)
    return UV_EBADF;
  if (!(stream->flags & UV_HANDLE_WRITABLE))
    return UV_EPIPE;
 
  switch (stream->type) {
    case UV_TCP:
      return uv__tcp_try_write((uv_tcp_t*) stream, bufs, nbufs);
    case UV_TTY:
      return uv__tty_try_write((uv_tty_t*) stream, bufs, nbufs);
    case UV_NAMED_PIPE:
      return UV_EAGAIN;
    default:
      assert(0);
      return UV_ENOSYS;
  }
}

References assert(), bufs, NULL, QUEUE_REMOVE, r, req, uv__count_bufs(), uv__free(), uv__io_active(), uv__io_stop(), uv__req_unregister, uv__stream_osx_interrupt_select(), uv__tcp_try_write(), uv__tty_try_write(), uv__write_req_size(), UV_HANDLE_CLOSING, UV_HANDLE_WRITABLE, uv_try_write_cb(), and uv_write().

uv_write()

int uv_write	(	uv_write_t *	req,
		uv_stream_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		uv_write_cb	cb
	)

Definition at line 119 of file stream.c.

                             {
  uv_loop_t* loop = handle->loop;
  int err;
 
  if (!(handle->flags & UV_HANDLE_WRITABLE)) {
    return UV_EPIPE;
  }
 
  err = ERROR_INVALID_PARAMETER;
  switch (handle->type) {
    case UV_TCP:
      err = uv_tcp_write(loop, req, (uv_tcp_t*) handle, bufs, nbufs, cb);
      break;
    case UV_NAMED_PIPE:
      err = uv__pipe_write(
          loop, req, (uv_pipe_t*) handle, bufs, nbufs, NULL, cb);
      break;
    case UV_TTY:
      err = uv_tty_write(loop, req, (uv_tty_t*) handle, bufs, nbufs, cb);
      break;
    default:
      assert(0);
  }
 
  return uv_translate_sys_error(err);
}

References assert(), bufs, cb, err, handle, loop, NULL, req, uv__pipe_write(), UV_HANDLE_WRITABLE, uv_tcp_write(), uv_translate_sys_error(), uv_tty_write(), and uv_write2().

Referenced by echo_read(), main(), update(), and write_data().

uv_write2()

int uv_write2	(	uv_write_t *	req,
		uv_stream_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		uv_stream_t *	send_handle,
		uv_write_cb	cb
	)

Definition at line 151 of file stream.c.

                              {
  uv_loop_t* loop = handle->loop;
  int err;
 
  if (send_handle == NULL) {
    return uv_write(req, handle, bufs, nbufs, cb);
  }
 
  if (handle->type != UV_NAMED_PIPE || !((uv_pipe_t*) handle)->ipc) {
    return UV_EINVAL;
  } else if (!(handle->flags & UV_HANDLE_WRITABLE)) {
    return UV_EPIPE;
  }
 
  err = uv__pipe_write(
      loop, req, (uv_pipe_t*) handle, bufs, nbufs, send_handle, cb);
  return uv_translate_sys_error(err);
}

References ARRAY_SIZE, assert(), bufs, cb, err, handle, loop, memcpy(), NULL, QUEUE_INIT, QUEUE_INSERT_TAIL, req, uv__count_bufs(), uv__handle_fd(), uv__io_start(), uv__malloc(), uv__pipe_write(), uv__req_init, uv__stream_fd, uv__stream_osx_interrupt_select(), uv__write(), UV_HANDLE_BLOCKING_WRITES, UV_HANDLE_WRITABLE, uv_translate_sys_error(), and uv_write().

Referenced by on_new_connection().