/**
* This one is asynchronously triggered, so as to ensure we don't have any
* silly re-entrancy issues.
*/
static void socket_closing_cb(uv_idle_t *idle, int status)
{
my_sockdata_t *sock = idle->data;
uv_idle_stop(idle);
uv_close((uv_handle_t *)idle, generic_close_cb);
if (sock->pending.read) {
/**
* UV doesn't invoke read callbacks once the handle has been closed
* so we must track this ourselves.
*/
lcb_assert(sock->pending.read == 1);
uv_read_stop((uv_stream_t *)&sock->tcp);
sock->pending.read--;
decref_sock(sock);
}
#ifdef DEBUG
if (sock->pending.read || sock->pending.write) {
sock_dump_pending(sock);
}
#endif
decref_sock(sock);
sock_do_uv_close(sock);
(void)status;
}
/******************************************************************************
******************************************************************************
** Connection Functions **
******************************************************************************
******************************************************************************/
static void connect_callback(uv_connect_t *req, int status)
{
my_uvreq_t *uvr = (my_uvreq_t *)req;
if (uvr->cb.conn) {
uvr->cb.conn(&uvr->socket->base, status);
}
decref_sock(uvr->socket);
free(uvr);
}
/******************************************************************************
******************************************************************************
** Connection Functions **
******************************************************************************
******************************************************************************/
static void connect_callback(uv_connect_t *req, int status)
{
my_uvreq_t *uvr = (my_uvreq_t *)req;
set_last_error((my_iops_t *)uvr->socket->base.parent, status);
if (uvr->cb.conn) {
uvr->cb.conn(&uvr->socket->base, status);
}
decref_sock(uvr->socket);
free(uvr);
}
/******************************************************************************
******************************************************************************
** Write Functions **
******************************************************************************
******************************************************************************/
static void write_callback(uv_write_t *req, int status)
{
my_write_t *mw = (my_write_t *)req;
my_writebuf_t *wbuf = PTR_FROM_FIELD(my_writebuf_t, mw, write);
my_sockdata_t *sock = wbuf->sock;
lcb_io_write_cb callback = CbREQ(mw);
if (callback) {
callback(&sock->base, &wbuf->base, status);
}
SOCK_DECR_PENDING(sock, write);
decref_sock(sock);
}
/******************************************************************************
******************************************************************************
** Async Errors **
******************************************************************************
******************************************************************************/
static void err_idle_cb(uv_idle_t *idle, int status)
{
my_uvreq_t *uvr = (my_uvreq_t *)idle;
lcb_io_error_cb callback = uvr->cb.err;
uv_idle_stop(idle);
uv_close((uv_handle_t *)idle, generic_close_cb);
if (callback) {
callback(&uvr->socket->base);
}
decref_sock(uvr->socket);
(void)status;
}
static UVC_READ_CB(read_cb)
{
UVC_READ_CB_VARS()
my_tcp_t *mt = (my_tcp_t *)stream;
my_sockdata_t *sock = PTR_FROM_FIELD(my_sockdata_t, mt, tcp);
my_iops_t *io = (my_iops_t *)sock->base.parent;
lcb_ioC_read2_callback callback = CbREQ(mt);
if (nread == 0) {
/* we have a fixed IOV between requests, so just retry again */
return;
}
/**
* XXX:
* For multi-IOV support, we would require a counter to determine if this
* EAGAIN is spurious (i.e. no previous data in buffer), or actual. In
* the case of the former, we'd retry -- but in the latter it is a signal
* that there is no more pending data within the socket buffer AND we have
* outstanding data to deliver back to the caller.
*/
SOCK_DECR_PENDING(sock, read);
uv_read_stop(stream);
CbREQ(mt) = NULL;
if (nread < 0) {
set_last_error(io, uvc_last_errno(io->loop, nread));
if (uvc_is_eof(io->loop, nread)) {
nread = 0;
}
}
callback(&sock->base, nread, sock->rdarg);
decref_sock(sock);
(void)buf;
}
static UVC_READ_CB(read_cb)
{
UVC_READ_CB_VARS()
my_tcp_t *mt = (my_tcp_t *)stream;
my_sockdata_t *sock = PTR_FROM_FIELD(my_sockdata_t, mt, tcp);
lcb_io_read_cb callback = CbREQ(mt);
/**
* XXX:
* For multi-IOV support, we would require a counter to determine if this
* EAGAIN is spurious (i.e. no previous data in buffer), or actual. In
* the case of the former, we'd retry -- but in the latter it is a signal
* that there is no more pending data within the socket buffer AND we have
* outstanding data to deliver back to the caller.
*/
if (nread == 0) {
sock->cur_iov--;
return;
}
SOCK_DECR_PENDING(sock, read);
uv_read_stop(stream);
CbREQ(mt) = NULL;
if (callback) {
callback(&sock->base, nread);
#ifdef DEBUG
} else {
printf("No callback specified!!\n");
#endif
}
decref_sock(sock);
(void)buf;
}
