1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved. 2 * 3 * Permission is hereby granted, free of charge, to any person obtaining a copy 4 * of this software and associated documentation files (the "Software"), to 5 * deal in the Software without restriction, including without limitation the 6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 7 * sell copies of the Software, and to permit persons to whom the Software is 8 * furnished to do so, subject to the following conditions: 9 * 10 * The above copyright notice and this permission notice shall be included in 11 * all copies or substantial portions of the Software. 12 * 13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 19 * IN THE SOFTWARE. 20 */ 21 22 #include "uv.h" 23 #include "internal.h" 24 25 #include <assert.h> 26 #include <errno.h> 27 #include <string.h> 28 #include <sys/un.h> 29 #include <unistd.h> 30 #include <stdlib.h> 31 32 33 /* Does the file path contain embedded nul bytes? */ 34 static int includes_invalid_nul(const char *s, size_t n) { 35 if (n == 0) 36 return 0; 37 #ifdef __linux__ 38 /* Accept abstract socket namespace paths, throughout which nul bytes have 39 * no special significance ("\0foo\0bar"). 40 */ 41 if (s[0] == '\0') 42 return 0; 43 #endif 44 return NULL != memchr(s, '\0', n); 45 } 46 47 48 int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc) { 49 uv__stream_init(loop, (uv_stream_t*)handle, UV_NAMED_PIPE); 50 handle->shutdown_req = NULL; 51 handle->connect_req = NULL; 52 handle->pipe_fname = NULL; 53 handle->ipc = ipc; 54 return 0; 55 } 56 57 58 int uv_pipe_bind(uv_pipe_t* handle, const char* name) { 59 return uv_pipe_bind2(handle, name, strlen(name), 0); 60 } 61 62 63 int uv_pipe_bind2(uv_pipe_t* handle, 64 const char* name, 65 size_t namelen, 66 unsigned int flags) { 67 struct sockaddr_un saddr; 68 char* pipe_fname; 69 int sockfd; 70 int err; 71 socklen_t addrlen; 72 73 pipe_fname = NULL; 74 75 if (flags & ~UV_PIPE_NO_TRUNCATE) 76 return UV_EINVAL; 77 78 if (name == NULL) 79 return UV_EINVAL; 80 81 /* namelen==0 on Linux means autobind the listen socket in the abstract 82 * socket namespace, see `man 7 unix` for details. 83 */ 84 #if !defined(__linux__) 85 if (namelen == 0) 86 return UV_EINVAL; 87 #endif 88 89 if (includes_invalid_nul(name, namelen)) 90 return UV_EINVAL; 91 92 if (flags & UV_PIPE_NO_TRUNCATE) 93 if (namelen > sizeof(saddr.sun_path)) 94 return UV_EINVAL; 95 96 /* Truncate long paths. Documented behavior. */ 97 if (namelen > sizeof(saddr.sun_path)) 98 namelen = sizeof(saddr.sun_path); 99 100 /* Already bound? */ 101 if (uv__stream_fd(handle) >= 0) 102 return UV_EINVAL; 103 104 if (uv__is_closing(handle)) 105 return UV_EINVAL; 106 107 /* Make a copy of the file path unless it is an abstract socket. 108 * We unlink the file later but abstract sockets disappear 109 * automatically since they're not real file system entities. 110 */ 111 if (*name == '\0') { 112 addrlen = offsetof(struct sockaddr_un, sun_path) + namelen; 113 } else { 114 pipe_fname = uv__malloc(namelen + 1); 115 if (pipe_fname == NULL) 116 return UV_ENOMEM; 117 memcpy(pipe_fname, name, namelen); 118 pipe_fname[namelen] = '\0'; 119 addrlen = sizeof saddr; 120 } 121 122 err = uv__socket(AF_UNIX, SOCK_STREAM, 0); 123 if (err < 0) 124 goto err_socket; 125 sockfd = err; 126 127 memset(&saddr, 0, sizeof saddr); 128 memcpy(&saddr.sun_path, name, namelen); 129 saddr.sun_family = AF_UNIX; 130 131 if (bind(sockfd, (struct sockaddr*)&saddr, addrlen)) { 132 err = UV__ERR(errno); 133 /* Convert ENOENT to EACCES for compatibility with Windows. */ 134 if (err == UV_ENOENT) 135 err = UV_EACCES; 136 137 uv__close(sockfd); 138 goto err_socket; 139 } 140 141 /* Success. */ 142 handle->flags |= UV_HANDLE_BOUND; 143 handle->pipe_fname = pipe_fname; /* NULL or a copy of |name| */ 144 handle->io_watcher.fd = sockfd; 145 return 0; 146 147 err_socket: 148 uv__free(pipe_fname); 149 return err; 150 } 151 152 153 int uv__pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb) { 154 if (uv__stream_fd(handle) == -1) 155 return UV_EINVAL; 156 157 if (handle->ipc) 158 return UV_EINVAL; 159 160 #if defined(__MVS__) || defined(__PASE__) 161 /* On zOS, backlog=0 has undefined behaviour */ 162 /* On IBMi PASE, backlog=0 leads to "Connection refused" error */ 163 if (backlog == 0) 164 backlog = 1; 165 else if (backlog < 0) 166 backlog = SOMAXCONN; 167 #endif 168 169 if (listen(uv__stream_fd(handle), backlog)) 170 return UV__ERR(errno); 171 172 handle->connection_cb = cb; 173 handle->io_watcher.cb = uv__server_io; 174 uv__io_start(handle->loop, &handle->io_watcher, POLLIN); 175 return 0; 176 } 177 178 179 void uv__pipe_close(uv_pipe_t* handle) { 180 if (handle->pipe_fname) { 181 /* 182 * Unlink the file system entity before closing the file descriptor. 183 * Doing it the other way around introduces a race where our process 184 * unlinks a socket with the same name that's just been created by 185 * another thread or process. 186 */ 187 unlink(handle->pipe_fname); 188 uv__free((void*)handle->pipe_fname); 189 handle->pipe_fname = NULL; 190 } 191 192 uv__stream_close((uv_stream_t*)handle); 193 } 194 195 196 int uv_pipe_open(uv_pipe_t* handle, uv_file fd) { 197 int flags; 198 int mode; 199 int err; 200 flags = 0; 201 202 if (uv__fd_exists(handle->loop, fd)) 203 return UV_EEXIST; 204 205 do 206 mode = fcntl(fd, F_GETFL); 207 while (mode == -1 && errno == EINTR); 208 209 if (mode == -1) 210 return UV__ERR(errno); /* according to docs, must be EBADF */ 211 212 err = uv__nonblock(fd, 1); 213 if (err) 214 return err; 215 216 #if defined(__APPLE__) 217 err = uv__stream_try_select((uv_stream_t*) handle, &fd); 218 if (err) 219 return err; 220 #endif /* defined(__APPLE__) */ 221 222 mode &= O_ACCMODE; 223 if (mode != O_WRONLY) 224 flags |= UV_HANDLE_READABLE; 225 if (mode != O_RDONLY) 226 flags |= UV_HANDLE_WRITABLE; 227 228 return uv__stream_open((uv_stream_t*)handle, fd, flags); 229 } 230 231 232 void uv_pipe_connect(uv_connect_t* req, 233 uv_pipe_t* handle, 234 const char* name, 235 uv_connect_cb cb) { 236 int err; 237 238 err = uv_pipe_connect2(req, handle, name, strlen(name), 0, cb); 239 240 if (err) { 241 handle->delayed_error = err; 242 handle->connect_req = req; 243 244 uv__req_init(handle->loop, req, UV_CONNECT); 245 req->handle = (uv_stream_t*) handle; 246 req->cb = cb; 247 uv__queue_init(&req->queue); 248 249 /* Force callback to run on next tick in case of error. */ 250 uv__io_feed(handle->loop, &handle->io_watcher); 251 } 252 } 253 254 255 int uv_pipe_connect2(uv_connect_t* req, 256 uv_pipe_t* handle, 257 const char* name, 258 size_t namelen, 259 unsigned int flags, 260 uv_connect_cb cb) { 261 struct sockaddr_un saddr; 262 int new_sock; 263 int err; 264 int r; 265 socklen_t addrlen; 266 267 if (flags & ~UV_PIPE_NO_TRUNCATE) 268 return UV_EINVAL; 269 270 if (name == NULL) 271 return UV_EINVAL; 272 273 if (namelen == 0) 274 return UV_EINVAL; 275 276 if (includes_invalid_nul(name, namelen)) 277 return UV_EINVAL; 278 279 if (flags & UV_PIPE_NO_TRUNCATE) 280 if (namelen > sizeof(saddr.sun_path)) 281 return UV_EINVAL; 282 283 /* Truncate long paths. Documented behavior. */ 284 if (namelen > sizeof(saddr.sun_path)) 285 namelen = sizeof(saddr.sun_path); 286 287 new_sock = (uv__stream_fd(handle) == -1); 288 289 if (new_sock) { 290 err = uv__socket(AF_UNIX, SOCK_STREAM, 0); 291 if (err < 0) 292 goto out; 293 handle->io_watcher.fd = err; 294 } 295 296 memset(&saddr, 0, sizeof saddr); 297 memcpy(&saddr.sun_path, name, namelen); 298 saddr.sun_family = AF_UNIX; 299 300 if (*name == '\0') 301 addrlen = offsetof(struct sockaddr_un, sun_path) + namelen; 302 else 303 addrlen = sizeof saddr; 304 305 do { 306 r = connect(uv__stream_fd(handle), (struct sockaddr*)&saddr, addrlen); 307 } 308 while (r == -1 && errno == EINTR); 309 310 if (r == -1 && errno != EINPROGRESS) { 311 err = UV__ERR(errno); 312 #if defined(__CYGWIN__) || defined(__MSYS__) 313 /* EBADF is supposed to mean that the socket fd is bad, but 314 Cygwin reports EBADF instead of ENOTSOCK when the file is 315 not a socket. We do not expect to see a bad fd here 316 (e.g. due to new_sock), so translate the error. */ 317 if (err == UV_EBADF) 318 err = UV_ENOTSOCK; 319 #endif 320 goto out; 321 } 322 323 err = 0; 324 if (new_sock) { 325 err = uv__stream_open((uv_stream_t*)handle, 326 uv__stream_fd(handle), 327 UV_HANDLE_READABLE | UV_HANDLE_WRITABLE); 328 } 329 330 if (err == 0) 331 uv__io_start(handle->loop, &handle->io_watcher, POLLOUT); 332 333 out: 334 handle->delayed_error = err; 335 handle->connect_req = req; 336 337 uv__req_init(handle->loop, req, UV_CONNECT); 338 req->handle = (uv_stream_t*) handle; 339 req->cb = cb; 340 uv__queue_init(&req->queue); 341 342 /* Force callback to run on next tick in case of error. */ 343 if (err) 344 uv__io_feed(handle->loop, &handle->io_watcher); 345 346 return 0; 347 } 348 349 350 static int uv__pipe_getsockpeername(const uv_pipe_t* handle, 351 uv__peersockfunc func, 352 char* buffer, 353 size_t* size) { 354 #if defined(__linux__) 355 static const int is_linux = 1; 356 #else 357 static const int is_linux = 0; 358 #endif 359 struct sockaddr_un sa; 360 socklen_t addrlen; 361 size_t slop; 362 char* p; 363 int err; 364 365 if (buffer == NULL || size == NULL || *size == 0) 366 return UV_EINVAL; 367 368 addrlen = sizeof(sa); 369 memset(&sa, 0, addrlen); 370 err = uv__getsockpeername((const uv_handle_t*) handle, 371 func, 372 (struct sockaddr*) &sa, 373 (int*) &addrlen); 374 if (err < 0) { 375 *size = 0; 376 return err; 377 } 378 379 slop = 1; 380 if (is_linux && sa.sun_path[0] == '\0') { 381 /* Linux abstract namespace. Not zero-terminated. */ 382 slop = 0; 383 addrlen -= offsetof(struct sockaddr_un, sun_path); 384 } else { 385 p = memchr(sa.sun_path, '\0', sizeof(sa.sun_path)); 386 if (p == NULL) 387 p = ARRAY_END(sa.sun_path); 388 addrlen = p - sa.sun_path; 389 } 390 391 if ((size_t)addrlen + slop > *size) { 392 *size = addrlen + slop; 393 return UV_ENOBUFS; 394 } 395 396 memcpy(buffer, sa.sun_path, addrlen); 397 *size = addrlen; 398 399 /* only null-terminate if it's not an abstract socket */ 400 if (buffer[0] != '\0') 401 buffer[addrlen] = '\0'; 402 403 return 0; 404 } 405 406 407 int uv_pipe_getsockname(const uv_pipe_t* handle, char* buffer, size_t* size) { 408 return uv__pipe_getsockpeername(handle, getsockname, buffer, size); 409 } 410 411 412 int uv_pipe_getpeername(const uv_pipe_t* handle, char* buffer, size_t* size) { 413 return uv__pipe_getsockpeername(handle, getpeername, buffer, size); 414 } 415 416 417 void uv_pipe_pending_instances(uv_pipe_t* handle, int count) { 418 } 419 420 421 int uv_pipe_pending_count(uv_pipe_t* handle) { 422 uv__stream_queued_fds_t* queued_fds; 423 424 if (!handle->ipc) 425 return 0; 426 427 if (handle->accepted_fd == -1) 428 return 0; 429 430 if (handle->queued_fds == NULL) 431 return 1; 432 433 queued_fds = handle->queued_fds; 434 return queued_fds->offset + 1; 435 } 436 437 438 uv_handle_type uv_pipe_pending_type(uv_pipe_t* handle) { 439 if (!handle->ipc) 440 return UV_UNKNOWN_HANDLE; 441 442 if (handle->accepted_fd == -1) 443 return UV_UNKNOWN_HANDLE; 444 else 445 return uv_guess_handle(handle->accepted_fd); 446 } 447 448 449 int uv_pipe_chmod(uv_pipe_t* handle, int mode) { 450 char name_buffer[1 + UV__PATH_MAX]; 451 int desired_mode; 452 size_t name_len; 453 const char* name; 454 int fd; 455 int r; 456 457 if (handle == NULL) 458 return UV_EBADF; 459 460 fd = uv__stream_fd(handle); 461 if (fd == -1) 462 return UV_EBADF; 463 464 if (mode != UV_READABLE && 465 mode != UV_WRITABLE && 466 mode != (UV_WRITABLE | UV_READABLE)) 467 return UV_EINVAL; 468 469 desired_mode = 0; 470 if (mode & UV_READABLE) 471 desired_mode |= S_IRUSR | S_IRGRP | S_IROTH; 472 if (mode & UV_WRITABLE) 473 desired_mode |= S_IWUSR | S_IWGRP | S_IWOTH; 474 475 /* fchmod on macOS and (Free|Net|Open)BSD does not support UNIX sockets. */ 476 if (fchmod(fd, desired_mode)) 477 if (errno != EINVAL && errno != EOPNOTSUPP) 478 return UV__ERR(errno); 479 480 /* Fall back to chmod. */ 481 name_len = sizeof(name_buffer); 482 r = uv_pipe_getsockname(handle, name_buffer, &name_len); 483 if (r != 0) 484 return r; 485 name = name_buffer; 486 487 /* On some platforms, getsockname returns an empty string, and we try with pipe_fname. */ 488 if (name_len == 0 && handle->pipe_fname != NULL) 489 name = handle->pipe_fname; 490 491 if (chmod(name, desired_mode)) 492 return UV__ERR(errno); 493 494 return 0; 495 } 496 497 498 int uv_pipe(uv_os_fd_t fds[2], int read_flags, int write_flags) { 499 uv_os_fd_t temp[2]; 500 int err; 501 #if defined(__linux__) || \ 502 defined(__FreeBSD__) || \ 503 defined(__OpenBSD__) || \ 504 defined(__DragonFly__) || \ 505 defined(__NetBSD__) || \ 506 defined(__illumos__) || \ 507 (defined(UV__SOLARIS_11_4) && UV__SOLARIS_11_4) 508 int flags = O_CLOEXEC; 509 510 if ((read_flags & UV_NONBLOCK_PIPE) && (write_flags & UV_NONBLOCK_PIPE)) 511 flags |= UV_FS_O_NONBLOCK; 512 513 if (pipe2(temp, flags)) 514 return UV__ERR(errno); 515 516 if (flags & UV_FS_O_NONBLOCK) { 517 fds[0] = temp[0]; 518 fds[1] = temp[1]; 519 return 0; 520 } 521 #else 522 if (pipe(temp)) 523 return UV__ERR(errno); 524 525 if ((err = uv__cloexec(temp[0], 1))) 526 goto fail; 527 528 if ((err = uv__cloexec(temp[1], 1))) 529 goto fail; 530 #endif 531 532 if (read_flags & UV_NONBLOCK_PIPE) 533 if ((err = uv__nonblock(temp[0], 1))) 534 goto fail; 535 536 if (write_flags & UV_NONBLOCK_PIPE) 537 if ((err = uv__nonblock(temp[1], 1))) 538 goto fail; 539 540 fds[0] = temp[0]; 541 fds[1] = temp[1]; 542 return 0; 543 544 fail: 545 uv__close(temp[0]); 546 uv__close(temp[1]); 547 return err; 548 } 549 550 551 int uv__make_pipe(int fds[2], int flags) { 552 return uv_pipe(fds, 553 flags & UV_NONBLOCK_PIPE, 554 flags & UV_NONBLOCK_PIPE); 555 } 556
Indexes created Tue Feb 24 08:35:24 UTC 2026