/* _raft_readname(): parse a raft host:port peer name. */ static u2_rnam* _raft_readname(const c3_c* str_c, c3_w siz_w) { u2_rnam* nam_u = calloc(1, sizeof(*nam_u)); c3_c* col_c; c3_w nam_w; nam_u->str_c = malloc(siz_w + 1); strncpy(nam_u->str_c, str_c, siz_w); nam_u->str_c[siz_w] = '\0'; //fprintf(stderr, "raft: peer %s\n", nam_u->str_c); if ( 0 == (col_c = strchr(nam_u->str_c, ':')) ) { uL(fprintf(uH, "raft: invalid name %s\n", nam_u->str_c)); _raft_rnam_free(nam_u); nam_u = 0; } else { nam_w = col_c - nam_u->str_c + 1; nam_u->nam_c = malloc(nam_w); uv_strlcpy(nam_u->nam_c, nam_u->str_c, nam_w); nam_u->por_c = strdup(col_c + 1); } return nam_u; }
void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle, const char* name, uv_connect_cb cb) { struct sockaddr_un saddr; int saved_errno; int new_sock; int err; int r; saved_errno = errno; new_sock = (handle->fd == -1); err = -1; if (new_sock) if ((handle->fd = uv__socket(AF_UNIX, SOCK_STREAM, 0)) == -1) goto out; memset(&saddr, 0, sizeof saddr); uv_strlcpy(saddr.sun_path, name, sizeof(saddr.sun_path)); saddr.sun_family = AF_UNIX; /* We don't check for EINPROGRESS. Think about it: the socket * is either there or not. */ do { r = connect(handle->fd, (struct sockaddr*)&saddr, sizeof saddr); } while (r == -1 && errno == EINTR); if (r == -1) goto out; if (new_sock) if (uv__stream_open((uv_stream_t*)handle, handle->fd, UV_STREAM_READABLE | UV_STREAM_WRITABLE)) goto out; uv__io_start(handle->loop, &handle->read_watcher); uv__io_start(handle->loop, &handle->write_watcher); err = 0; out: handle->delayed_error = err ? errno : 0; /* Passed to callback. */ handle->connect_req = req; uv__req_init(handle->loop, req, UV_CONNECT); req->handle = (uv_stream_t*)handle; req->cb = cb; ngx_queue_init(&req->queue); /* Run callback on next tick. */ uv__io_feed(handle->loop, &handle->write_watcher, UV__IO_WRITE); /* Mimic the Windows pipe implementation, always * return 0 and let the callback handle errors. */ errno = saved_errno; }
void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle, const char* name, uv_connect_cb cb) { struct sockaddr_un saddr; int saved_errno; int new_sock; int err; int r; saved_errno = errno; new_sock = (uv__stream_fd(handle) == -1); err = -1; if (new_sock) if ((handle->io_watcher.fd = uv__socket(AF_UNIX, SOCK_STREAM, 0)) == -1) goto out; memset(&saddr, 0, sizeof saddr); uv_strlcpy(saddr.sun_path, name, sizeof(saddr.sun_path)); saddr.sun_family = AF_UNIX; do { r = connect(uv__stream_fd(handle), (struct sockaddr*)&saddr, sizeof saddr); } while (r == -1 && errno == EINTR); if (r == -1) if (errno != EINPROGRESS) goto out; if (new_sock) if (uv__stream_open((uv_stream_t*)handle, uv__stream_fd(handle), UV_STREAM_READABLE | UV_STREAM_WRITABLE)) goto out; uv__io_start(handle->loop, &handle->io_watcher, UV__POLLIN | UV__POLLOUT); err = 0; out: handle->delayed_error = err ? errno : 0; /* Passed to callback. */ handle->connect_req = req; uv__req_init(handle->loop, req, UV_CONNECT); req->handle = (uv_stream_t*)handle; req->cb = cb; QUEUE_INIT(&req->queue); /* Force callback to run on next tick in case of error. */ if (err != 0) uv__io_feed(handle->loop, &handle->io_watcher); /* Mimic the Windows pipe implementation, always * return 0 and let the callback handle errors. */ errno = saved_errno; }
int uv_pipe_bind(uv_pipe_t* handle, const char* name) { struct sockaddr_un saddr; const char* pipe_fname; int saved_errno; int sockfd; int status; int bound; saved_errno = errno; pipe_fname = NULL; sockfd = -1; status = -1; bound = 0; /* Already bound? */ if (handle->fd >= 0) { uv__set_artificial_error(handle->loop, UV_EINVAL); goto out; } /* Make a copy of the file name, it outlives this function's scope. */ if ((pipe_fname = strdup(name)) == NULL) { uv__set_sys_error(handle->loop, ENOMEM); goto out; } /* We've got a copy, don't touch the original any more. */ name = NULL; if ((sockfd = uv__socket(AF_UNIX, SOCK_STREAM, 0)) == -1) { uv__set_sys_error(handle->loop, errno); goto out; } memset(&saddr, 0, sizeof saddr); uv_strlcpy(saddr.sun_path, pipe_fname, sizeof(saddr.sun_path)); saddr.sun_family = AF_UNIX; if (bind(sockfd, (struct sockaddr*)&saddr, sizeof saddr)) { /* Convert ENOENT to EACCES for compatibility with Windows. */ uv__set_sys_error(handle->loop, (errno == ENOENT) ? EACCES : errno); goto out; } bound = 1; /* Success. */ handle->pipe_fname = pipe_fname; /* Is a strdup'ed copy. */ handle->fd = sockfd; status = 0; out: /* Clean up on error. */ if (status) { if (bound) { /* unlink() before close() to avoid races. */ assert(pipe_fname != NULL); unlink(pipe_fname); } close(sockfd); free((void*)pipe_fname); } errno = saved_errno; return status; }
void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle, const char* name, uv_connect_cb cb) { struct sockaddr_un saddr; int saved_errno; int sockfd; int status; int r; saved_errno = errno; sockfd = -1; status = -1; if ((sockfd = uv__socket(AF_UNIX, SOCK_STREAM, 0)) == -1) { uv__set_sys_error(handle->loop, errno); goto out; } memset(&saddr, 0, sizeof saddr); uv_strlcpy(saddr.sun_path, name, sizeof(saddr.sun_path)); saddr.sun_family = AF_UNIX; /* We don't check for EINPROGRESS. Think about it: the socket * is either there or not. */ do { r = connect(sockfd, (struct sockaddr*)&saddr, sizeof saddr); } while (r == -1 && errno == EINTR); if (r == -1) { status = errno; uv__close(sockfd); goto out; } uv__stream_open((uv_stream_t*)handle, sockfd, UV_READABLE | UV_WRITABLE); ev_io_start(handle->loop->ev, &handle->read_watcher); ev_io_start(handle->loop->ev, &handle->write_watcher); status = 0; out: handle->delayed_error = status; /* Passed to callback. */ handle->connect_req = req; req->handle = (uv_stream_t*)handle; req->type = UV_CONNECT; req->cb = cb; ngx_queue_init(&req->queue); /* Run callback on next tick. */ ev_feed_event(handle->loop->ev, &handle->read_watcher, EV_CUSTOM); assert(ev_is_pending(&handle->read_watcher)); /* Mimic the Windows pipe implementation, always * return 0 and let the callback handle errors. */ errno = saved_errno; }