1 2 /*--------------------------------------------------------------------*/ 3 /*--- File- and socket-related libc stuff. m_libcfile.c ---*/ 4 /*--------------------------------------------------------------------*/ 5 6 /* 7 This file is part of Valgrind, a dynamic binary instrumentation 8 framework. 9 10 Copyright (C) 2000-2012 Julian Seward 11 jseward (at) acm.org 12 13 This program is free software; you can redistribute it and/or 14 modify it under the terms of the GNU General Public License as 15 published by the Free Software Foundation; either version 2 of the 16 License, or (at your option) any later version. 17 18 This program is distributed in the hope that it will be useful, but 19 WITHOUT ANY WARRANTY; without even the implied warranty of 20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 21 General Public License for more details. 22 23 You should have received a copy of the GNU General Public License 24 along with this program; if not, write to the Free Software 25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 26 02111-1307, USA. 27 28 The GNU General Public License is contained in the file COPYING. 29 */ 30 31 #include "pub_core_basics.h" 32 #include "pub_core_vki.h" 33 #include "pub_core_vkiscnums.h" 34 #include "pub_core_debuglog.h" 35 #include "pub_core_libcbase.h" 36 #include "pub_core_libcassert.h" 37 #include "pub_core_libcfile.h" 38 #include "pub_core_libcprint.h" // VG_(sprintf) 39 #include "pub_core_libcproc.h" // VG_(getpid), VG_(getppid) 40 #include "pub_core_xarray.h" 41 #include "pub_core_clientstate.h" // VG_(fd_hard_limit) 42 #include "pub_core_syscall.h" 43 44 /* IMPORTANT: on Darwin it is essential to use the _nocancel versions 45 of syscalls rather than the vanilla version, if a _nocancel version 46 is available. See docs/internals/Darwin-notes.txt for the reason 47 why. */ 48 49 /* --------------------------------------------------------------------- 50 File stuff 51 ------------------------------------------------------------------ */ 52 53 static inline Bool fd_exists(Int fd) 54 { 55 struct vg_stat st; 56 return VG_(fstat)(fd, &st) == 0; 57 } 58 59 /* Move an fd into the Valgrind-safe range */ 60 Int VG_(safe_fd)(Int oldfd) 61 { 62 Int newfd; 63 64 vg_assert(VG_(fd_hard_limit) != -1); 65 66 newfd = VG_(fcntl)(oldfd, VKI_F_DUPFD, VG_(fd_hard_limit)); 67 if (newfd != -1) 68 VG_(close)(oldfd); 69 70 /* Set the close-on-exec flag for this fd. */ 71 VG_(fcntl)(newfd, VKI_F_SETFD, VKI_FD_CLOEXEC); 72 73 vg_assert(newfd >= VG_(fd_hard_limit)); 74 return newfd; 75 } 76 77 /* Given a file descriptor, attempt to deduce its filename. To do 78 this, we use /proc/self/fd/<FD>. If this doesn't point to a file, 79 or if it doesn't exist, we return False. */ 80 Bool VG_(resolve_filename) ( Int fd, HChar* buf, Int n_buf ) 81 { 82 # if defined(VGO_linux) 83 HChar tmp[64]; 84 VG_(sprintf)(tmp, "/proc/self/fd/%d", fd); 85 VG_(memset)(buf, 0, n_buf); 86 if (VG_(readlink)(tmp, buf, n_buf) > 0 && buf[0] == '/') 87 return True; 88 else 89 return False; 90 91 # elif defined(VGO_darwin) 92 HChar tmp[VKI_MAXPATHLEN+1]; 93 if (0 == VG_(fcntl)(fd, VKI_F_GETPATH, (UWord)tmp)) { 94 if (n_buf > 0) { 95 VG_(strncpy)( buf, tmp, n_buf < sizeof(tmp) ? n_buf : sizeof(tmp) ); 96 buf[n_buf-1] = 0; 97 } 98 if (tmp[0] == '/') return True; 99 } 100 return False; 101 102 # else 103 # error Unknown OS 104 # endif 105 } 106 107 SysRes VG_(mknod) ( const Char* pathname, Int mode, UWord dev ) 108 { 109 # if defined(VGO_linux) || defined(VGO_darwin) 110 SysRes res = VG_(do_syscall3)(__NR_mknod, 111 (UWord)pathname, mode, dev); 112 # else 113 # error Unknown OS 114 # endif 115 return res; 116 } 117 118 SysRes VG_(open) ( const Char* pathname, Int flags, Int mode ) 119 { 120 # if defined(VGO_linux) 121 SysRes res = VG_(do_syscall3)(__NR_open, 122 (UWord)pathname, flags, mode); 123 # elif defined(VGO_darwin) 124 SysRes res = VG_(do_syscall3)(__NR_open_nocancel, 125 (UWord)pathname, flags, mode); 126 # else 127 # error Unknown OS 128 # endif 129 return res; 130 } 131 132 Int VG_(fd_open) (const Char* pathname, Int flags, Int mode) 133 { 134 SysRes sr; 135 sr = VG_(open) (pathname, flags, mode); 136 if (sr_isError (sr)) 137 return -1; 138 else 139 return sr_Res (sr); 140 } 141 142 void VG_(close) ( Int fd ) 143 { 144 /* Hmm. Return value is not checked. That's uncool. */ 145 # if defined(VGO_linux) 146 (void)VG_(do_syscall1)(__NR_close, fd); 147 # elif defined(VGO_darwin) 148 (void)VG_(do_syscall1)(__NR_close_nocancel, fd); 149 # else 150 # error Unknown OS 151 # endif 152 } 153 154 Int VG_(read) ( Int fd, void* buf, Int count) 155 { 156 Int ret; 157 # if defined(VGO_linux) 158 SysRes res = VG_(do_syscall3)(__NR_read, fd, (UWord)buf, count); 159 # elif defined(VGO_darwin) 160 SysRes res = VG_(do_syscall3)(__NR_read_nocancel, fd, (UWord)buf, count); 161 # else 162 # error Unknown OS 163 # endif 164 if (sr_isError(res)) { 165 ret = - (Int)(Word)sr_Err(res); 166 vg_assert(ret < 0); 167 } else { 168 ret = (Int)(Word)sr_Res(res); 169 vg_assert(ret >= 0); 170 } 171 return ret; 172 } 173 174 Int VG_(write) ( Int fd, const void* buf, Int count) 175 { 176 Int ret; 177 # if defined(VGO_linux) 178 SysRes res = VG_(do_syscall3)(__NR_write, fd, (UWord)buf, count); 179 # elif defined(VGO_darwin) 180 SysRes res = VG_(do_syscall3)(__NR_write_nocancel, fd, (UWord)buf, count); 181 # else 182 # error "Unknown OS" 183 # endif 184 if (sr_isError(res)) { 185 ret = - (Int)(Word)sr_Err(res); 186 vg_assert(ret < 0); 187 } else { 188 ret = (Int)(Word)sr_Res(res); 189 vg_assert(ret >= 0); 190 } 191 return ret; 192 } 193 194 195 Int VG_(pipe) ( Int fd[2] ) 196 { 197 # if defined(VGP_mips32_linux) 198 /* __NR_pipe has a strange return convention on mips32-linux. */ 199 SysRes res = VG_(do_syscall0)(__NR_pipe); 200 if (!sr_isError(res)) { 201 fd[0] = (Int)sr_Res(res); 202 fd[1] = (Int)sr_ResEx(res); 203 return 0; 204 } else { 205 return -1; 206 } 207 # elif defined(VGO_linux) 208 SysRes res = VG_(do_syscall1)(__NR_pipe, (UWord)fd); 209 return sr_isError(res) ? -1 : 0; 210 # elif defined(VGO_darwin) 211 /* __NR_pipe is UX64, so produces a double-word result */ 212 SysRes res = VG_(do_syscall0)(__NR_pipe); 213 if (!sr_isError(res)) { 214 fd[0] = (Int)sr_Res(res); 215 fd[1] = (Int)sr_ResHI(res); 216 } 217 return sr_isError(res) ? -1 : 0; 218 # else 219 # error "Unknown OS" 220 # endif 221 } 222 223 Off64T VG_(lseek) ( Int fd, Off64T offset, Int whence ) 224 { 225 # if defined(VGO_linux) || defined(VGP_amd64_darwin) 226 # if defined(__NR__llseek) 227 Off64T result; 228 SysRes res = VG_(do_syscall5)(__NR__llseek, fd, 229 offset >> 32, offset & 0xffffffff, 230 (UWord)&result, whence); 231 return sr_isError(res) ? (-1) : result; 232 # else 233 SysRes res = VG_(do_syscall3)(__NR_lseek, fd, offset, whence); 234 vg_assert(sizeof(Off64T) == sizeof(Word)); 235 return sr_isError(res) ? (-1) : sr_Res(res); 236 # endif 237 # elif defined(VGP_x86_darwin) 238 SysRes res = VG_(do_syscall4)(__NR_lseek, fd, 239 offset & 0xffffffff, offset >> 32, whence); 240 return sr_isError(res) ? (-1) : sr_Res(res); 241 # else 242 # error "Unknown plat" 243 # endif 244 /* if you change the error-reporting conventions of this, also 245 change all usage points. */ 246 } 247 248 249 /* stat/fstat support. It's uggerly. We have impedance-match into a 250 'struct vg_stat' in order to have a single structure that callers 251 can use consistently on all platforms. */ 252 253 #define TRANSLATE_TO_vg_stat(_p_vgstat, _p_vkistat) \ 254 do { \ 255 (_p_vgstat)->dev = (ULong)( (_p_vkistat)->st_dev ); \ 256 (_p_vgstat)->ino = (ULong)( (_p_vkistat)->st_ino ); \ 257 (_p_vgstat)->nlink = (ULong)( (_p_vkistat)->st_nlink ); \ 258 (_p_vgstat)->mode = (UInt) ( (_p_vkistat)->st_mode ); \ 259 (_p_vgstat)->uid = (UInt) ( (_p_vkistat)->st_uid ); \ 260 (_p_vgstat)->gid = (UInt) ( (_p_vkistat)->st_gid ); \ 261 (_p_vgstat)->rdev = (ULong)( (_p_vkistat)->st_rdev ); \ 262 (_p_vgstat)->size = (Long) ( (_p_vkistat)->st_size ); \ 263 (_p_vgstat)->blksize = (ULong)( (_p_vkistat)->st_blksize ); \ 264 (_p_vgstat)->blocks = (ULong)( (_p_vkistat)->st_blocks ); \ 265 (_p_vgstat)->atime = (ULong)( (_p_vkistat)->st_atime ); \ 266 (_p_vgstat)->atime_nsec = (ULong)( (_p_vkistat)->st_atime_nsec ); \ 267 (_p_vgstat)->mtime = (ULong)( (_p_vkistat)->st_mtime ); \ 268 (_p_vgstat)->mtime_nsec = (ULong)( (_p_vkistat)->st_mtime_nsec ); \ 269 (_p_vgstat)->ctime = (ULong)( (_p_vkistat)->st_ctime ); \ 270 (_p_vgstat)->ctime_nsec = (ULong)( (_p_vkistat)->st_ctime_nsec ); \ 271 } while (0) 272 273 SysRes VG_(stat) ( const Char* file_name, struct vg_stat* vgbuf ) 274 { 275 SysRes res; 276 VG_(memset)(vgbuf, 0, sizeof(*vgbuf)); 277 278 # if defined(VGO_linux) || defined(VGO_darwin) 279 /* First try with stat64. If that doesn't work out, fall back to 280 the vanilla version. */ 281 # if defined(__NR_stat64) 282 { struct vki_stat64 buf64; 283 res = VG_(do_syscall2)(__NR_stat64, (UWord)file_name, (UWord)&buf64); 284 if (!(sr_isError(res) && sr_Err(res) == VKI_ENOSYS)) { 285 /* Success, or any failure except ENOSYS */ 286 if (!sr_isError(res)) 287 TRANSLATE_TO_vg_stat(vgbuf, &buf64); 288 return res; 289 } 290 } 291 # endif /* defined(__NR_stat64) */ 292 { struct vki_stat buf; 293 res = VG_(do_syscall2)(__NR_stat, (UWord)file_name, (UWord)&buf); 294 if (!sr_isError(res)) 295 TRANSLATE_TO_vg_stat(vgbuf, &buf); 296 return res; 297 } 298 299 # else 300 # error Unknown OS 301 # endif 302 } 303 304 Int VG_(fstat) ( Int fd, struct vg_stat* vgbuf ) 305 { 306 SysRes res; 307 VG_(memset)(vgbuf, 0, sizeof(*vgbuf)); 308 309 # if defined(VGO_linux) || defined(VGO_darwin) 310 /* First try with fstat64. If that doesn't work out, fall back to 311 the vanilla version. */ 312 # if defined(__NR_fstat64) 313 { struct vki_stat64 buf64; 314 res = VG_(do_syscall2)(__NR_fstat64, (UWord)fd, (UWord)&buf64); 315 if (!(sr_isError(res) && sr_Err(res) == VKI_ENOSYS)) { 316 /* Success, or any failure except ENOSYS */ 317 if (!sr_isError(res)) 318 TRANSLATE_TO_vg_stat(vgbuf, &buf64); 319 return sr_isError(res) ? (-1) : 0; 320 } 321 } 322 # endif /* if defined(__NR_fstat64) */ 323 { struct vki_stat buf; 324 res = VG_(do_syscall2)(__NR_fstat, (UWord)fd, (UWord)&buf); 325 if (!sr_isError(res)) 326 TRANSLATE_TO_vg_stat(vgbuf, &buf); 327 return sr_isError(res) ? (-1) : 0; 328 } 329 330 # else 331 # error Unknown OS 332 # endif 333 } 334 335 #undef TRANSLATE_TO_vg_stat 336 337 338 Long VG_(fsize) ( Int fd ) 339 { 340 struct vg_stat buf; 341 Int res = VG_(fstat)( fd, &buf ); 342 return (res == -1) ? (-1LL) : buf.size; 343 } 344 345 Bool VG_(is_dir) ( const HChar* f ) 346 { 347 struct vg_stat buf; 348 SysRes res = VG_(stat)(f, &buf); 349 return sr_isError(res) ? False 350 : VKI_S_ISDIR(buf.mode) ? True : False; 351 } 352 353 SysRes VG_(dup) ( Int oldfd ) 354 { 355 return VG_(do_syscall1)(__NR_dup, oldfd); 356 } 357 358 SysRes VG_(dup2) ( Int oldfd, Int newfd ) 359 { 360 # if defined(VGO_linux) || defined(VGO_darwin) 361 return VG_(do_syscall2)(__NR_dup2, oldfd, newfd); 362 # else 363 # error Unknown OS 364 # endif 365 } 366 367 /* Returns -1 on error. */ 368 Int VG_(fcntl) ( Int fd, Int cmd, Addr arg ) 369 { 370 # if defined(VGO_linux) 371 SysRes res = VG_(do_syscall3)(__NR_fcntl, fd, cmd, arg); 372 # elif defined(VGO_darwin) 373 SysRes res = VG_(do_syscall3)(__NR_fcntl_nocancel, fd, cmd, arg); 374 # else 375 # error "Unknown OS" 376 # endif 377 return sr_isError(res) ? -1 : sr_Res(res); 378 } 379 380 Int VG_(rename) ( const Char* old_name, const Char* new_name ) 381 { 382 SysRes res = VG_(do_syscall2)(__NR_rename, (UWord)old_name, (UWord)new_name); 383 return sr_isError(res) ? (-1) : 0; 384 } 385 386 Int VG_(unlink) ( const Char* file_name ) 387 { 388 SysRes res = VG_(do_syscall1)(__NR_unlink, (UWord)file_name); 389 return sr_isError(res) ? (-1) : 0; 390 } 391 392 /* The working directory at startup. AIX doesn't provide an easy 393 system call to do getcwd, but fortunately we don't need arbitrary 394 getcwd support. All that is really needed is to note the cwd at 395 process startup. Hence VG_(record_startup_wd) notes it (in a 396 platform dependent way) and VG_(get_startup_wd) produces the noted 397 value. Hence: */ 398 static HChar startup_wd[VKI_PATH_MAX]; 399 static Bool startup_wd_acquired = False; 400 401 /* Record the process' working directory at startup. Is intended to 402 be called exactly once, at startup, before the working directory 403 changes. Return True for success, False for failure, so that the 404 caller can bomb out suitably without creating module cycles if 405 there is a problem. */ 406 Bool VG_(record_startup_wd) ( void ) 407 { 408 const Int szB = sizeof(startup_wd); 409 vg_assert(!startup_wd_acquired); 410 vg_assert(szB >= 512 && szB <= 16384/*let's say*/); /* stay sane */ 411 VG_(memset)(startup_wd, 0, szB); 412 # if defined(VGO_linux) 413 /* Simple: just ask the kernel */ 414 { SysRes res 415 = VG_(do_syscall2)(__NR_getcwd, (UWord)startup_wd, szB-1); 416 vg_assert(startup_wd[szB-1] == 0); 417 if (sr_isError(res)) { 418 return False; 419 } else { 420 startup_wd_acquired = True; 421 return True; 422 } 423 } 424 # elif defined(VGO_darwin) 425 /* We can't ask the kernel, so instead rely on launcher-*.c to 426 tell us the startup path. Note the env var is keyed to the 427 parent's PID, not ours, since our parent is the launcher 428 process. */ 429 { Char envvar[100]; 430 Char* wd = NULL; 431 VG_(memset)(envvar, 0, sizeof(envvar)); 432 VG_(sprintf)(envvar, "VALGRIND_STARTUP_PWD_%d_XYZZY", 433 (Int)VG_(getppid)()); 434 wd = VG_(getenv)( envvar ); 435 if (wd == NULL || (1+VG_(strlen)(wd) >= szB)) 436 return False; 437 VG_(strncpy_safely)(startup_wd, wd, szB); 438 vg_assert(startup_wd[szB-1] == 0); 439 startup_wd_acquired = True; 440 return True; 441 } 442 # else 443 # error Unknown OS 444 # endif 445 } 446 447 /* Copy the previously acquired startup_wd into buf[0 .. size-1], 448 or return False if buf isn't big enough. */ 449 Bool VG_(get_startup_wd) ( Char* buf, SizeT size ) 450 { 451 vg_assert(startup_wd_acquired); 452 vg_assert(startup_wd[ sizeof(startup_wd)-1 ] == 0); 453 if (1+VG_(strlen)(startup_wd) >= size) 454 return False; 455 VG_(strncpy_safely)(buf, startup_wd, size); 456 return True; 457 } 458 459 Int VG_(poll) (struct vki_pollfd *fds, Int nfds, Int timeout) 460 { 461 SysRes res; 462 # if defined(VGO_linux) 463 res = VG_(do_syscall3)(__NR_poll, (UWord)fds, nfds, timeout); 464 # elif defined(VGO_darwin) 465 res = VG_(do_syscall3)(__NR_poll_nocancel, (UWord)fds, nfds, timeout); 466 # else 467 # error "Unknown OS" 468 # endif 469 return sr_isError(res) ? -1 : sr_Res(res); 470 } 471 472 473 Int VG_(readlink) (const Char* path, Char* buf, UInt bufsiz) 474 { 475 SysRes res; 476 /* res = readlink( path, buf, bufsiz ); */ 477 res = VG_(do_syscall3)(__NR_readlink, (UWord)path, (UWord)buf, bufsiz); 478 return sr_isError(res) ? -1 : sr_Res(res); 479 } 480 481 Int VG_(getdents) (Int fd, struct vki_dirent *dirp, UInt count) 482 { 483 # if defined(VGO_linux) 484 SysRes res; 485 /* res = getdents( fd, dirp, count ); */ 486 res = VG_(do_syscall3)(__NR_getdents, fd, (UWord)dirp, count); 487 return sr_isError(res) ? -1 : sr_Res(res); 488 # elif defined(VGO_darwin) 489 I_die_here; 490 # else 491 # error "Unknown OS" 492 # endif 493 } 494 495 /* Check accessibility of a file. Returns zero for access granted, 496 nonzero otherwise. */ 497 Int VG_(access) ( const HChar* path, Bool irusr, Bool iwusr, Bool ixusr ) 498 { 499 # if defined(VGO_linux) 500 /* Very annoyingly, I cannot find any definition for R_OK et al in 501 the kernel interfaces. Therefore I reluctantly resort to 502 hardwiring in these magic numbers that I determined by 503 experimentation. */ 504 # define VKI_R_OK 4 505 # define VKI_W_OK 2 506 # define VKI_X_OK 1 507 # endif 508 509 UWord w = (irusr ? VKI_R_OK : 0) 510 | (iwusr ? VKI_W_OK : 0) 511 | (ixusr ? VKI_X_OK : 0); 512 SysRes res = VG_(do_syscall2)(__NR_access, (UWord)path, w); 513 return sr_isError(res) ? 1 : 0; 514 515 # if defined(VGO_linux) 516 # undef VKI_R_OK 517 # undef VKI_W_OK 518 # undef VKI_X_OK 519 # endif 520 } 521 522 /* 523 Emulate the normal Unix permissions checking algorithm. 524 525 If owner matches, then use the owner permissions, else 526 if group matches, then use the group permissions, else 527 use other permissions. 528 529 Note that we can't deal properly with SUID/SGID. By default 530 (allow_setuid == False), we refuse to run them (otherwise the 531 executable may misbehave if it doesn't have the permissions it 532 thinks it does). However, the caller may indicate that setuid 533 executables are allowed, for example if we are going to exec them 534 but not trace into them (iow, client sys_execve when 535 clo_trace_children == False). 536 537 If VKI_EACCES is returned (iow, permission was refused), then 538 *is_setuid is set to True iff permission was refused because the 539 executable is setuid. 540 */ 541 /* returns: 0 = success, non-0 is failure */ 542 Int VG_(check_executable)(/*OUT*/Bool* is_setuid, 543 const HChar* f, Bool allow_setuid) 544 { 545 struct vg_stat st; 546 SysRes res = VG_(stat)(f, &st); 547 548 if (is_setuid) 549 *is_setuid = False; 550 551 if (sr_isError(res)) { 552 return sr_Err(res); 553 } 554 555 if ( (st.mode & (VKI_S_ISUID | VKI_S_ISGID)) && !allow_setuid ) { 556 if (is_setuid) 557 *is_setuid = True; 558 return VKI_EACCES; 559 } 560 561 if (VG_(geteuid)() == st.uid) { 562 if (!(st.mode & VKI_S_IXUSR)) 563 return VKI_EACCES; 564 } else { 565 Int grpmatch = 0; 566 567 if (VG_(getegid)() == st.gid) 568 grpmatch = 1; 569 else { 570 UInt groups[32]; 571 Int ngrp = VG_(getgroups)(32, groups); 572 Int i; 573 /* ngrp will be -1 if VG_(getgroups) failed. */ 574 for (i = 0; i < ngrp; i++) { 575 if (groups[i] == st.gid) { 576 grpmatch = 1; 577 break; 578 } 579 } 580 } 581 582 if (grpmatch) { 583 if (!(st.mode & VKI_S_IXGRP)) { 584 return VKI_EACCES; 585 } 586 } else if (!(st.mode & VKI_S_IXOTH)) { 587 return VKI_EACCES; 588 } 589 } 590 591 return 0; 592 } 593 594 SysRes VG_(pread) ( Int fd, void* buf, Int count, OffT offset ) 595 { 596 SysRes res; 597 // on 32 bits platforms, we receive a 32 bits OffT but 598 // we must extend it to pass a long long 64 bits. 599 # if defined(VGP_x86_linux) 600 vg_assert(sizeof(OffT) == 4); 601 res = VG_(do_syscall5)(__NR_pread64, fd, (UWord)buf, count, 602 offset, 0); // Little endian long long 603 return res; 604 # elif defined(VGP_arm_linux) 605 vg_assert(sizeof(OffT) == 4); 606 res = VG_(do_syscall5)(__NR_pread64, fd, (UWord)buf, count, 607 0, offset); // Big endian long long 608 return res; 609 # elif defined(VGP_ppc32_linux) 610 vg_assert(sizeof(OffT) == 4); 611 res = VG_(do_syscall6)(__NR_pread64, fd, (UWord)buf, count, 612 0, // Padding needed on PPC32 613 0, offset); // Big endian long long 614 return res; 615 # elif defined(VGP_mips32_linux) && VKI_LITTLE_ENDIAN 616 vg_assert(sizeof(OffT) == 4); 617 res = VG_(do_syscall6)(__NR_pread64, fd, (UWord)buf, count, 618 0, offset, 0); 619 return res; 620 # elif defined(VGP_mips32_linux) && VKI_BIG_ENDIAN 621 vg_assert(sizeof(OffT) == 4); 622 res = VG_(do_syscall6)(__NR_pread64, fd, (UWord)buf, count, 623 0, 0, offset); 624 return res; 625 # elif defined(VGP_amd64_linux) \ 626 || defined(VGP_ppc64_linux) || defined(VGP_s390x_linux) 627 res = VG_(do_syscall4)(__NR_pread64, fd, (UWord)buf, count, offset); 628 return res; 629 # elif defined(VGP_amd64_darwin) 630 vg_assert(sizeof(OffT) == 8); 631 res = VG_(do_syscall4)(__NR_pread_nocancel, fd, (UWord)buf, count, offset); 632 return res; 633 # elif defined(VGP_x86_darwin) 634 vg_assert(sizeof(OffT) == 8); 635 res = VG_(do_syscall5)(__NR_pread_nocancel, fd, (UWord)buf, count, 636 offset & 0xffffffff, offset >> 32); 637 return res; 638 # else 639 # error "Unknown platform" 640 # endif 641 } 642 643 /* Return the name of a directory for temporary files. */ 644 const HChar *VG_(tmpdir)(void) 645 { 646 const HChar *tmpdir; 647 648 tmpdir = VG_(getenv)("TMPDIR"); 649 if (tmpdir == NULL || *tmpdir == '\0') tmpdir = VG_TMPDIR; 650 if (tmpdir == NULL || *tmpdir == '\0') tmpdir = "/tmp"; /* fallback */ 651 652 return tmpdir; 653 } 654 655 /* Create and open (-rw------) a tmp file name incorporating said arg. 656 Returns -1 on failure, else the fd of the file. If fullname is 657 non-NULL, the file's name is written into it. The number of bytes 658 written is guaranteed not to exceed 64+strlen(part_of_name). */ 659 660 Int VG_(mkstemp) ( HChar* part_of_name, /*OUT*/HChar* fullname ) 661 { 662 HChar buf[200]; 663 Int n, tries, fd; 664 UInt seed; 665 SysRes sres; 666 const HChar *tmpdir; 667 668 vg_assert(part_of_name); 669 n = VG_(strlen)(part_of_name); 670 vg_assert(n > 0 && n < 100); 671 672 seed = (VG_(getpid)() << 9) ^ VG_(getppid)(); 673 674 /* Determine sensible location for temporary files */ 675 tmpdir = VG_(tmpdir)(); 676 677 tries = 0; 678 while (True) { 679 if (tries++ > 10) 680 return -1; 681 VG_(sprintf)( buf, "%s/valgrind_%s_%08x", 682 tmpdir, part_of_name, VG_(random)( &seed )); 683 if (0) 684 VG_(printf)("VG_(mkstemp): trying: %s\n", buf); 685 686 sres = VG_(open)(buf, 687 VKI_O_CREAT|VKI_O_RDWR|VKI_O_EXCL|VKI_O_TRUNC, 688 VKI_S_IRUSR|VKI_S_IWUSR); 689 if (sr_isError(sres)) { 690 VG_(umsg)("VG_(mkstemp): failed to create temp file: %s\n", buf); 691 continue; 692 } 693 /* VG_(safe_fd) doesn't return if it fails. */ 694 fd = VG_(safe_fd)( sr_Res(sres) ); 695 if (fullname) 696 VG_(strcpy)( fullname, buf ); 697 return fd; 698 } 699 /* NOTREACHED */ 700 } 701 702 703 /* --------------------------------------------------------------------- 704 Socket-related stuff. 705 ------------------------------------------------------------------ */ 706 707 static 708 Int parse_inet_addr_and_port ( UChar* str, UInt* ip_addr, UShort* port ); 709 710 static 711 Int my_connect ( Int sockfd, struct vki_sockaddr_in* serv_addr, Int addrlen ); 712 713 UInt VG_(htonl) ( UInt x ) 714 { 715 # if defined(VG_BIGENDIAN) 716 return x; 717 # else 718 return 719 (((x >> 24) & 0xFF) << 0) | (((x >> 16) & 0xFF) << 8) 720 | (((x >> 8) & 0xFF) << 16) | (((x >> 0) & 0xFF) << 24); 721 # endif 722 } 723 724 UInt VG_(ntohl) ( UInt x ) 725 { 726 # if defined(VG_BIGENDIAN) 727 return x; 728 # else 729 return 730 (((x >> 24) & 0xFF) << 0) | (((x >> 16) & 0xFF) << 8) 731 | (((x >> 8) & 0xFF) << 16) | (((x >> 0) & 0xFF) << 24); 732 # endif 733 } 734 735 UShort VG_(htons) ( UShort x ) 736 { 737 # if defined(VG_BIGENDIAN) 738 return x; 739 # else 740 return 741 (((x >> 8) & 0xFF) << 0) | (((x >> 0) & 0xFF) << 8); 742 # endif 743 } 744 745 UShort VG_(ntohs) ( UShort x ) 746 { 747 # if defined(VG_BIGENDIAN) 748 return x; 749 # else 750 return 751 (((x >> 8) & 0xFF) << 0) | (((x >> 0) & 0xFF) << 8); 752 # endif 753 } 754 755 756 /* The main function. 757 758 Supplied string contains either an ip address "192.168.0.1" or 759 an ip address and port pair, "192.168.0.1:1500". Parse these, 760 and return: 761 -1 if there is a parse error 762 -2 if no parse error, but specified host:port cannot be opened 763 the relevant file (socket) descriptor, otherwise. 764 is used. 765 */ 766 Int VG_(connect_via_socket)( UChar* str ) 767 { 768 # if defined(VGO_linux) || defined(VGO_darwin) 769 Int sd, res; 770 struct vki_sockaddr_in servAddr; 771 UInt ip = 0; 772 UShort port = VG_CLO_DEFAULT_LOGPORT; 773 Bool ok = parse_inet_addr_and_port(str, &ip, &port); 774 if (!ok) 775 return -1; 776 777 //if (0) 778 // VG_(printf)("ip = %d.%d.%d.%d, port %d\n", 779 // (ip >> 24) & 0xFF, (ip >> 16) & 0xFF, 780 // (ip >> 8) & 0xFF, ip & 0xFF, 781 // (UInt)port ); 782 783 servAddr.sin_family = VKI_AF_INET; 784 servAddr.sin_addr.s_addr = VG_(htonl)(ip); 785 servAddr.sin_port = VG_(htons)(port); 786 787 /* create socket */ 788 sd = VG_(socket)(VKI_AF_INET, VKI_SOCK_STREAM, 0 /* IPPROTO_IP ? */); 789 if (sd < 0) { 790 /* this shouldn't happen ... nevertheless */ 791 return -2; 792 } 793 794 /* connect to server */ 795 res = my_connect(sd, &servAddr, sizeof(servAddr)); 796 if (res < 0) { 797 /* connection failed */ 798 return -2; 799 } 800 801 return sd; 802 803 # else 804 # error "Unknown OS" 805 # endif 806 } 807 808 809 /* Let d = one or more digits. Accept either: 810 d.d.d.d or d.d.d.d:d 811 */ 812 static Int parse_inet_addr_and_port ( UChar* str, UInt* ip_addr, UShort* port ) 813 { 814 # define GET_CH ((*str) ? (*str++) : 0) 815 UInt ipa, i, j, c, any; 816 ipa = 0; 817 for (i = 0; i < 4; i++) { 818 j = 0; 819 any = 0; 820 while (1) { 821 c = GET_CH; 822 if (c < '0' || c > '9') break; 823 j = 10 * j + (int)(c - '0'); 824 any = 1; 825 } 826 if (any == 0 || j > 255) goto syntaxerr; 827 ipa = (ipa << 8) + j; 828 if (i <= 2 && c != '.') goto syntaxerr; 829 } 830 if (c == 0 || c == ':') 831 *ip_addr = ipa; 832 if (c == 0) goto ok; 833 if (c != ':') goto syntaxerr; 834 j = 0; 835 any = 0; 836 while (1) { 837 c = GET_CH; 838 if (c < '0' || c > '9') break; 839 j = j * 10 + (int)(c - '0'); 840 any = 1; 841 if (j > 65535) goto syntaxerr; 842 } 843 if (any == 0 || c != 0) goto syntaxerr; 844 if (j < 1024) goto syntaxerr; 845 *port = (UShort)j; 846 ok: 847 return 1; 848 syntaxerr: 849 return 0; 850 # undef GET_CH 851 } 852 853 // GrP fixme safe_fd? 854 Int VG_(socket) ( Int domain, Int type, Int protocol ) 855 { 856 # if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \ 857 || defined(VGP_ppc64_linux) || defined(VGP_s390x_linux) 858 SysRes res; 859 UWord args[3]; 860 args[0] = domain; 861 args[1] = type; 862 args[2] = protocol; 863 res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_SOCKET, (UWord)&args); 864 return sr_isError(res) ? -1 : sr_Res(res); 865 866 # elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \ 867 || defined(VGP_mips32_linux) 868 SysRes res; 869 res = VG_(do_syscall3)(__NR_socket, domain, type, protocol ); 870 return sr_isError(res) ? -1 : sr_Res(res); 871 872 # elif defined(VGO_darwin) 873 SysRes res; 874 res = VG_(do_syscall3)(__NR_socket, domain, type, protocol); 875 if (!sr_isError(res)) { 876 // Set SO_NOSIGPIPE so write() returns EPIPE instead of raising SIGPIPE 877 Int optval = 1; 878 SysRes res2; 879 res2 = VG_(do_syscall5)(__NR_setsockopt, sr_Res(res), VKI_SOL_SOCKET, 880 VKI_SO_NOSIGPIPE, (UWord)&optval, 881 sizeof(optval)); 882 // ignore setsockopt() error 883 } 884 return sr_isError(res) ? -1 : sr_Res(res); 885 886 # else 887 # error "Unknown arch" 888 # endif 889 } 890 891 892 static 893 Int my_connect ( Int sockfd, struct vki_sockaddr_in* serv_addr, Int addrlen ) 894 { 895 # if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \ 896 || defined(VGP_ppc64_linux) || defined(VGP_s390x_linux) 897 SysRes res; 898 UWord args[3]; 899 args[0] = sockfd; 900 args[1] = (UWord)serv_addr; 901 args[2] = addrlen; 902 res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_CONNECT, (UWord)&args); 903 return sr_isError(res) ? -1 : sr_Res(res); 904 905 # elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \ 906 || defined(VGP_mips32_linux) 907 SysRes res; 908 res = VG_(do_syscall3)(__NR_connect, sockfd, (UWord)serv_addr, addrlen); 909 return sr_isError(res) ? -1 : sr_Res(res); 910 911 # elif defined(VGO_darwin) 912 SysRes res; 913 res = VG_(do_syscall3)(__NR_connect_nocancel, 914 sockfd, (UWord)serv_addr, addrlen); 915 return sr_isError(res) ? -1 : sr_Res(res); 916 917 # else 918 # error "Unknown arch" 919 # endif 920 } 921 922 Int VG_(write_socket)( Int sd, void *msg, Int count ) 923 { 924 /* This is actually send(). */ 925 926 /* For Linux, VKI_MSG_NOSIGNAL is a request not to send SIGPIPE on 927 errors on stream oriented sockets when the other end breaks the 928 connection. The EPIPE error is still returned. 929 930 For Darwin, VG_(socket)() sets SO_NOSIGPIPE to get EPIPE instead of 931 SIGPIPE */ 932 933 # if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \ 934 || defined(VGP_ppc64_linux) || defined(VGP_s390x_linux) 935 SysRes res; 936 UWord args[4]; 937 args[0] = sd; 938 args[1] = (UWord)msg; 939 args[2] = count; 940 args[3] = VKI_MSG_NOSIGNAL; 941 res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_SEND, (UWord)&args); 942 return sr_isError(res) ? -1 : sr_Res(res); 943 944 # elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \ 945 || defined(VGP_mips32_linux) 946 SysRes res; 947 res = VG_(do_syscall6)(__NR_sendto, sd, (UWord)msg, 948 count, VKI_MSG_NOSIGNAL, 0,0); 949 return sr_isError(res) ? -1 : sr_Res(res); 950 951 # elif defined(VGP_x86_darwin) || defined(VGP_amd64_darwin) 952 SysRes res; 953 res = VG_(do_syscall3)(__NR_write_nocancel, sd, (UWord)msg, count); 954 return sr_isError(res) ? -1 : sr_Res(res); 955 956 # else 957 # error "Unknown platform" 958 # endif 959 } 960 961 Int VG_(getsockname) ( Int sd, struct vki_sockaddr *name, Int *namelen) 962 { 963 # if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \ 964 || defined(VGP_ppc64_linux) || defined(VGP_s390x_linux) \ 965 || defined(VGP_mips32_linux) 966 SysRes res; 967 UWord args[3]; 968 args[0] = sd; 969 args[1] = (UWord)name; 970 args[2] = (UWord)namelen; 971 res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_GETSOCKNAME, (UWord)&args); 972 return sr_isError(res) ? -1 : sr_Res(res); 973 974 # elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) 975 SysRes res; 976 res = VG_(do_syscall3)( __NR_getsockname, 977 (UWord)sd, (UWord)name, (UWord)namelen ); 978 return sr_isError(res) ? -1 : sr_Res(res); 979 980 # elif defined(VGO_darwin) 981 SysRes res; 982 res = VG_(do_syscall3)( __NR_getsockname, 983 (UWord)sd, (UWord)name, (UWord)namelen ); 984 return sr_isError(res) ? -1 : sr_Res(res); 985 986 # else 987 # error "Unknown platform" 988 # endif 989 } 990 991 Int VG_(getpeername) ( Int sd, struct vki_sockaddr *name, Int *namelen) 992 { 993 # if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \ 994 || defined(VGP_ppc64_linux) || defined(VGP_s390x_linux) \ 995 || defined(VGP_mips32_linux) 996 SysRes res; 997 UWord args[3]; 998 args[0] = sd; 999 args[1] = (UWord)name; 1000 args[2] = (UWord)namelen; 1001 res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_GETPEERNAME, (UWord)&args); 1002 return sr_isError(res) ? -1 : sr_Res(res); 1003 1004 # elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) 1005 SysRes res; 1006 res = VG_(do_syscall3)( __NR_getpeername, 1007 (UWord)sd, (UWord)name, (UWord)namelen ); 1008 return sr_isError(res) ? -1 : sr_Res(res); 1009 1010 # elif defined(VGO_darwin) 1011 SysRes res; 1012 res = VG_(do_syscall3)( __NR_getpeername, 1013 (UWord)sd, (UWord)name, (UWord)namelen ); 1014 return sr_isError(res) ? -1 : sr_Res(res); 1015 1016 # else 1017 # error "Unknown platform" 1018 # endif 1019 } 1020 1021 Int VG_(getsockopt) ( Int sd, Int level, Int optname, void *optval, 1022 Int *optlen) 1023 { 1024 # if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \ 1025 || defined(VGP_ppc64_linux) || defined(VGP_s390x_linux) 1026 SysRes res; 1027 UWord args[5]; 1028 args[0] = sd; 1029 args[1] = level; 1030 args[2] = optname; 1031 args[3] = (UWord)optval; 1032 args[4] = (UWord)optlen; 1033 res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_GETSOCKOPT, (UWord)&args); 1034 return sr_isError(res) ? -1 : sr_Res(res); 1035 1036 # elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \ 1037 || defined(VGP_mips32_linux) 1038 SysRes res; 1039 res = VG_(do_syscall5)( __NR_getsockopt, 1040 (UWord)sd, (UWord)level, (UWord)optname, 1041 (UWord)optval, (UWord)optlen ); 1042 return sr_isError(res) ? -1 : sr_Res(res); 1043 1044 # elif defined(VGO_darwin) 1045 SysRes res; 1046 res = VG_(do_syscall5)( __NR_getsockopt, 1047 (UWord)sd, (UWord)level, (UWord)optname, 1048 (UWord)optval, (UWord)optlen ); 1049 return sr_isError(res) ? -1 : sr_Res(res); 1050 1051 # else 1052 # error "Unknown platform" 1053 # endif 1054 } 1055 1056 1057 Char *VG_(basename)(const Char *path) 1058 { 1059 static Char buf[VKI_PATH_MAX]; 1060 1061 const Char *p, *end; 1062 1063 if (path == NULL || 1064 0 == VG_(strcmp)(path, "")) 1065 { 1066 return "."; 1067 } 1068 1069 p = path + VG_(strlen)(path); 1070 while (p > path && *p == '/') { 1071 // skip all trailing '/' 1072 p--; 1073 } 1074 1075 if (p == path && *p == '/') return "/"; // all slashes 1076 1077 end = p; 1078 1079 while (p > path && *p != '/') { 1080 // now skip non '/' 1081 p--; 1082 } 1083 1084 if (*p == '/') p++; 1085 1086 VG_(strncpy)(buf, p, end-p+1); 1087 buf[end-p+1] = '\0'; 1088 1089 return buf; 1090 } 1091 1092 1093 Char *VG_(dirname)(const Char *path) 1094 { 1095 static Char buf[VKI_PATH_MAX]; 1096 1097 const Char *p; 1098 1099 if (path == NULL || 1100 0 == VG_(strcmp)(path, "") || 1101 0 == VG_(strcmp)(path, "/")) 1102 { 1103 return "."; 1104 } 1105 1106 p = path + VG_(strlen)(path); 1107 while (p > path && *p == '/') { 1108 // skip all trailing '/' 1109 p--; 1110 } 1111 1112 while (p > path && *p != '/') { 1113 // now skip non '/' 1114 p--; 1115 } 1116 1117 if (p == path) { 1118 if (*p == '/') return "/"; // all slashes 1119 else return "."; // no slashes 1120 } 1121 1122 while (p > path && *p == '/') { 1123 // skip '/' again 1124 p--; 1125 } 1126 1127 VG_(strncpy)(buf, path, p-path+1); 1128 buf[p-path+1] = '\0'; 1129 1130 return buf; 1131 } 1132 1133 1134 /*--------------------------------------------------------------------*/ 1135 /*--- end ---*/ 1136 /*--------------------------------------------------------------------*/ 1137
