coregrind/m_libcfile.c

   1 /* -*- mode: C; c-basic-offset: 3; -*- */
   2
   3 /*--------------------------------------------------------------------*/
   4 /*--- File- and socket-related libc stuff.            m_libcfile.c ---*/
   5 /*--------------------------------------------------------------------*/
   6
   7 /*
   8    This file is part of Valgrind, a dynamic binary instrumentation
   9    framework.
  10
  11    Copyright (C) 2000-2017 Julian Seward
  12       jseward@acm.org
  13
  14    This program is free software; you can redistribute it and/or
  15    modify it under the terms of the GNU General Public License as
  16    published by the Free Software Foundation; either version 2 of the
  17    License, or (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful, but
  20    WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22    General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program; if not, write to the Free Software
  26    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  27    02111-1307, USA.
  28
  29    The GNU General Public License is contained in the file COPYING.
  30 */
  31
  32 #include "pub_core_basics.h"
  33 #include "pub_core_vki.h"
  34 #include "pub_core_vkiscnums.h"
  35 #include "pub_core_debuglog.h"
  36 #include "pub_core_libcbase.h"
  37 #include "pub_core_libcassert.h"
  38 #include "pub_core_libcfile.h"
  39 #include "pub_core_libcprint.h"     // VG_(sprintf)
  40 #include "pub_core_libcproc.h"      // VG_(getpid), VG_(getppid)
  41 #include "pub_core_clientstate.h"   // VG_(fd_hard_limit)
  42 #include "pub_core_mallocfree.h"    // VG_(realloc)
  43 #include "pub_core_syscall.h"
  44
  45 /* IMPORTANT: on Darwin it is essential to use the _nocancel versions
  46    of syscalls rather than the vanilla version, if a _nocancel version
  47    is available.  See docs/internals/Darwin-notes.txt for the reason
  48    why. */
  49
  50 /* ---------------------------------------------------------------------
  51    File stuff
  52    ------------------------------------------------------------------ */
  53
  54 /* Move an fd into the Valgrind-safe range */
  55 Int VG_(safe_fd)(Int oldfd)
  56 {
  57    Int newfd;
  58
  59    vg_assert(VG_(fd_hard_limit) != -1);
  60
  61    newfd = VG_(fcntl)(oldfd, VKI_F_DUPFD, VG_(fd_hard_limit));
  62    if (newfd != -1)
  63       VG_(close)(oldfd);
  64
  65    /* Set the close-on-exec flag for this fd. */
  66    VG_(fcntl)(newfd, VKI_F_SETFD, VKI_FD_CLOEXEC);
  67
  68    vg_assert(newfd >= VG_(fd_hard_limit));
  69    return newfd;
  70 }
  71
  72 /* Given a file descriptor, attempt to deduce its filename.  To do
  73    this, we use /proc/self/fd/<FD>.  If this doesn't point to a file,
  74    or if it doesn't exist, we return False.
  75    Upon successful completion *result contains the filename. The
  76    filename will be overwritten with the next invocation so callers
  77    need to copy the filename if needed. *result is NULL if the filename
  78    cannot be deduced. */
  79 Bool VG_(resolve_filename) ( Int fd, const HChar** result )
  80 {
  81 #  if defined(VGO_linux) || defined(VGO_solaris)
  82    static HChar *buf = NULL;
  83    static SizeT  bufsiz = 0;
  84
  85    if (buf == NULL) {   // first time
  86       bufsiz = 500;
  87       buf = VG_(malloc)("resolve_filename", bufsiz);
  88    }
  89
  90    HChar tmp[64];   // large enough
  91    {
  92 #     if defined(VGO_linux)
  93       VG_(sprintf)(tmp, "/proc/self/fd/%d", fd);
  94 #     elif defined(VGO_solaris)
  95       VG_(sprintf)(tmp, "/proc/self/path/%d", fd);
  96 #     endif
  97    }
  98
  99    while (42) {
 100       SSizeT res = VG_(readlink)(tmp, buf, bufsiz);
 101       if (res < 0) break;
 102       if (res == bufsiz) {  // buffer too small; increase and retry
 103          bufsiz += 500;
 104          buf = VG_(realloc)("resolve_filename", buf, bufsiz);
 105          continue;
 106       }
 107       vg_assert(bufsiz > res);  // paranoia
 108       if (buf[0] != '/') break;
 109
 110       buf[res] = '\0';
 111       *result = buf;
 112       return True;
 113    }
 114    // Failure
 115    *result = NULL;
 116    return False;
 117
 118 #  elif defined(VGO_darwin)
 119    HChar tmp[VKI_MAXPATHLEN+1];
 120    if (0 == VG_(fcntl)(fd, VKI_F_GETPATH, (UWord)tmp)) {
 121       static HChar *buf = NULL;
 122
 123       if (buf == NULL)
 124          buf = VG_(malloc)("resolve_filename", VKI_MAXPATHLEN+1);
 125       VG_(strcpy)( buf, tmp );
 126
 127       *result = buf;
 128       if (buf[0] == '/') return True;
 129    }
 130    // Failure
 131    *result = NULL;
 132    return False;
 133
 134 #  else
 135 #     error Unknown OS
 136 #  endif
 137 }
 138
 139 SysRes VG_(mknod) ( const HChar* pathname, Int mode, UWord dev )
 140 {
 141 #  if defined(VGP_arm64_linux)
 142    /* ARM64 wants to use __NR_mknodat rather than __NR_mknod. */
 143    SysRes res = VG_(do_syscall4)(__NR_mknodat,
 144                                  VKI_AT_FDCWD, (UWord)pathname, mode, dev);
 145 #  elif defined(VGO_linux) || defined(VGO_darwin)
 146    SysRes res = VG_(do_syscall3)(__NR_mknod,
 147                                  (UWord)pathname, mode, dev);
 148 #  elif defined(VGO_solaris)
 149    SysRes res = VG_(do_syscall4)(__NR_mknodat,
 150                                  VKI_AT_FDCWD, (UWord)pathname, mode, dev);
 151 #  else
 152 #    error Unknown OS
 153 #  endif
 154    return res;
 155 }
 156
 157 SysRes VG_(open) ( const HChar* pathname, Int flags, Int mode )
 158 {
 159 #  if defined(VGP_arm64_linux)
 160    /* ARM64 wants to use __NR_openat rather than __NR_open. */
 161    SysRes res = VG_(do_syscall4)(__NR_openat,
 162                                  VKI_AT_FDCWD, (UWord)pathname, flags, mode);
 163 #  elif defined(VGO_linux)
 164    SysRes res = VG_(do_syscall3)(__NR_open,
 165                                  (UWord)pathname, flags, mode);
 166 #  elif defined(VGO_darwin)
 167    SysRes res = VG_(do_syscall3)(__NR_open_nocancel,
 168                                  (UWord)pathname, flags, mode);
 169 #  elif defined(VGO_solaris)
 170    SysRes res = VG_(do_syscall4)(__NR_openat,
 171                                  VKI_AT_FDCWD, (UWord)pathname, flags, mode);
 172 #  else
 173 #    error Unknown OS
 174 #  endif
 175    return res;
 176 }
 177
 178 Int VG_(fd_open) (const HChar* pathname, Int flags, Int mode)
 179 {
 180    SysRes sr;
 181    sr = VG_(open) (pathname, flags, mode);
 182    if (sr_isError (sr))
 183       return -1;
 184    else
 185       return sr_Res (sr);
 186 }
 187
 188 void VG_(close) ( Int fd )
 189 {
 190    /* Hmm.  Return value is not checked.  That's uncool. */
 191 #  if defined(VGO_linux) || defined(VGO_solaris)
 192    (void)VG_(do_syscall1)(__NR_close, fd);
 193 #  elif defined(VGO_darwin)
 194    (void)VG_(do_syscall1)(__NR_close_nocancel, fd);
 195 #  else
 196 #    error Unknown OS
 197 #  endif
 198 }
 199
 200 Int VG_(read) ( Int fd, void* buf, Int count)
 201 {
 202    Int    ret;
 203 #  if defined(VGO_linux) || defined(VGO_solaris)
 204    SysRes res = VG_(do_syscall3)(__NR_read, fd, (UWord)buf, count);
 205 #  elif defined(VGO_darwin)
 206    SysRes res = VG_(do_syscall3)(__NR_read_nocancel, fd, (UWord)buf, count);
 207 #  else
 208 #    error Unknown OS
 209 #  endif
 210    if (sr_isError(res)) {
 211       ret = - (Int)(Word)sr_Err(res);
 212       vg_assert(ret < 0);
 213    } else {
 214       ret = (Int)(Word)sr_Res(res);
 215       vg_assert(ret >= 0);
 216    }
 217    return ret;
 218 }
 219
 220 Int VG_(write) ( Int fd, const void* buf, Int count)
 221 {
 222    Int    ret;
 223 #  if defined(VGO_linux) || defined(VGO_solaris)
 224    SysRes res = VG_(do_syscall3)(__NR_write, fd, (UWord)buf, count);
 225 #  elif defined(VGO_darwin)
 226    SysRes res = VG_(do_syscall3)(__NR_write_nocancel, fd, (UWord)buf, count);
 227 #  else
 228 #    error "Unknown OS"
 229 #  endif
 230    if (sr_isError(res)) {
 231       ret = - (Int)(Word)sr_Err(res);
 232       vg_assert(ret < 0);
 233    } else {
 234       ret = (Int)(Word)sr_Res(res);
 235       vg_assert(ret >= 0);
 236    }
 237    return ret;
 238 }
 239
 240
 241 Int VG_(pipe) ( Int fd[2] )
 242 {
 243 #  if defined(VGP_mips32_linux) || defined(VGP_mips64_linux)
 244    /* __NR_pipe has a strange return convention on mips32-linux. */
 245    SysRes res = VG_(do_syscall1)(__NR_pipe, (UWord)fd);
 246    if (!sr_isError(res)) {
 247       fd[0] = (Int)sr_Res(res);
 248       fd[1] = (Int)sr_ResEx(res);
 249       return 0;
 250    } else {
 251       return -1;
 252    }
 253 #  elif defined(VGP_arm64_linux)
 254    SysRes res = VG_(do_syscall2)(__NR_pipe2, (UWord)fd, 0);
 255    return sr_isError(res) ? -1 : 0;
 256 #  elif defined(VGO_linux)
 257    SysRes res = VG_(do_syscall1)(__NR_pipe, (UWord)fd);
 258    return sr_isError(res) ? -1 : 0;
 259 #  elif defined(VGO_darwin)
 260    /* __NR_pipe is UX64, so produces a double-word result */
 261    SysRes res = VG_(do_syscall0)(__NR_pipe);
 262    if (!sr_isError(res)) {
 263       fd[0] = (Int)sr_Res(res);
 264       fd[1] = (Int)sr_ResHI(res);
 265    }
 266    return sr_isError(res) ? -1 : 0;
 267 #  elif defined(VGO_solaris)
 268 #  if defined(SOLARIS_NEW_PIPE_SYSCALL)
 269    SysRes res = VG_(do_syscall2)(__NR_pipe, (UWord)fd, 0);
 270    return sr_isError(res) ? -1 : 0;
 271 #  else
 272    SysRes res = VG_(do_syscall0)(__NR_pipe);
 273    if (!sr_isError(res)) {
 274       fd[0] = (Int)sr_Res(res);
 275       fd[1] = (Int)sr_ResHI(res);
 276    }
 277    return sr_isError(res) ? -1 : 0;
 278 #  endif
 279 #  else
 280 #    error "Unknown OS"
 281 #  endif
 282 }
 283
 284 Off64T VG_(lseek) ( Int fd, Off64T offset, Int whence )
 285 {
 286 #  if defined(VGO_linux) || defined(VGP_amd64_darwin)
 287 #  if defined(__NR__llseek)
 288    Off64T result;
 289    SysRes res = VG_(do_syscall5)(__NR__llseek, fd,
 290                                  offset >> 32, offset & 0xffffffff,
 291                                  (UWord)&result, whence);
 292    return sr_isError(res) ? (-1) : result;
 293 #  else
 294    SysRes res = VG_(do_syscall3)(__NR_lseek, fd, offset, whence);
 295    vg_assert(sizeof(Off64T) == sizeof(sr_Res(res)));
 296    return sr_isError(res) ? (-1) : sr_Res(res);
 297 #  endif
 298 #  elif defined(VGP_x86_darwin)
 299    SysRes res = VG_(do_syscall4)(__NR_lseek, fd,
 300                                  offset & 0xffffffff, offset >> 32, whence);
 301    return sr_isError(res) ? (-1) : sr_Res(res);
 302 #  elif defined(VGP_x86_solaris)
 303    SysRes res = VG_(do_syscall4)(__NR_llseek, fd,
 304                                  offset & 0xffffffff, offset >> 32, whence);
 305    return sr_isError(res) ? (-1) : ((ULong)sr_ResHI(res) << 32 | sr_Res(res));
 306 #  elif defined(VGP_amd64_solaris)
 307    SysRes res = VG_(do_syscall3)(__NR_lseek, fd, offset, whence);
 308    vg_assert(sizeof(Off64T) == sizeof(Word));
 309    return sr_isError(res) ? (-1) : sr_Res(res);
 310 #  else
 311 #    error "Unknown plat"
 312 #  endif
 313    /* if you change the error-reporting conventions of this, also
 314       change all usage points. */
 315 }
 316
 317
 318 /* stat/fstat support.  It's uggerly.  We have impedance-match into a
 319    'struct vg_stat' in order to have a single structure that callers
 320    can use consistently on all platforms. */
 321
 322 #define TRANSLATE_TO_vg_stat(_p_vgstat, _p_vkistat) \
 323    do { \
 324       (_p_vgstat)->dev        = (ULong)( (_p_vkistat)->st_dev ); \
 325       (_p_vgstat)->ino        = (ULong)( (_p_vkistat)->st_ino ); \
 326       (_p_vgstat)->nlink      = (ULong)( (_p_vkistat)->st_nlink ); \
 327       (_p_vgstat)->mode       = (UInt) ( (_p_vkistat)->st_mode ); \
 328       (_p_vgstat)->uid        = (UInt) ( (_p_vkistat)->st_uid ); \
 329       (_p_vgstat)->gid        = (UInt) ( (_p_vkistat)->st_gid ); \
 330       (_p_vgstat)->rdev       = (ULong)( (_p_vkistat)->st_rdev ); \
 331       (_p_vgstat)->size       = (Long) ( (_p_vkistat)->st_size ); \
 332       (_p_vgstat)->blksize    = (ULong)( (_p_vkistat)->st_blksize ); \
 333       (_p_vgstat)->blocks     = (ULong)( (_p_vkistat)->st_blocks ); \
 334       (_p_vgstat)->atime      = (ULong)( (_p_vkistat)->st_atime ); \
 335       (_p_vgstat)->atime_nsec = (ULong)( (_p_vkistat)->st_atime_nsec ); \
 336       (_p_vgstat)->mtime      = (ULong)( (_p_vkistat)->st_mtime ); \
 337       (_p_vgstat)->mtime_nsec = (ULong)( (_p_vkistat)->st_mtime_nsec ); \
 338       (_p_vgstat)->ctime      = (ULong)( (_p_vkistat)->st_ctime ); \
 339       (_p_vgstat)->ctime_nsec = (ULong)( (_p_vkistat)->st_ctime_nsec ); \
 340    } while (0)
 341
 342 SysRes VG_(stat) ( const HChar* file_name, struct vg_stat* vgbuf )
 343 {
 344    SysRes res;
 345    VG_(memset)(vgbuf, 0, sizeof(*vgbuf));
 346
 347 #  if defined(VGO_linux) || defined(VGO_darwin)
 348    /* First try with stat64.  If that doesn't work out, fall back to
 349       the vanilla version. */
 350 #  if defined(__NR_stat64)
 351    { struct vki_stat64 buf64;
 352      res = VG_(do_syscall2)(__NR_stat64, (UWord)file_name, (UWord)&buf64);
 353      if (!(sr_isError(res) && sr_Err(res) == VKI_ENOSYS)) {
 354         /* Success, or any failure except ENOSYS */
 355         if (!sr_isError(res))
 356            TRANSLATE_TO_vg_stat(vgbuf, &buf64);
 357         return res;
 358      }
 359    }
 360 #  endif /* defined(__NR_stat64) */
 361    /* This is the fallback ("vanilla version"). */
 362    { struct vki_stat buf;
 363 #    if defined(VGP_arm64_linux)
 364      res = VG_(do_syscall3)(__NR3264_fstatat, VKI_AT_FDCWD,
 365                                               (UWord)file_name, (UWord)&buf);
 366 #    else
 367      res = VG_(do_syscall2)(__NR_stat, (UWord)file_name, (UWord)&buf);
 368 #    endif
 369      if (!sr_isError(res))
 370         TRANSLATE_TO_vg_stat(vgbuf, &buf);
 371      return res;
 372    }
 373 #  elif defined(VGO_solaris)
 374    {
 375 #     if defined(VGP_x86_solaris)
 376       struct vki_stat64 buf64;
 377       res = VG_(do_syscall4)(__NR_fstatat64, VKI_AT_FDCWD, (UWord)file_name,
 378                              (UWord)&buf64, 0);
 379 #     elif defined(VGP_amd64_solaris)
 380       struct vki_stat buf64;
 381       res = VG_(do_syscall4)(__NR_fstatat, VKI_AT_FDCWD, (UWord)file_name,
 382                              (UWord)&buf64, 0);
 383 #     else
 384 #        error "Unknown platform"
 385 #     endif
 386       if (!sr_isError(res))
 387          TRANSLATE_TO_vg_stat(vgbuf, &buf64);
 388       return res;
 389    }
 390 #  else
 391 #    error Unknown OS
 392 #  endif
 393 }
 394
 395 Int VG_(fstat) ( Int fd, struct vg_stat* vgbuf )
 396 {
 397    SysRes res;
 398    VG_(memset)(vgbuf, 0, sizeof(*vgbuf));
 399
 400 #  if defined(VGO_linux) || defined(VGO_darwin)
 401    /* First try with fstat64.  If that doesn't work out, fall back to
 402       the vanilla version. */
 403 #  if defined(__NR_fstat64)
 404    { struct vki_stat64 buf64;
 405      res = VG_(do_syscall2)(__NR_fstat64, (UWord)fd, (UWord)&buf64);
 406      if (!(sr_isError(res) && sr_Err(res) == VKI_ENOSYS)) {
 407         /* Success, or any failure except ENOSYS */
 408         if (!sr_isError(res))
 409            TRANSLATE_TO_vg_stat(vgbuf, &buf64);
 410         return sr_isError(res) ? (-1) : 0;
 411      }
 412    }
 413 #  endif /* if defined(__NR_fstat64) */
 414    { struct vki_stat buf;
 415      res = VG_(do_syscall2)(__NR_fstat, (RegWord)fd, (RegWord)(Addr)&buf);
 416      if (!sr_isError(res))
 417         TRANSLATE_TO_vg_stat(vgbuf, &buf);
 418      return sr_isError(res) ? (-1) : 0;
 419    }
 420 #  elif defined(VGO_solaris)
 421    {
 422 #     if defined(VGP_x86_solaris)
 423       struct vki_stat64 buf64;
 424       res = VG_(do_syscall4)(__NR_fstatat64, (UWord)fd, 0, (UWord)&buf64, 0);
 425 #     elif defined(VGP_amd64_solaris)
 426       struct vki_stat buf64;
 427       res = VG_(do_syscall4)(__NR_fstatat, (UWord)fd, 0, (UWord)&buf64, 0);
 428 #     else
 429 #        error "Unknown platform"
 430 #     endif
 431       if (!sr_isError(res))
 432          TRANSLATE_TO_vg_stat(vgbuf, &buf64);
 433       return sr_isError(res) ? (-1) : 0;
 434    }
 435 #  else
 436 #    error Unknown OS
 437 #  endif
 438 }
 439
 440 #undef TRANSLATE_TO_vg_stat
 441
 442
 443 Long VG_(fsize) ( Int fd )
 444 {
 445    struct vg_stat buf;
 446    Int res = VG_(fstat)( fd, &buf );
 447    return (res == -1) ? (-1LL) : buf.size;
 448 }
 449
 450 SysRes VG_(getxattr) ( const HChar* file_name, const HChar* attr_name, Addr attr_value, SizeT attr_value_len )
 451 {
 452    SysRes res;
 453 #if defined(VGO_linux)
 454    res = VG_(do_syscall4)(__NR_getxattr, (UWord)file_name, (UWord)attr_name,
 455                           attr_value, attr_value_len);
 456 #else
 457    res = VG_(mk_SysRes_Error)(VKI_ENOSYS);
 458 #endif
 459    return res;
 460 }
 461
 462 Bool VG_(is_dir) ( const HChar* f )
 463 {
 464    struct vg_stat buf;
 465    SysRes res = VG_(stat)(f, &buf);
 466    return sr_isError(res) ? False
 467                       : VKI_S_ISDIR(buf.mode) ? True : False;
 468 }
 469
 470 SysRes VG_(dup) ( Int oldfd )
 471 {
 472 #  if defined(VGO_linux) || defined(VGO_darwin)
 473    return VG_(do_syscall1)(__NR_dup, oldfd);
 474 #  elif defined(VGO_solaris)
 475    return VG_(do_syscall3)(__NR_fcntl, oldfd, F_DUPFD, 0);
 476 #  else
 477 #    error Unknown OS
 478 #  endif
 479 }
 480
 481 SysRes VG_(dup2) ( Int oldfd, Int newfd )
 482 {
 483 #  if defined(VGP_arm64_linux)
 484    /* We only have dup3, that means we have to mimic dup2.
 485       The only real difference is when oldfd == newfd.
 486       dup3 always returns an error, but dup2 returns only an
 487       error if the fd is invalid, otherwise it returns newfd. */
 488    if (oldfd == newfd) {
 489       if (VG_(fcntl)(oldfd, VKI_F_GETFL, 0) == -1)
 490          return VG_(mk_SysRes_Error)(VKI_EBADF);
 491       return VG_(mk_SysRes_Success)(newfd);
 492    }
 493    return VG_(do_syscall3)(__NR_dup3, oldfd, newfd, 0);
 494 #  elif defined(VGO_linux) || defined(VGO_darwin)
 495    return VG_(do_syscall2)(__NR_dup2, oldfd, newfd);
 496 #  elif defined(VGO_solaris)
 497    return VG_(do_syscall3)(__NR_fcntl, oldfd, F_DUP2FD, newfd);
 498 #  else
 499 #    error Unknown OS
 500 #  endif
 501 }
 502
 503 /* Returns -1 on error. */
 504 Int VG_(fcntl) ( Int fd, Int cmd, Addr arg )
 505 {
 506 #  if defined(VGO_linux) || defined(VGO_solaris)
 507    SysRes res = VG_(do_syscall3)(__NR_fcntl, fd, cmd, arg);
 508 #  elif defined(VGO_darwin)
 509    SysRes res = VG_(do_syscall3)(__NR_fcntl_nocancel, fd, cmd, arg);
 510 #  else
 511 #    error "Unknown OS"
 512 #  endif
 513    return sr_isError(res) ? -1 : sr_Res(res);
 514 }
 515
 516 Int VG_(rename) ( const HChar* old_name, const HChar* new_name )
 517 {
 518 #  if defined(VGO_solaris) || defined(VGP_arm64_linux)
 519    SysRes res = VG_(do_syscall4)(__NR_renameat, VKI_AT_FDCWD, (UWord)old_name,
 520                                  VKI_AT_FDCWD, (UWord)new_name);
 521 #  elif defined(VGO_linux) || defined(VGO_darwin)
 522    SysRes res = VG_(do_syscall2)(__NR_rename, (UWord)old_name, (UWord)new_name);
 523 #  else
 524 #    error "Unknown OS"
 525 #  endif
 526    return sr_isError(res) ? (-1) : 0;
 527 }
 528
 529 Int VG_(unlink) ( const HChar* file_name )
 530 {
 531 #  if defined(VGP_arm64_linux)
 532    SysRes res = VG_(do_syscall2)(__NR_unlinkat, VKI_AT_FDCWD,
 533                                                 (UWord)file_name);
 534 #  elif defined(VGO_linux) || defined(VGO_darwin)
 535    SysRes res = VG_(do_syscall1)(__NR_unlink, (UWord)file_name);
 536 #  elif defined(VGO_solaris)
 537    SysRes res = VG_(do_syscall3)(__NR_unlinkat, VKI_AT_FDCWD,
 538                                  (UWord)file_name, 0);
 539 #  else
 540 #    error "Unknown OS"
 541 #  endif
 542    return sr_isError(res) ? (-1) : 0;
 543 }
 544
 545 /* The working directory at startup.
 546    All that is really needed is to note the cwd at process startup.
 547    Hence VG_(record_startup_wd) notes it (in a platform dependent way)
 548    and VG_(get_startup_wd) produces the noted value. */
 549 static HChar *startup_wd;
 550
 551 /* Record the process' working directory at startup.  Is intended to
 552    be called exactly once, at startup, before the working directory
 553    changes. */
 554 void VG_(record_startup_wd) ( void )
 555 {
 556 #  if defined(VGO_linux) || defined(VGO_solaris)
 557    /* Simple: just ask the kernel */
 558    SysRes res;
 559    SizeT szB = 0;
 560    do {
 561       szB += 500;
 562       startup_wd = VG_(realloc)("startup_wd", startup_wd, szB);
 563       VG_(memset)(startup_wd, 0, szB);
 564       res = VG_(do_syscall2)(__NR_getcwd, (UWord)startup_wd, szB-1);
 565    } while (sr_isError(res) && sr_Err(res) == VKI_ERANGE);
 566
 567    if (sr_isError(res)) {
 568       VG_(free)(startup_wd);
 569       startup_wd = NULL;
 570       return;
 571    }
 572
 573    vg_assert(startup_wd[szB-1] == 0);
 574
 575 #  elif defined(VGO_darwin)
 576    /* We can't ask the kernel, so instead rely on launcher-*.c to
 577       tell us the startup path.  Note the env var is keyed to the
 578       parent's PID, not ours, since our parent is the launcher
 579       process. */
 580    { HChar  envvar[100];   // large enough
 581      HChar* wd;
 582      VG_(memset)(envvar, 0, sizeof(envvar));
 583      VG_(sprintf)(envvar, "VALGRIND_STARTUP_PWD_%d_XYZZY",
 584                           (Int)VG_(getppid)());
 585      wd = VG_(getenv)( envvar );
 586      if (wd == NULL)
 587         return;
 588      SizeT need = VG_(strlen)(wd) + 1;
 589      startup_wd = VG_(malloc)("startup_wd", need);
 590      VG_(strcpy)(startup_wd, wd);
 591    }
 592 #  else
 593 #    error Unknown OS
 594 #  endif
 595 }
 596
 597 /* Return the previously acquired startup_wd or NULL. */
 598 const HChar *VG_(get_startup_wd) ( void )
 599 {
 600    return startup_wd;
 601 }
 602
 603 SysRes VG_(poll) (struct vki_pollfd *fds, Int nfds, Int timeout)
 604 {
 605    SysRes res;
 606 #  if defined(VGP_arm64_linux)
 607    /* ARM64 wants to use __NR_ppoll rather than __NR_poll. */
 608    struct vki_timespec timeout_ts;
 609    if (timeout >= 0) {
 610       timeout_ts.tv_sec = timeout / 1000;
 611       timeout_ts.tv_nsec = ((long)timeout % 1000) * 1000000;
 612    }
 613    res = VG_(do_syscall4)(__NR_ppoll,
 614                           (UWord)fds, nfds,
 615                           (UWord)(timeout >= 0 ? &timeout_ts : NULL),
 616                           (UWord)NULL);
 617 #  elif defined(VGO_linux)
 618    res = VG_(do_syscall3)(__NR_poll, (UWord)fds, nfds, timeout);
 619 #  elif defined(VGO_darwin)
 620    res = VG_(do_syscall3)(__NR_poll_nocancel, (UWord)fds, nfds, timeout);
 621 #  elif defined(VGO_solaris)
 622    struct vki_timespec ts;
 623    struct vki_timespec *tsp;
 624
 625    if (timeout < 0)
 626       tsp = NULL;
 627    else {
 628       ts.tv_sec = timeout / 1000;
 629       ts.tv_nsec = (timeout % 1000) * 1000000;
 630       tsp = &ts;
 631    }
 632
 633    res = VG_(do_syscall4)(__NR_pollsys, (UWord)fds, nfds, (UWord)tsp, 0);
 634 #  else
 635 #    error "Unknown OS"
 636 #  endif
 637    return res;
 638 }
 639
 640
 641 /* Performs the readlink operation and puts the result into 'buf'.
 642    Note, that the string in 'buf' is *not* null-terminated. The function
 643    returns the number of characters put into 'buf' or -1 if an error
 644    occurred. */
 645 SSizeT VG_(readlink) (const HChar* path, HChar* buf, SizeT bufsiz)
 646 {
 647    SysRes res;
 648    /* res = readlink( path, buf, bufsiz ); */
 649 #  if defined(VGP_arm64_linux)
 650    res = VG_(do_syscall4)(__NR_readlinkat, VKI_AT_FDCWD,
 651                                            (UWord)path, (UWord)buf, bufsiz);
 652 #  elif defined(VGO_linux) || defined(VGO_darwin)
 653    res = VG_(do_syscall3)(__NR_readlink, (UWord)path, (UWord)buf, bufsiz);
 654 #  elif defined(VGO_solaris)
 655    res = VG_(do_syscall4)(__NR_readlinkat, VKI_AT_FDCWD, (UWord)path,
 656                           (UWord)buf, bufsiz);
 657 #  else
 658 #    error "Unknown OS"
 659 #  endif
 660    return sr_isError(res) ? -1 : sr_Res(res);
 661 }
 662
 663 #if defined(VGO_linux) || defined(VGO_solaris)
 664 Int VG_(getdents64) (Int fd, struct vki_dirent64 *dirp, UInt count)
 665 {
 666    SysRes res;
 667    /* res = getdents( fd, dirp, count ); */
 668 #  if defined(VGP_amd64_solaris)
 669    /* This silently assumes that dirent64 and dirent on amd64 are same, which
 670       they should always be. */
 671    res = VG_(do_syscall3)(__NR_getdents, fd, (UWord)dirp, count);
 672 #  else
 673    res = VG_(do_syscall3)(__NR_getdents64, fd, (UWord)dirp, count);
 674 #     if defined(VGA_mips64)
 675       /* The MIPS64 getdents64() system call is only present in 3.10+ kernels.
 676          If the getdents64() system call is not available fall back to using
 677          getdents() and modify the result to be compatible with getdents64(). */
 678       if (sr_isError(res) && (sr_Err(res) == VKI_ENOSYS)) {
 679          int r;
 680          res = VG_(do_syscall3)(__NR_getdents, fd, (UWord)dirp, count);
 681          r = sr_Res(res);
 682          if (r > 0) {
 683             char *p;
 684             char type;
 685             union dirents {
 686                struct vki_dirent m;
 687                struct vki_dirent64 d;
 688             } *u;
 689             p = (char *)dirp;
 690             do {
 691                u = (union dirents *)p;
 692                /* This should not happen, but just in case... */
 693                if (p + u->m.d_reclen > (char *)dirp + r)
 694                   break;
 695                /* shuffle the dirent */
 696                type = *(p + u->m.d_reclen - 1);
 697                VG_(memmove)(u->d.d_name, u->m.d_name,
 698                             u->m.d_reclen - 2
 699                                - offsetof(struct vki_dirent, d_name) + 1);
 700                u->d.d_type = type;
 701                p += u->m.d_reclen;
 702             } while (p < (char *)dirp + r);
 703          }
 704       }
 705 #     endif
 706 #  endif
 707    return sr_isError(res) ? -1 : sr_Res(res);
 708 }
 709 #endif
 710
 711 /* Check accessibility of a file.  Returns zero for access granted,
 712    nonzero otherwise. */
 713 Int VG_(access) ( const HChar* path, Bool irusr, Bool iwusr, Bool ixusr )
 714 {
 715 #  if defined(VGO_linux)
 716    /* Very annoyingly, I cannot find any definition for R_OK et al in
 717       the kernel interfaces.  Therefore I reluctantly resort to
 718       hardwiring in these magic numbers that I determined by
 719       experimentation. */
 720 #  define VKI_R_OK 4
 721 #  define VKI_W_OK 2
 722 #  define VKI_X_OK 1
 723 #  endif
 724
 725    UWord w = (irusr ? VKI_R_OK : 0)
 726              | (iwusr ? VKI_W_OK : 0)
 727              | (ixusr ? VKI_X_OK : 0);
 728 #  if defined(VGP_arm64_linux)
 729    SysRes res = VG_(do_syscall3)(__NR_faccessat, VKI_AT_FDCWD, (UWord)path, w);
 730 #  elif defined(VGO_linux) || defined(VGO_darwin)
 731    SysRes res = VG_(do_syscall2)(__NR_access, (UWord)path, w);
 732 #  elif defined(VGO_solaris)
 733    SysRes res = VG_(do_syscall4)(__NR_faccessat, VKI_AT_FDCWD, (UWord)path,
 734                                  w, 0);
 735 #  else
 736 #    error "Unknown OS"
 737 #  endif
 738    return sr_isError(res) ? 1 : 0;
 739
 740 #  if defined(VGO_linux)
 741 #  undef VKI_R_OK
 742 #  undef VKI_W_OK
 743 #  undef VKI_X_OK
 744 #  endif
 745 }
 746
 747 /*
 748    Emulate the normal Unix permissions checking algorithm.
 749
 750    If owner matches, then use the owner permissions, else
 751    if group matches, then use the group permissions, else
 752    use other permissions.
 753
 754    Note that we can't deal properly with SUID/SGID.  By default
 755    (allow_setuid == False), we refuse to run them (otherwise the
 756    executable may misbehave if it doesn't have the permissions it
 757    thinks it does).  However, the caller may indicate that setuid
 758    executables are allowed, for example if we are going to exec them
 759    but not trace into them (iow, client sys_execve when
 760    clo_trace_children == False).
 761
 762    If VKI_EACCES is returned (iow, permission was refused), then
 763    *is_setuid is set to True iff permission was refused because the
 764    executable is setuid.
 765 */
 766 /* returns: 0 = success, non-0 is failure */
 767 Int VG_(check_executable)(/*OUT*/Bool* is_setuid,
 768                           const HChar* f, Bool allow_setuid)
 769 {
 770    struct vg_stat st;
 771    SysRes res = VG_(stat)(f, &st);
 772
 773    if (is_setuid)
 774       *is_setuid = False;
 775
 776    if (sr_isError(res)) {
 777       return sr_Err(res);
 778    }
 779
 780    if ( VKI_S_ISDIR (st.mode) ) {
 781       return VKI_EACCES;
 782    }
 783
 784    if ( (st.mode & (VKI_S_ISUID | VKI_S_ISGID)) && !allow_setuid ) {
 785       if (is_setuid)
 786          *is_setuid = True;
 787       return VKI_EACCES;
 788    }
 789
 790    res = VG_(getxattr)(f, "security.capability", (Addr)0, 0);
 791    if (!sr_isError(res) && !allow_setuid) {
 792       if (is_setuid)
 793          *is_setuid = True;
 794       return VKI_EACCES;
 795    }
 796
 797    if (VG_(geteuid)() == st.uid) {
 798       if (!(st.mode & VKI_S_IXUSR))
 799          return VKI_EACCES;
 800    } else {
 801       Int grpmatch = 0;
 802
 803       if (VG_(getegid)() == st.gid)
 804          grpmatch = 1;
 805       else {
 806          UInt *groups = NULL;
 807          Int   ngrp;
 808
 809          /* Find out # groups, allocate large enough array and fetch groups */
 810          ngrp = VG_(getgroups)(0, NULL);
 811          if (ngrp != -1) {
 812             groups = VG_(malloc)("check_executable", ngrp * sizeof *groups);
 813             ngrp   = VG_(getgroups)(ngrp, groups);
 814          }
 815
 816          Int i;
 817          /* ngrp will be -1 if VG_(getgroups) failed. */
 818          for (i = 0; i < ngrp; i++) {
 819             if (groups[i] == st.gid) {
 820                grpmatch = 1;
 821                break;
 822             }
 823          }
 824          VG_(free)(groups);
 825       }
 826
 827       if (grpmatch) {
 828          if (!(st.mode & VKI_S_IXGRP)) {
 829             return VKI_EACCES;
 830          }
 831       } else if (!(st.mode & VKI_S_IXOTH)) {
 832          return VKI_EACCES;
 833       }
 834    }
 835
 836    return 0;
 837 }
 838
 839 SysRes VG_(pread) ( Int fd, void* buf, Int count, OffT offset )
 840 {
 841    SysRes res;
 842    // on 32 bits platforms, we receive a 32 bits OffT but
 843    // we must extend it to pass a long long 64 bits.
 844 #  if defined(VGP_x86_linux)
 845    vg_assert(sizeof(OffT) == 4);
 846    res = VG_(do_syscall5)(__NR_pread64, fd, (UWord)buf, count,
 847                           offset, 0); // Little endian long long
 848    return res;
 849 #  elif defined(VGP_arm_linux)
 850    vg_assert(sizeof(OffT) == 4);
 851    res = VG_(do_syscall5)(__NR_pread64, fd, (UWord)buf, count,
 852                           0, offset); // Big endian long long
 853    return res;
 854 #  elif defined(VGP_ppc32_linux)
 855    vg_assert(sizeof(OffT) == 4);
 856    res = VG_(do_syscall6)(__NR_pread64, fd, (UWord)buf, count,
 857                           0, // Padding needed on PPC32
 858                           0, offset); // Big endian long long
 859    return res;
 860 #  elif defined(VGP_mips32_linux) && (VKI_LITTLE_ENDIAN)
 861    vg_assert(sizeof(OffT) == 4);
 862    res = VG_(do_syscall6)(__NR_pread64, fd, (UWord)buf, count,
 863                           0, offset, 0);
 864    return res;
 865 #  elif defined(VGP_mips32_linux) && (VKI_BIG_ENDIAN)
 866    vg_assert(sizeof(OffT) == 4);
 867    res = VG_(do_syscall6)(__NR_pread64, fd, (UWord)buf, count,
 868                           0, 0, offset);
 869    return res;
 870 #  elif defined(VGP_amd64_linux) || defined(VGP_s390x_linux) \
 871       || defined(VGP_ppc64be_linux)  || defined(VGP_ppc64le_linux) \
 872       || defined(VGP_mips64_linux) || defined(VGP_arm64_linux)
 873    res = VG_(do_syscall4)(__NR_pread64, fd, (UWord)buf, count, offset);
 874    return res;
 875 #  elif defined(VGP_amd64_darwin)
 876    vg_assert(sizeof(OffT) == 8);
 877    res = VG_(do_syscall4)(__NR_pread_nocancel, fd, (UWord)buf, count, offset);
 878    return res;
 879 #  elif defined(VGP_x86_darwin)
 880    vg_assert(sizeof(OffT) == 8);
 881    res = VG_(do_syscall5)(__NR_pread_nocancel, fd, (UWord)buf, count,
 882                           offset & 0xffffffff, offset >> 32);
 883    return res;
 884 #  elif defined(VGP_x86_solaris)
 885    vg_assert(sizeof(OffT) == 4);
 886    res = VG_(do_syscall4)(__NR_pread, fd, (UWord)buf, count, offset);
 887    return res;
 888 #  elif defined(VGP_amd64_solaris)
 889    vg_assert(sizeof(OffT) == 8);
 890    res = VG_(do_syscall4)(__NR_pread, fd, (UWord)buf, count, offset);
 891    return res;
 892 #  else
 893 #    error "Unknown platform"
 894 #  endif
 895 }
 896
 897 /* Return the name of a directory for temporary files. */
 898 const HChar *VG_(tmpdir)(void)
 899 {
 900    const HChar *tmpdir;
 901
 902    tmpdir = VG_(getenv)("TMPDIR");
 903    if (tmpdir == NULL || *tmpdir == '\0') tmpdir = VG_TMPDIR;
 904    if (tmpdir == NULL || *tmpdir == '\0') tmpdir = "/tmp";    /* fallback */
 905
 906    return tmpdir;
 907 }
 908
 909 static const HChar mkstemp_format[] = "%s/valgrind_%s_%08x";
 910
 911 SizeT VG_(mkstemp_fullname_bufsz) ( SizeT part_of_name_len )
 912 {
 913    return VG_(strlen)(mkstemp_format)
 914       + VG_(strlen)(VG_(tmpdir)()) - 2 // %s tmpdir
 915       + part_of_name_len - 2           // %s part_of_name
 916       + 8 - 4                          // %08x
 917       + 1;                             // trailing 0
 918 }
 919
 920
 921 Int VG_(mkstemp) ( const HChar* part_of_name, /*OUT*/HChar* fullname )
 922 {
 923    Int    n, tries;
 924    UInt   seed;
 925    SysRes sres;
 926    const HChar *tmpdir;
 927
 928    vg_assert(part_of_name);
 929    vg_assert(fullname);
 930    n = VG_(strlen)(part_of_name);
 931    vg_assert(n > 0 && n < 100);
 932
 933    seed = (VG_(getpid)() << 9) ^ VG_(getppid)();
 934
 935    /* Determine sensible location for temporary files */
 936    tmpdir = VG_(tmpdir)();
 937
 938    tries = 0;
 939    while (True) {
 940       if (tries++ > 10)
 941          return -1;
 942       VG_(sprintf)( fullname, mkstemp_format,
 943                     tmpdir, part_of_name, VG_(random)( &seed ));
 944       if (0)
 945          VG_(printf)("VG_(mkstemp): trying: %s\n", fullname);
 946
 947       sres = VG_(open)(fullname,
 948                        VKI_O_CREAT|VKI_O_RDWR|VKI_O_EXCL|VKI_O_TRUNC,
 949                        VKI_S_IRUSR|VKI_S_IWUSR);
 950       if (sr_isError(sres)) {
 951          VG_(umsg)("VG_(mkstemp): failed to create temp file: %s\n", fullname);
 952          continue;
 953       }
 954       /* VG_(safe_fd) doesn't return if it fails. */
 955       return VG_(safe_fd)( sr_Res(sres) );
 956    }
 957    /* NOTREACHED */
 958 }
 959
 960
 961 /* ---------------------------------------------------------------------
 962    Socket-related stuff.
 963    ------------------------------------------------------------------ */
 964
 965 static
 966 Int parse_inet_addr_and_port ( const HChar* str, UInt* ip_addr, UShort* port );
 967
 968 static
 969 Int my_connect ( Int sockfd, struct vki_sockaddr_in* serv_addr, Int addrlen );
 970
 971 UInt VG_(htonl) ( UInt x )
 972 {
 973 #  if defined(VG_BIGENDIAN)
 974    return x;
 975 #  else
 976    return
 977       (((x >> 24) & 0xFF) << 0) | (((x >> 16) & 0xFF) << 8)
 978       | (((x >> 8) & 0xFF) << 16) | (((x >> 0) & 0xFF) << 24);
 979 #  endif
 980 }
 981
 982 UInt VG_(ntohl) ( UInt x )
 983 {
 984 #  if defined(VG_BIGENDIAN)
 985    return x;
 986 #  else
 987    return
 988       (((x >> 24) & 0xFF) << 0) | (((x >> 16) & 0xFF) << 8)
 989       | (((x >> 8) & 0xFF) << 16) | (((x >> 0) & 0xFF) << 24);
 990 #  endif
 991 }
 992
 993 UShort VG_(htons) ( UShort x )
 994 {
 995 #  if defined(VG_BIGENDIAN)
 996    return x;
 997 #  else
 998    return
 999       (((x >> 8) & 0xFF) << 0) | (((x >> 0) & 0xFF) << 8);
1000 #  endif
1001 }
1002
1003 UShort VG_(ntohs) ( UShort x )
1004 {
1005 #  if defined(VG_BIGENDIAN)
1006    return x;
1007 #  else
1008    return
1009       (((x >> 8) & 0xFF) << 0) | (((x >> 0) & 0xFF) << 8);
1010 #  endif
1011 }
1012
1013
1014 /* The main function.
1015
1016    Supplied string contains either an ip address "192.168.0.1" or
1017    an ip address and port pair, "192.168.0.1:1500".  Parse these,
1018    and return:
1019      -1 if there is a parse error
1020      -2 if no parse error, but specified host:port cannot be opened
1021      the relevant file (socket) descriptor, otherwise.
1022  is used.
1023 */
1024 Int VG_(connect_via_socket)( const HChar* str )
1025 {
1026 #  if defined(VGO_linux) || defined(VGO_darwin) || defined(VGO_solaris)
1027    Int sd, res;
1028    struct vki_sockaddr_in servAddr;
1029    UInt   ip   = 0;
1030    UShort port = VG_CLO_DEFAULT_LOGPORT;
1031    Bool   ok   = parse_inet_addr_and_port(str, &ip, &port);
1032    if (!ok)
1033       return -1;
1034
1035    //if (0)
1036    //   VG_(printf)("ip = %d.%d.%d.%d, port %d\n",
1037    //               (ip >> 24) & 0xFF, (ip >> 16) & 0xFF,
1038    //               (ip >> 8) & 0xFF, ip & 0xFF,
1039    //               (UInt)port );
1040
1041    servAddr.sin_family = VKI_AF_INET;
1042    servAddr.sin_addr.s_addr = VG_(htonl)(ip);
1043    servAddr.sin_port = VG_(htons)(port);
1044
1045    /* create socket */
1046    sd = VG_(socket)(VKI_AF_INET, VKI_SOCK_STREAM, 0 /* IPPROTO_IP ? */);
1047    if (sd < 0) {
1048       /* this shouldn't happen ... nevertheless */
1049       return -2;
1050    }
1051
1052    /* connect to server */
1053    res = my_connect(sd, &servAddr, sizeof(servAddr));
1054    if (res < 0) {
1055       /* connection failed */
1056       return -2;
1057    }
1058
1059    return sd;
1060
1061 #  else
1062 #    error "Unknown OS"
1063 #  endif
1064 }
1065
1066
1067 /* Let d = one or more digits.  Accept either:
1068    d.d.d.d  or  d.d.d.d:d
1069 */
1070 static Int parse_inet_addr_and_port ( const HChar* str, UInt* ip_addr, UShort* port )
1071 {
1072 #  define GET_CH ((*str) ? (*str++) : 0)
1073    UInt ipa, i, j, c, any;
1074    ipa = 0;
1075    for (i = 0; i < 4; i++) {
1076       j = 0;
1077       any = 0;
1078       while (1) {
1079          c = GET_CH;
1080          if (c < '0' || c > '9') break;
1081          j = 10 * j + (int)(c - '0');
1082          any = 1;
1083       }
1084       if (any == 0 || j > 255) goto syntaxerr;
1085       ipa = (ipa << 8) + j;
1086       if (i <= 2 && c != '.') goto syntaxerr;
1087    }
1088    if (c == 0 || c == ':')
1089       *ip_addr = ipa;
1090    if (c == 0) goto ok;
1091    if (c != ':') goto syntaxerr;
1092    j = 0;
1093    any = 0;
1094    while (1) {
1095       c = GET_CH;
1096       if (c < '0' || c > '9') break;
1097       j = j * 10 + (int)(c - '0');
1098       any = 1;
1099       if (j > 65535) goto syntaxerr;
1100    }
1101    if (any == 0 || c != 0) goto syntaxerr;
1102    if (j < 1024) goto syntaxerr;
1103    *port = (UShort)j;
1104  ok:
1105    return 1;
1106  syntaxerr:
1107    return 0;
1108 #  undef GET_CH
1109 }
1110
1111 // GrP fixme safe_fd?
1112 Int VG_(socket) ( Int domain, Int type, Int protocol )
1113 {
1114 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
1115       || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
1116       || defined(VGP_s390x_linux)
1117    SysRes res;
1118    UWord  args[3];
1119    args[0] = domain;
1120    args[1] = type;
1121    args[2] = protocol;
1122    res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_SOCKET, (UWord)&args);
1123    return sr_isError(res) ? -1 : sr_Res(res);
1124
1125 #  elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \
1126         || defined(VGP_mips32_linux) || defined(VGP_mips64_linux) \
1127         || defined(VGP_arm64_linux)
1128    SysRes res;
1129    res = VG_(do_syscall3)(__NR_socket, domain, type, protocol );
1130    return sr_isError(res) ? -1 : sr_Res(res);
1131
1132 #  elif defined(VGO_darwin)
1133    SysRes res;
1134    res = VG_(do_syscall3)(__NR_socket, domain, type, protocol);
1135    if (!sr_isError(res)) {
1136        // Set SO_NOSIGPIPE so write() returns EPIPE instead of raising SIGPIPE
1137        Int optval = 1;
1138        SysRes res2;
1139        res2 = VG_(do_syscall5)(__NR_setsockopt, sr_Res(res), VKI_SOL_SOCKET,
1140                                VKI_SO_NOSIGPIPE, (UWord)&optval,
1141                                sizeof(optval));
1142        // ignore setsockopt() error
1143    }
1144    return sr_isError(res) ? -1 : sr_Res(res);
1145
1146 #  elif defined(VGO_solaris)
1147    /* XXX There doesn't seem to be an easy way to convince the send syscall to
1148       only return EPIPE instead of raising SIGPIPE. EPIPE is only returned if
1149       SM_KERNEL is set on the socket. Without serious hackery it looks we
1150       can't set this flag.
1151
1152       Should we wrap the send syscall below into sigprocmask calls to block
1153       SIGPIPE?
1154     */
1155    SysRes res;
1156    res = VG_(do_syscall5)(__NR_so_socket, domain, type, protocol,
1157                           0 /*devpath*/, VKI_SOV_DEFAULT /*version*/);
1158    return sr_isError(res) ? -1 : sr_Res(res);
1159
1160 #  else
1161 #    error "Unknown arch"
1162 #  endif
1163 }
1164
1165
1166 static
1167 Int my_connect ( Int sockfd, struct vki_sockaddr_in* serv_addr, Int addrlen )
1168 {
1169 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
1170       || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
1171       || defined(VGP_s390x_linux)
1172    SysRes res;
1173    UWord  args[3];
1174    args[0] = sockfd;
1175    args[1] = (UWord)serv_addr;
1176    args[2] = addrlen;
1177    res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_CONNECT, (UWord)&args);
1178    return sr_isError(res) ? -1 : sr_Res(res);
1179
1180 #  elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \
1181         || defined(VGP_mips32_linux) || defined(VGP_mips64_linux) \
1182         || defined(VGP_arm64_linux)
1183    SysRes res;
1184    res = VG_(do_syscall3)(__NR_connect, sockfd, (UWord)serv_addr, addrlen);
1185    return sr_isError(res) ? -1 : sr_Res(res);
1186
1187 #  elif defined(VGO_darwin)
1188    SysRes res;
1189    res = VG_(do_syscall3)(__NR_connect_nocancel,
1190                           sockfd, (UWord)serv_addr, addrlen);
1191    return sr_isError(res) ? -1 : sr_Res(res);
1192
1193 #  elif defined(VGO_solaris)
1194    SysRes res;
1195    res = VG_(do_syscall4)(__NR_connect, sockfd, (UWord)serv_addr, addrlen,
1196                           VKI_SOV_DEFAULT /*version*/);
1197    return sr_isError(res) ? -1 : sr_Res(res);
1198
1199 #  else
1200 #    error "Unknown arch"
1201 #  endif
1202 }
1203
1204 Int VG_(write_socket)( Int sd, const void *msg, Int count )
1205 {
1206    /* This is actually send(). */
1207
1208    /* For Linux, VKI_MSG_NOSIGNAL is a request not to send SIGPIPE on
1209       errors on stream oriented sockets when the other end breaks the
1210       connection. The EPIPE error is still returned.
1211
1212       For Darwin, VG_(socket)() sets SO_NOSIGPIPE to get EPIPE instead of
1213       SIGPIPE */
1214
1215 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
1216       || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
1217       || defined(VGP_s390x_linux)
1218    SysRes res;
1219    UWord  args[4];
1220    args[0] = sd;
1221    args[1] = (UWord)msg;
1222    args[2] = count;
1223    args[3] = VKI_MSG_NOSIGNAL;
1224    res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_SEND, (UWord)&args);
1225    return sr_isError(res) ? -1 : sr_Res(res);
1226
1227 #  elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \
1228         || defined(VGP_mips32_linux) || defined(VGP_mips64_linux) \
1229         || defined(VGP_arm64_linux)
1230    SysRes res;
1231    res = VG_(do_syscall6)(__NR_sendto, sd, (UWord)msg,
1232                                        count, VKI_MSG_NOSIGNAL, 0,0);
1233    return sr_isError(res) ? -1 : sr_Res(res);
1234
1235 #  elif defined(VGP_x86_darwin) || defined(VGP_amd64_darwin)
1236    SysRes res;
1237    res = VG_(do_syscall3)(__NR_write_nocancel, sd, (UWord)msg, count);
1238    return sr_isError(res) ? -1 : sr_Res(res);
1239
1240 #  elif defined(VGO_solaris)
1241    SysRes res;
1242    res = VG_(do_syscall4)(__NR_send, sd, (UWord)msg, count, 0 /*flags*/);
1243    return sr_isError(res) ? -1 : sr_Res(res);
1244
1245 #  else
1246 #    error "Unknown platform"
1247 #  endif
1248 }
1249
1250 Int VG_(getsockname) ( Int sd, struct vki_sockaddr *name, Int *namelen)
1251 {
1252 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
1253       || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
1254       || defined(VGP_s390x_linux) \
1255       || defined(VGP_mips32_linux)
1256    SysRes res;
1257    UWord  args[3];
1258    args[0] = sd;
1259    args[1] = (UWord)name;
1260    args[2] = (UWord)namelen;
1261    res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_GETSOCKNAME, (UWord)&args);
1262    return sr_isError(res) ? -1 : sr_Res(res);
1263
1264 #  elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \
1265         || defined(VGP_mips64_linux) || defined(VGP_arm64_linux)
1266    SysRes res;
1267    res = VG_(do_syscall3)( __NR_getsockname,
1268                            (UWord)sd, (UWord)name, (UWord)namelen );
1269    return sr_isError(res) ? -1 : sr_Res(res);
1270
1271 #  elif defined(VGO_darwin)
1272    SysRes res;
1273    res = VG_(do_syscall3)( __NR_getsockname,
1274                            (UWord)sd, (UWord)name, (UWord)namelen );
1275    return sr_isError(res) ? -1 : sr_Res(res);
1276
1277 #  elif defined(VGO_solaris)
1278    SysRes res;
1279    res = VG_(do_syscall4)(__NR_getsockname, sd, (UWord)name, (UWord)namelen,
1280                           VKI_SOV_DEFAULT /*version*/);
1281    return sr_isError(res) ? -1 : sr_Res(res);
1282
1283 #  else
1284 #    error "Unknown platform"
1285 #  endif
1286 }
1287
1288 Int VG_(getpeername) ( Int sd, struct vki_sockaddr *name, Int *namelen)
1289 {
1290 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
1291       || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
1292       || defined(VGP_s390x_linux) \
1293       || defined(VGP_mips32_linux)
1294    SysRes res;
1295    UWord  args[3];
1296    args[0] = sd;
1297    args[1] = (UWord)name;
1298    args[2] = (UWord)namelen;
1299    res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_GETPEERNAME, (UWord)&args);
1300    return sr_isError(res) ? -1 : sr_Res(res);
1301
1302 #  elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \
1303         || defined(VGP_mips64_linux) || defined(VGP_arm64_linux)
1304    SysRes res;
1305    res = VG_(do_syscall3)( __NR_getpeername,
1306                            (UWord)sd, (UWord)name, (UWord)namelen );
1307    return sr_isError(res) ? -1 : sr_Res(res);
1308
1309 #  elif defined(VGO_darwin)
1310    SysRes res;
1311    res = VG_(do_syscall3)( __NR_getpeername,
1312                            (UWord)sd, (UWord)name, (UWord)namelen );
1313    return sr_isError(res) ? -1 : sr_Res(res);
1314
1315 #  elif defined(VGO_solaris)
1316    SysRes res;
1317    res = VG_(do_syscall4)(__NR_getpeername, sd, (UWord)name, (UWord)namelen,
1318                           VKI_SOV_DEFAULT /*version*/);
1319    return sr_isError(res) ? -1 : sr_Res(res);
1320
1321 #  else
1322 #    error "Unknown platform"
1323 #  endif
1324 }
1325
1326 Int VG_(getsockopt) ( Int sd, Int level, Int optname, void *optval,
1327                       Int *optlen)
1328 {
1329 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
1330       || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
1331       || defined(VGP_s390x_linux)
1332    SysRes res;
1333    UWord  args[5];
1334    args[0] = sd;
1335    args[1] = level;
1336    args[2] = optname;
1337    args[3] = (UWord)optval;
1338    args[4] = (UWord)optlen;
1339    res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_GETSOCKOPT, (UWord)&args);
1340    return sr_isError(res) ? -1 : sr_Res(res);
1341
1342 #  elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \
1343         || defined(VGP_mips32_linux) || defined(VGP_mips64_linux) \
1344         || defined(VGP_arm64_linux)
1345    SysRes res;
1346    res = VG_(do_syscall5)( __NR_getsockopt,
1347                            (UWord)sd, (UWord)level, (UWord)optname,
1348                            (UWord)optval, (UWord)optlen );
1349    return sr_isError(res) ? -1 : sr_Res(res);
1350
1351 #  elif defined(VGO_darwin)
1352    SysRes res;
1353    res = VG_(do_syscall5)( __NR_getsockopt,
1354                            (UWord)sd, (UWord)level, (UWord)optname,
1355                            (UWord)optval, (UWord)optlen );
1356    return sr_isError(res) ? -1 : sr_Res(res);
1357
1358 #  elif defined(VGO_solaris)
1359    SysRes res;
1360    res = VG_(do_syscall6)(__NR_getsockopt, sd, level, optname, (UWord)optval,
1361                           (UWord)optlen, VKI_SOV_DEFAULT /*version*/);
1362    return sr_isError(res) ? -1 : sr_Res(res);
1363
1364 #  else
1365 #    error "Unknown platform"
1366 #  endif
1367 }
1368
1369
1370 Int VG_(setsockopt) ( Int sd, Int level, Int optname, void *optval,
1371                       Int optlen)
1372 {
1373 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
1374       || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
1375       || defined(VGP_s390x_linux)
1376    SysRes res;
1377    UWord  args[5];
1378    args[0] = sd;
1379    args[1] = level;
1380    args[2] = optname;
1381    args[3] = (UWord)optval;
1382    args[4] = (UWord)optlen;
1383    res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_SETSOCKOPT, (UWord)&args);
1384    return sr_isError(res) ? -1 : sr_Res(res);
1385
1386 #  elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \
1387         || defined(VGP_mips32_linux) || defined(VGP_mips64_linux) \
1388         || defined(VGP_arm64_linux)
1389    SysRes res;
1390    res = VG_(do_syscall5)( __NR_setsockopt,
1391                            (UWord)sd, (UWord)level, (UWord)optname,
1392                            (UWord)optval, (UWord)optlen );
1393    return sr_isError(res) ? -1 : sr_Res(res);
1394
1395 #  elif defined(VGO_darwin)
1396    SysRes res;
1397    res = VG_(do_syscall5)( __NR_setsockopt,
1398                            (UWord)sd, (UWord)level, (UWord)optname,
1399                            (UWord)optval, (UWord)optlen );
1400    return sr_isError(res) ? -1 : sr_Res(res);
1401
1402 #  elif defined(VGO_solaris)
1403    SysRes res;
1404    res = VG_(do_syscall6)( __NR_setsockopt,
1405                            (UWord)sd, (UWord)level, (UWord)optname,
1406                            (UWord)optval, (UWord)optlen,
1407                            VKI_SOV_DEFAULT /*version*/ );
1408    return sr_isError(res) ? -1 : sr_Res(res);
1409
1410 #  else
1411 #    error "Unknown platform"
1412 #  endif
1413 }
1414
1415
1416 const HChar *VG_(basename)(const HChar *path)
1417 {
1418    static HChar *buf = NULL;
1419    static SizeT  buf_len = 0;
1420    const HChar *p, *end;
1421
1422    if (path == NULL  ||
1423        0 == VG_(strcmp)(path, ""))
1424    {
1425       return ".";
1426    }
1427
1428    p = path + VG_(strlen)(path);
1429    while (p > path  &&  *p == '/') {
1430       // skip all trailing '/'
1431       p--;
1432    }
1433
1434    if (p == path  &&  *p == '/') return "/"; // all slashes
1435
1436    end = p;
1437
1438    while (p > path  &&  *p != '/') {
1439       // now skip non '/'
1440       p--;
1441    }
1442
1443    if (*p == '/') p++;
1444
1445    SizeT need = end-p+1 + 1;
1446    if (need > buf_len) {
1447       buf_len = (buf_len == 0) ? 500 : need;
1448       buf = VG_(realloc)("basename", buf, buf_len);
1449    }
1450    VG_(strncpy)(buf, p, end-p+1);
1451    buf[end-p+1] = '\0';
1452
1453    return buf;
1454 }
1455
1456
1457 const HChar *VG_(dirname)(const HChar *path)
1458 {
1459    static HChar *buf = NULL;
1460    static SizeT  buf_len = 0;
1461
1462    const HChar *p;
1463
1464    if (path == NULL  ||
1465        0 == VG_(strcmp)(path, "")  ||
1466        0 == VG_(strcmp)(path, "/"))
1467    {
1468       return ".";
1469    }
1470
1471    p = path + VG_(strlen)(path);
1472    while (p > path  &&  *p == '/') {
1473       // skip all trailing '/'
1474       p--;
1475    }
1476
1477    while (p > path  &&  *p != '/') {
1478       // now skip non '/'
1479       p--;
1480    }
1481
1482    if (p == path) {
1483       if (*p == '/') return "/"; // all slashes
1484       else return "."; // no slashes
1485    }
1486
1487    while (p > path  &&  *p == '/') {
1488       // skip '/' again
1489       p--;
1490    }
1491
1492    SizeT need = p-path+1 + 1;
1493    if (need > buf_len) {
1494       buf_len = (buf_len == 0) ? 500 : need;
1495       buf = VG_(realloc)("dirname", buf, buf_len);
1496    }
1497    VG_(strncpy)(buf, path, p-path+1);
1498    buf[p-path+1] = '\0';
1499
1500    return buf;
1501 }
1502
1503
1504 /*--------------------------------------------------------------------*/
1505 /*--- end                                                          ---*/
1506 /*--------------------------------------------------------------------*/