1 /* 2 * os-win32.c 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * Copyright (c) 2010-2016 Red Hat, Inc. 6 * 7 * QEMU library functions for win32 which are shared between QEMU and 8 * the QEMU tools. 9 * 10 * Permission is hereby granted, free of charge, to any person obtaining a copy 11 * of this software and associated documentation files (the "Software"), to deal 12 * in the Software without restriction, including without limitation the rights 13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 14 * copies of the Software, and to permit persons to whom the Software is 15 * furnished to do so, subject to the following conditions: 16 * 17 * The above copyright notice and this permission notice shall be included in 18 * all copies or substantial portions of the Software. 19 * 20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 26 * THE SOFTWARE. 27 * 28 * The implementation of g_poll (functions poll_rest, g_poll) at the end of 29 * this file are based on code from GNOME glib-2 and use a different license, 30 * see the license comment there. 31 */ 32 #include "qemu/osdep.h" 33 #include <windows.h> 34 #include "qapi/error.h" 35 #include "sysemu/sysemu.h" 36 #include "qemu/main-loop.h" 37 #include "trace.h" 38 #include "qemu/sockets.h" 39 #include "qemu/cutils.h" 40 41 /* this must come after including "trace.h" */ 42 #include <shlobj.h> 43 44 void *qemu_oom_check(void *ptr) 45 { 46 if (ptr == NULL) { 47 fprintf(stderr, "Failed to allocate memory: %lu\n", GetLastError()); 48 abort(); 49 } 50 return ptr; 51 } 52 53 void *qemu_try_memalign(size_t alignment, size_t size) 54 { 55 void *ptr; 56 57 if (!size) { 58 abort(); 59 } 60 ptr = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE); 61 trace_qemu_memalign(alignment, size, ptr); 62 return ptr; 63 } 64 65 void *qemu_memalign(size_t alignment, size_t size) 66 { 67 return qemu_oom_check(qemu_try_memalign(alignment, size)); 68 } 69 70 void *qemu_anon_ram_alloc(size_t size, uint64_t *align) 71 { 72 void *ptr; 73 74 /* FIXME: this is not exactly optimal solution since VirtualAlloc 75 has 64Kb granularity, but at least it guarantees us that the 76 memory is page aligned. */ 77 ptr = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE); 78 trace_qemu_anon_ram_alloc(size, ptr); 79 return ptr; 80 } 81 82 void qemu_vfree(void *ptr) 83 { 84 trace_qemu_vfree(ptr); 85 if (ptr) { 86 VirtualFree(ptr, 0, MEM_RELEASE); 87 } 88 } 89 90 void qemu_anon_ram_free(void *ptr, size_t size) 91 { 92 trace_qemu_anon_ram_free(ptr, size); 93 if (ptr) { 94 VirtualFree(ptr, 0, MEM_RELEASE); 95 } 96 } 97 98 #ifndef CONFIG_LOCALTIME_R 99 /* FIXME: add proper locking */ 100 struct tm *gmtime_r(const time_t *timep, struct tm *result) 101 { 102 struct tm *p = gmtime(timep); 103 memset(result, 0, sizeof(*result)); 104 if (p) { 105 *result = *p; 106 p = result; 107 } 108 return p; 109 } 110 111 /* FIXME: add proper locking */ 112 struct tm *localtime_r(const time_t *timep, struct tm *result) 113 { 114 struct tm *p = localtime(timep); 115 memset(result, 0, sizeof(*result)); 116 if (p) { 117 *result = *p; 118 p = result; 119 } 120 return p; 121 } 122 #endif /* CONFIG_LOCALTIME_R */ 123 124 void qemu_set_block(int fd) 125 { 126 unsigned long opt = 0; 127 WSAEventSelect(fd, NULL, 0); 128 ioctlsocket(fd, FIONBIO, &opt); 129 } 130 131 void qemu_set_nonblock(int fd) 132 { 133 unsigned long opt = 1; 134 ioctlsocket(fd, FIONBIO, &opt); 135 qemu_fd_register(fd); 136 } 137 138 int socket_set_fast_reuse(int fd) 139 { 140 /* Enabling the reuse of an endpoint that was used by a socket still in 141 * TIME_WAIT state is usually performed by setting SO_REUSEADDR. On Windows 142 * fast reuse is the default and SO_REUSEADDR does strange things. So we 143 * don't have to do anything here. More info can be found at: 144 * http://msdn.microsoft.com/en-us/library/windows/desktop/ms740621.aspx */ 145 return 0; 146 } 147 148 149 static int socket_error(void) 150 { 151 switch (WSAGetLastError()) { 152 case 0: 153 return 0; 154 case WSAEINTR: 155 return EINTR; 156 case WSAEINVAL: 157 return EINVAL; 158 case WSA_INVALID_HANDLE: 159 return EBADF; 160 case WSA_NOT_ENOUGH_MEMORY: 161 return ENOMEM; 162 case WSA_INVALID_PARAMETER: 163 return EINVAL; 164 case WSAENAMETOOLONG: 165 return ENAMETOOLONG; 166 case WSAENOTEMPTY: 167 return ENOTEMPTY; 168 case WSAEWOULDBLOCK: 169 /* not using EWOULDBLOCK as we don't want code to have 170 * to check both EWOULDBLOCK and EAGAIN */ 171 return EAGAIN; 172 case WSAEINPROGRESS: 173 return EINPROGRESS; 174 case WSAEALREADY: 175 return EALREADY; 176 case WSAENOTSOCK: 177 return ENOTSOCK; 178 case WSAEDESTADDRREQ: 179 return EDESTADDRREQ; 180 case WSAEMSGSIZE: 181 return EMSGSIZE; 182 case WSAEPROTOTYPE: 183 return EPROTOTYPE; 184 case WSAENOPROTOOPT: 185 return ENOPROTOOPT; 186 case WSAEPROTONOSUPPORT: 187 return EPROTONOSUPPORT; 188 case WSAEOPNOTSUPP: 189 return EOPNOTSUPP; 190 case WSAEAFNOSUPPORT: 191 return EAFNOSUPPORT; 192 case WSAEADDRINUSE: 193 return EADDRINUSE; 194 case WSAEADDRNOTAVAIL: 195 return EADDRNOTAVAIL; 196 case WSAENETDOWN: 197 return ENETDOWN; 198 case WSAENETUNREACH: 199 return ENETUNREACH; 200 case WSAENETRESET: 201 return ENETRESET; 202 case WSAECONNABORTED: 203 return ECONNABORTED; 204 case WSAECONNRESET: 205 return ECONNRESET; 206 case WSAENOBUFS: 207 return ENOBUFS; 208 case WSAEISCONN: 209 return EISCONN; 210 case WSAENOTCONN: 211 return ENOTCONN; 212 case WSAETIMEDOUT: 213 return ETIMEDOUT; 214 case WSAECONNREFUSED: 215 return ECONNREFUSED; 216 case WSAELOOP: 217 return ELOOP; 218 case WSAEHOSTUNREACH: 219 return EHOSTUNREACH; 220 default: 221 return EIO; 222 } 223 } 224 225 int inet_aton(const char *cp, struct in_addr *ia) 226 { 227 uint32_t addr = inet_addr(cp); 228 if (addr == 0xffffffff) { 229 return 0; 230 } 231 ia->s_addr = addr; 232 return 1; 233 } 234 235 void qemu_set_cloexec(int fd) 236 { 237 } 238 239 /* Offset between 1/1/1601 and 1/1/1970 in 100 nanosec units */ 240 #define _W32_FT_OFFSET (116444736000000000ULL) 241 242 int qemu_gettimeofday(qemu_timeval *tp) 243 { 244 union { 245 unsigned long long ns100; /*time since 1 Jan 1601 in 100ns units */ 246 FILETIME ft; 247 } _now; 248 249 if(tp) { 250 GetSystemTimeAsFileTime (&_now.ft); 251 tp->tv_usec=(long)((_now.ns100 / 10ULL) % 1000000ULL ); 252 tp->tv_sec= (long)((_now.ns100 - _W32_FT_OFFSET) / 10000000ULL); 253 } 254 /* Always return 0 as per Open Group Base Specifications Issue 6. 255 Do not set errno on error. */ 256 return 0; 257 } 258 259 int qemu_get_thread_id(void) 260 { 261 return GetCurrentThreadId(); 262 } 263 264 char * 265 qemu_get_local_state_pathname(const char *relative_pathname) 266 { 267 HRESULT result; 268 char base_path[MAX_PATH+1] = ""; 269 270 result = SHGetFolderPath(NULL, CSIDL_COMMON_APPDATA, NULL, 271 /* SHGFP_TYPE_CURRENT */ 0, base_path); 272 if (result != S_OK) { 273 /* misconfigured environment */ 274 g_critical("CSIDL_COMMON_APPDATA unavailable: %ld", (long)result); 275 abort(); 276 } 277 return g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s", base_path, 278 relative_pathname); 279 } 280 281 void qemu_set_tty_echo(int fd, bool echo) 282 { 283 HANDLE handle = (HANDLE)_get_osfhandle(fd); 284 DWORD dwMode = 0; 285 286 if (handle == INVALID_HANDLE_VALUE) { 287 return; 288 } 289 290 GetConsoleMode(handle, &dwMode); 291 292 if (echo) { 293 SetConsoleMode(handle, dwMode | ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT); 294 } else { 295 SetConsoleMode(handle, 296 dwMode & ~(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT)); 297 } 298 } 299 300 static char exec_dir[PATH_MAX]; 301 302 void qemu_init_exec_dir(const char *argv0) 303 { 304 305 char *p; 306 char buf[MAX_PATH]; 307 DWORD len; 308 309 len = GetModuleFileName(NULL, buf, sizeof(buf) - 1); 310 if (len == 0) { 311 return; 312 } 313 314 buf[len] = 0; 315 p = buf + len - 1; 316 while (p != buf && *p != '\\') { 317 p--; 318 } 319 *p = 0; 320 if (access(buf, R_OK) == 0) { 321 pstrcpy(exec_dir, sizeof(exec_dir), buf); 322 } 323 } 324 325 char *qemu_get_exec_dir(void) 326 { 327 return g_strdup(exec_dir); 328 } 329 330 /* 331 * The original implementation of g_poll from glib has a problem on Windows 332 * when using timeouts < 10 ms. 333 * 334 * Whenever g_poll is called with timeout < 10 ms, it does a quick poll instead 335 * of wait. This causes significant performance degradation of QEMU. 336 * 337 * The following code is a copy of the original code from glib/gpoll.c 338 * (glib commit 20f4d1820b8d4d0fc4447188e33efffd6d4a88d8 from 2014-02-19). 339 * Some debug code was removed and the code was reformatted. 340 * All other code modifications are marked with 'QEMU'. 341 */ 342 343 /* 344 * gpoll.c: poll(2) abstraction 345 * Copyright 1998 Owen Taylor 346 * Copyright 2008 Red Hat, Inc. 347 * 348 * This library is free software; you can redistribute it and/or 349 * modify it under the terms of the GNU Lesser General Public 350 * License as published by the Free Software Foundation; either 351 * version 2 of the License, or (at your option) any later version. 352 * 353 * This library is distributed in the hope that it will be useful, 354 * but WITHOUT ANY WARRANTY; without even the implied warranty of 355 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 356 * Lesser General Public License for more details. 357 * 358 * You should have received a copy of the GNU Lesser General Public 359 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 360 */ 361 362 static int poll_rest(gboolean poll_msgs, HANDLE *handles, gint nhandles, 363 GPollFD *fds, guint nfds, gint timeout) 364 { 365 DWORD ready; 366 GPollFD *f; 367 int recursed_result; 368 369 if (poll_msgs) { 370 /* Wait for either messages or handles 371 * -> Use MsgWaitForMultipleObjectsEx 372 */ 373 ready = MsgWaitForMultipleObjectsEx(nhandles, handles, timeout, 374 QS_ALLINPUT, MWMO_ALERTABLE); 375 376 if (ready == WAIT_FAILED) { 377 gchar *emsg = g_win32_error_message(GetLastError()); 378 g_warning("MsgWaitForMultipleObjectsEx failed: %s", emsg); 379 g_free(emsg); 380 } 381 } else if (nhandles == 0) { 382 /* No handles to wait for, just the timeout */ 383 if (timeout == INFINITE) { 384 ready = WAIT_FAILED; 385 } else { 386 SleepEx(timeout, TRUE); 387 ready = WAIT_TIMEOUT; 388 } 389 } else { 390 /* Wait for just handles 391 * -> Use WaitForMultipleObjectsEx 392 */ 393 ready = 394 WaitForMultipleObjectsEx(nhandles, handles, FALSE, timeout, TRUE); 395 if (ready == WAIT_FAILED) { 396 gchar *emsg = g_win32_error_message(GetLastError()); 397 g_warning("WaitForMultipleObjectsEx failed: %s", emsg); 398 g_free(emsg); 399 } 400 } 401 402 if (ready == WAIT_FAILED) { 403 return -1; 404 } else if (ready == WAIT_TIMEOUT || ready == WAIT_IO_COMPLETION) { 405 return 0; 406 } else if (poll_msgs && ready == WAIT_OBJECT_0 + nhandles) { 407 for (f = fds; f < &fds[nfds]; ++f) { 408 if (f->fd == G_WIN32_MSG_HANDLE && f->events & G_IO_IN) { 409 f->revents |= G_IO_IN; 410 } 411 } 412 413 /* If we have a timeout, or no handles to poll, be satisfied 414 * with just noticing we have messages waiting. 415 */ 416 if (timeout != 0 || nhandles == 0) { 417 return 1; 418 } 419 420 /* If no timeout and handles to poll, recurse to poll them, 421 * too. 422 */ 423 recursed_result = poll_rest(FALSE, handles, nhandles, fds, nfds, 0); 424 return (recursed_result == -1) ? -1 : 1 + recursed_result; 425 } else if (/* QEMU: removed the following unneeded statement which causes 426 * a compiler warning: ready >= WAIT_OBJECT_0 && */ 427 ready < WAIT_OBJECT_0 + nhandles) { 428 for (f = fds; f < &fds[nfds]; ++f) { 429 if ((HANDLE) f->fd == handles[ready - WAIT_OBJECT_0]) { 430 f->revents = f->events; 431 } 432 } 433 434 /* If no timeout and polling several handles, recurse to poll 435 * the rest of them. 436 */ 437 if (timeout == 0 && nhandles > 1) { 438 /* Remove the handle that fired */ 439 int i; 440 if (ready < nhandles - 1) { 441 for (i = ready - WAIT_OBJECT_0 + 1; i < nhandles; i++) { 442 handles[i-1] = handles[i]; 443 } 444 } 445 nhandles--; 446 recursed_result = poll_rest(FALSE, handles, nhandles, fds, nfds, 0); 447 return (recursed_result == -1) ? -1 : 1 + recursed_result; 448 } 449 return 1; 450 } 451 452 return 0; 453 } 454 455 gint g_poll(GPollFD *fds, guint nfds, gint timeout) 456 { 457 HANDLE handles[MAXIMUM_WAIT_OBJECTS]; 458 gboolean poll_msgs = FALSE; 459 GPollFD *f; 460 gint nhandles = 0; 461 int retval; 462 463 for (f = fds; f < &fds[nfds]; ++f) { 464 if (f->fd == G_WIN32_MSG_HANDLE && (f->events & G_IO_IN)) { 465 poll_msgs = TRUE; 466 } else if (f->fd > 0) { 467 /* Don't add the same handle several times into the array, as 468 * docs say that is not allowed, even if it actually does seem 469 * to work. 470 */ 471 gint i; 472 473 for (i = 0; i < nhandles; i++) { 474 if (handles[i] == (HANDLE) f->fd) { 475 break; 476 } 477 } 478 479 if (i == nhandles) { 480 if (nhandles == MAXIMUM_WAIT_OBJECTS) { 481 g_warning("Too many handles to wait for!\n"); 482 break; 483 } else { 484 handles[nhandles++] = (HANDLE) f->fd; 485 } 486 } 487 } 488 } 489 490 for (f = fds; f < &fds[nfds]; ++f) { 491 f->revents = 0; 492 } 493 494 if (timeout == -1) { 495 timeout = INFINITE; 496 } 497 498 /* Polling for several things? */ 499 if (nhandles > 1 || (nhandles > 0 && poll_msgs)) { 500 /* First check if one or several of them are immediately 501 * available 502 */ 503 retval = poll_rest(poll_msgs, handles, nhandles, fds, nfds, 0); 504 505 /* If not, and we have a significant timeout, poll again with 506 * timeout then. Note that this will return indication for only 507 * one event, or only for messages. We ignore timeouts less than 508 * ten milliseconds as they are mostly pointless on Windows, the 509 * MsgWaitForMultipleObjectsEx() call will timeout right away 510 * anyway. 511 * 512 * Modification for QEMU: replaced timeout >= 10 by timeout > 0. 513 */ 514 if (retval == 0 && (timeout == INFINITE || timeout > 0)) { 515 retval = poll_rest(poll_msgs, handles, nhandles, 516 fds, nfds, timeout); 517 } 518 } else { 519 /* Just polling for one thing, so no need to check first if 520 * available immediately 521 */ 522 retval = poll_rest(poll_msgs, handles, nhandles, fds, nfds, timeout); 523 } 524 525 if (retval == -1) { 526 for (f = fds; f < &fds[nfds]; ++f) { 527 f->revents = 0; 528 } 529 } 530 531 return retval; 532 } 533 534 int getpagesize(void) 535 { 536 SYSTEM_INFO system_info; 537 538 GetSystemInfo(&system_info); 539 return system_info.dwPageSize; 540 } 541 542 void os_mem_prealloc(int fd, char *area, size_t memory, Error **errp) 543 { 544 int i; 545 size_t pagesize = getpagesize(); 546 547 memory = (memory + pagesize - 1) & -pagesize; 548 for (i = 0; i < memory / pagesize; i++) { 549 memset(area + pagesize * i, 0, 1); 550 } 551 } 552 553 554 /* XXX: put correct support for win32 */ 555 int qemu_read_password(char *buf, int buf_size) 556 { 557 int c, i; 558 559 printf("Password: "); 560 fflush(stdout); 561 i = 0; 562 for (;;) { 563 c = getchar(); 564 if (c < 0) { 565 buf[i] = '\0'; 566 return -1; 567 } else if (c == '\n') { 568 break; 569 } else if (i < (buf_size - 1)) { 570 buf[i++] = c; 571 } 572 } 573 buf[i] = '\0'; 574 return 0; 575 } 576 577 578 pid_t qemu_fork(Error **errp) 579 { 580 errno = ENOSYS; 581 error_setg_errno(errp, errno, 582 "cannot fork child process"); 583 return -1; 584 } 585 586 587 #undef connect 588 int qemu_connect_wrap(int sockfd, const struct sockaddr *addr, 589 socklen_t addrlen) 590 { 591 int ret; 592 ret = connect(sockfd, addr, addrlen); 593 if (ret < 0) { 594 errno = socket_error(); 595 } 596 return ret; 597 } 598 599 600 #undef listen 601 int qemu_listen_wrap(int sockfd, int backlog) 602 { 603 int ret; 604 ret = listen(sockfd, backlog); 605 if (ret < 0) { 606 errno = socket_error(); 607 } 608 return ret; 609 } 610 611 612 #undef bind 613 int qemu_bind_wrap(int sockfd, const struct sockaddr *addr, 614 socklen_t addrlen) 615 { 616 int ret; 617 ret = bind(sockfd, addr, addrlen); 618 if (ret < 0) { 619 errno = socket_error(); 620 } 621 return ret; 622 } 623 624 625 #undef socket 626 int qemu_socket_wrap(int domain, int type, int protocol) 627 { 628 int ret; 629 ret = socket(domain, type, protocol); 630 if (ret < 0) { 631 errno = socket_error(); 632 } 633 return ret; 634 } 635 636 637 #undef accept 638 int qemu_accept_wrap(int sockfd, struct sockaddr *addr, 639 socklen_t *addrlen) 640 { 641 int ret; 642 ret = accept(sockfd, addr, addrlen); 643 if (ret < 0) { 644 errno = socket_error(); 645 } 646 return ret; 647 } 648 649 650 #undef shutdown 651 int qemu_shutdown_wrap(int sockfd, int how) 652 { 653 int ret; 654 ret = shutdown(sockfd, how); 655 if (ret < 0) { 656 errno = socket_error(); 657 } 658 return ret; 659 } 660 661 662 #undef ioctlsocket 663 int qemu_ioctlsocket_wrap(int fd, int req, void *val) 664 { 665 int ret; 666 ret = ioctlsocket(fd, req, val); 667 if (ret < 0) { 668 errno = socket_error(); 669 } 670 return ret; 671 } 672 673 674 #undef closesocket 675 int qemu_closesocket_wrap(int fd) 676 { 677 int ret; 678 ret = closesocket(fd); 679 if (ret < 0) { 680 errno = socket_error(); 681 } 682 return ret; 683 } 684 685 686 #undef getsockopt 687 int qemu_getsockopt_wrap(int sockfd, int level, int optname, 688 void *optval, socklen_t *optlen) 689 { 690 int ret; 691 ret = getsockopt(sockfd, level, optname, optval, optlen); 692 if (ret < 0) { 693 errno = socket_error(); 694 } 695 return ret; 696 } 697 698 699 #undef setsockopt 700 int qemu_setsockopt_wrap(int sockfd, int level, int optname, 701 const void *optval, socklen_t optlen) 702 { 703 int ret; 704 ret = setsockopt(sockfd, level, optname, optval, optlen); 705 if (ret < 0) { 706 errno = socket_error(); 707 } 708 return ret; 709 } 710 711 712 #undef getpeername 713 int qemu_getpeername_wrap(int sockfd, struct sockaddr *addr, 714 socklen_t *addrlen) 715 { 716 int ret; 717 ret = getpeername(sockfd, addr, addrlen); 718 if (ret < 0) { 719 errno = socket_error(); 720 } 721 return ret; 722 } 723 724 725 #undef getsockname 726 int qemu_getsockname_wrap(int sockfd, struct sockaddr *addr, 727 socklen_t *addrlen) 728 { 729 int ret; 730 ret = getsockname(sockfd, addr, addrlen); 731 if (ret < 0) { 732 errno = socket_error(); 733 } 734 return ret; 735 } 736 737 738 #undef send 739 ssize_t qemu_send_wrap(int sockfd, const void *buf, size_t len, int flags) 740 { 741 int ret; 742 ret = send(sockfd, buf, len, flags); 743 if (ret < 0) { 744 errno = socket_error(); 745 } 746 return ret; 747 } 748 749 750 #undef sendto 751 ssize_t qemu_sendto_wrap(int sockfd, const void *buf, size_t len, int flags, 752 const struct sockaddr *addr, socklen_t addrlen) 753 { 754 int ret; 755 ret = sendto(sockfd, buf, len, flags, addr, addrlen); 756 if (ret < 0) { 757 errno = socket_error(); 758 } 759 return ret; 760 } 761 762 763 #undef recv 764 ssize_t qemu_recv_wrap(int sockfd, void *buf, size_t len, int flags) 765 { 766 int ret; 767 ret = recv(sockfd, buf, len, flags); 768 if (ret < 0) { 769 errno = socket_error(); 770 } 771 return ret; 772 } 773 774 775 #undef recvfrom 776 ssize_t qemu_recvfrom_wrap(int sockfd, void *buf, size_t len, int flags, 777 struct sockaddr *addr, socklen_t *addrlen) 778 { 779 int ret; 780 ret = recvfrom(sockfd, buf, len, flags, addr, addrlen); 781 if (ret < 0) { 782 errno = socket_error(); 783 } 784 return ret; 785 } 786