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-2015 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) || defined(VGP_tilegx_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) || defined(VGP_tilegx_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) || defined(VGP_tilegx_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(Word));
 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) || defined(VGP_tilegx_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, (UWord)fd, (UWord)&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(VGO_linux) || defined(VGO_darwin)
 484    return VG_(do_syscall2)(__NR_dup2, oldfd, newfd);
 485 #  elif defined(VGO_solaris)
 486    return VG_(do_syscall3)(__NR_fcntl, oldfd, F_DUP2FD, newfd);
 487 #  else
 488 #    error Unknown OS
 489 #  endif
 490 }
 491
 492 /* Returns -1 on error. */
 493 Int VG_(fcntl) ( Int fd, Int cmd, Addr arg )
 494 {
 495 #  if defined(VGO_linux) || defined(VGO_solaris)
 496    SysRes res = VG_(do_syscall3)(__NR_fcntl, fd, cmd, arg);
 497 #  elif defined(VGO_darwin)
 498    SysRes res = VG_(do_syscall3)(__NR_fcntl_nocancel, fd, cmd, arg);
 499 #  else
 500 #    error "Unknown OS"
 501 #  endif
 502    return sr_isError(res) ? -1 : sr_Res(res);
 503 }
 504
 505 Int VG_(rename) ( const HChar* old_name, const HChar* new_name )
 506 {
 507 #  if defined(VGP_tilegx_linux)
 508    SysRes res = VG_(do_syscall3)(__NR_renameat, VKI_AT_FDCWD,
 509                                  (UWord)old_name, (UWord)new_name);
 510 #  elif defined(VGO_linux) || defined(VGO_darwin)
 511    SysRes res = VG_(do_syscall2)(__NR_rename, (UWord)old_name, (UWord)new_name);
 512 #  elif defined(VGO_solaris)
 513    SysRes res = VG_(do_syscall4)(__NR_renameat, VKI_AT_FDCWD, (UWord)old_name,
 514                                  VKI_AT_FDCWD, (UWord)new_name);
 515 #  else
 516 #    error "Unknown OS"
 517 #  endif
 518    return sr_isError(res) ? (-1) : 0;
 519 }
 520
 521 Int VG_(unlink) ( const HChar* file_name )
 522 {
 523 #  if defined(VGP_arm64_linux) || defined(VGP_tilegx_linux)
 524    SysRes res = VG_(do_syscall2)(__NR_unlinkat, VKI_AT_FDCWD,
 525                                                 (UWord)file_name);
 526 #  elif defined(VGO_linux) || defined(VGO_darwin)
 527    SysRes res = VG_(do_syscall1)(__NR_unlink, (UWord)file_name);
 528 #  elif defined(VGO_solaris)
 529    SysRes res = VG_(do_syscall3)(__NR_unlinkat, VKI_AT_FDCWD,
 530                                  (UWord)file_name, 0);
 531 #  else
 532 #    error "Unknown OS"
 533 #  endif
 534    return sr_isError(res) ? (-1) : 0;
 535 }
 536
 537 /* The working directory at startup.
 538    All that is really needed is to note the cwd at process startup.
 539    Hence VG_(record_startup_wd) notes it (in a platform dependent way)
 540    and VG_(get_startup_wd) produces the noted value. */
 541 static HChar *startup_wd;
 542 static Bool   startup_wd_acquired = False;
 543
 544 /* Record the process' working directory at startup.  Is intended to
 545    be called exactly once, at startup, before the working directory
 546    changes.  Return True for success, False for failure, so that the
 547    caller can bomb out suitably without creating module cycles if
 548    there is a problem. */
 549 Bool VG_(record_startup_wd) ( void )
 550 {
 551    vg_assert(!startup_wd_acquired);
 552 #  if defined(VGO_linux) || defined(VGO_solaris)
 553    /* Simple: just ask the kernel */
 554    SysRes res;
 555    SizeT szB = 0;
 556    do {
 557       szB += 500;
 558       startup_wd = VG_(realloc)("startup_wd", startup_wd, szB);
 559       VG_(memset)(startup_wd, 0, szB);
 560       res = VG_(do_syscall2)(__NR_getcwd, (UWord)startup_wd, szB-1);
 561    } while (sr_isError(res));
 562
 563    vg_assert(startup_wd[szB-1] == 0);
 564    startup_wd_acquired = True;
 565    return True;
 566
 567 #  elif defined(VGO_darwin)
 568    /* We can't ask the kernel, so instead rely on launcher-*.c to
 569       tell us the startup path.  Note the env var is keyed to the
 570       parent's PID, not ours, since our parent is the launcher
 571       process. */
 572    { HChar  envvar[100];   // large enough
 573      HChar* wd;
 574      VG_(memset)(envvar, 0, sizeof(envvar));
 575      VG_(sprintf)(envvar, "VALGRIND_STARTUP_PWD_%d_XYZZY",
 576                           (Int)VG_(getppid)());
 577      wd = VG_(getenv)( envvar );
 578      if (wd == NULL)
 579         return False;
 580      SizeT need = VG_(strlen)(wd) + 1;
 581      startup_wd = VG_(malloc)("startup_wd", need);
 582      VG_(strcpy)(startup_wd, wd);
 583      startup_wd_acquired = True;
 584      return True;
 585    }
 586 #  else
 587 #    error Unknown OS
 588 #  endif
 589 }
 590
 591 /* Return the previously acquired startup_wd. */
 592 const HChar *VG_(get_startup_wd) ( void )
 593 {
 594    vg_assert(startup_wd_acquired);
 595
 596    return startup_wd;
 597 }
 598
 599 SysRes VG_(poll) (struct vki_pollfd *fds, Int nfds, Int timeout)
 600 {
 601    SysRes res;
 602 #  if defined(VGP_arm64_linux) || defined(VGP_tilegx_linux)
 603    /* ARM64 wants to use __NR_ppoll rather than __NR_poll. */
 604    struct vki_timespec timeout_ts;
 605    if (timeout >= 0) {
 606       timeout_ts.tv_sec = timeout / 1000;
 607       timeout_ts.tv_nsec = ((long)timeout % 1000) * 1000000;
 608    }
 609    res = VG_(do_syscall4)(__NR_ppoll,
 610                           (UWord)fds, nfds,
 611                           (UWord)(timeout >= 0 ? &timeout_ts : NULL),
 612                           (UWord)NULL);
 613 #  elif defined(VGO_linux)
 614    res = VG_(do_syscall3)(__NR_poll, (UWord)fds, nfds, timeout);
 615 #  elif defined(VGO_darwin)
 616    res = VG_(do_syscall3)(__NR_poll_nocancel, (UWord)fds, nfds, timeout);
 617 #  elif defined(VGO_solaris)
 618    struct vki_timespec ts;
 619    struct vki_timespec *tsp;
 620
 621    if (timeout < 0)
 622       tsp = NULL;
 623    else {
 624       ts.tv_sec = timeout / 1000;
 625       ts.tv_nsec = (timeout % 1000) * 1000000;
 626       tsp = &ts;
 627    }
 628
 629    res = VG_(do_syscall4)(__NR_pollsys, (UWord)fds, nfds, (UWord)tsp, 0);
 630 #  else
 631 #    error "Unknown OS"
 632 #  endif
 633    return res;
 634 }
 635
 636
 637 /* Performs the readlink operation and puts the result into 'buf'.
 638    Note, that the string in 'buf' is *not* null-terminated. The function
 639    returns the number of characters put into 'buf' or -1 if an error
 640    occurred. */
 641 SSizeT VG_(readlink) (const HChar* path, HChar* buf, SizeT bufsiz)
 642 {
 643    SysRes res;
 644    /* res = readlink( path, buf, bufsiz ); */
 645 #  if defined(VGP_arm64_linux) || defined(VGP_tilegx_linux)
 646    res = VG_(do_syscall4)(__NR_readlinkat, VKI_AT_FDCWD,
 647                                            (UWord)path, (UWord)buf, bufsiz);
 648 #  elif defined(VGO_linux) || defined(VGO_darwin)
 649    res = VG_(do_syscall3)(__NR_readlink, (UWord)path, (UWord)buf, bufsiz);
 650 #  elif defined(VGO_solaris)
 651    res = VG_(do_syscall4)(__NR_readlinkat, VKI_AT_FDCWD, (UWord)path,
 652                           (UWord)buf, bufsiz);
 653 #  else
 654 #    error "Unknown OS"
 655 #  endif
 656    return sr_isError(res) ? -1 : sr_Res(res);
 657 }
 658
 659 #if defined(VGO_linux) || defined(VGO_solaris)
 660 Int VG_(getdents64) (Int fd, struct vki_dirent64 *dirp, UInt count)
 661 {
 662    SysRes res;
 663    /* res = getdents( fd, dirp, count ); */
 664 #  if defined(VGP_amd64_solaris)
 665    /* This silently assumes that dirent64 and dirent on amd64 are same, which
 666       they should always be. */
 667    res = VG_(do_syscall3)(__NR_getdents, fd, (UWord)dirp, count);
 668 #  else
 669    res = VG_(do_syscall3)(__NR_getdents64, fd, (UWord)dirp, count);
 670 #  endif
 671    return sr_isError(res) ? -1 : sr_Res(res);
 672 }
 673 #endif
 674
 675 /* Check accessibility of a file.  Returns zero for access granted,
 676    nonzero otherwise. */
 677 Int VG_(access) ( const HChar* path, Bool irusr, Bool iwusr, Bool ixusr )
 678 {
 679 #  if defined(VGO_linux)
 680    /* Very annoyingly, I cannot find any definition for R_OK et al in
 681       the kernel interfaces.  Therefore I reluctantly resort to
 682       hardwiring in these magic numbers that I determined by
 683       experimentation. */
 684 #  define VKI_R_OK 4
 685 #  define VKI_W_OK 2
 686 #  define VKI_X_OK 1
 687 #  endif
 688
 689    UWord w = (irusr ? VKI_R_OK : 0)
 690              | (iwusr ? VKI_W_OK : 0)
 691              | (ixusr ? VKI_X_OK : 0);
 692 #  if defined(VGP_arm64_linux) || defined(VGP_tilegx_linux)
 693    SysRes res = VG_(do_syscall3)(__NR_faccessat, VKI_AT_FDCWD, (UWord)path, w);
 694 #  elif defined(VGO_linux) || defined(VGO_darwin)
 695    SysRes res = VG_(do_syscall2)(__NR_access, (UWord)path, w);
 696 #  elif defined(VGO_solaris)
 697    SysRes res = VG_(do_syscall4)(__NR_faccessat, VKI_AT_FDCWD, (UWord)path,
 698                                  w, 0);
 699 #  else
 700 #    error "Unknown OS"
 701 #  endif
 702    return sr_isError(res) ? 1 : 0;
 703
 704 #  if defined(VGO_linux)
 705 #  undef VKI_R_OK
 706 #  undef VKI_W_OK
 707 #  undef VKI_X_OK
 708 #  endif
 709 }
 710
 711 /*
 712    Emulate the normal Unix permissions checking algorithm.
 713
 714    If owner matches, then use the owner permissions, else
 715    if group matches, then use the group permissions, else
 716    use other permissions.
 717
 718    Note that we can't deal properly with SUID/SGID.  By default
 719    (allow_setuid == False), we refuse to run them (otherwise the
 720    executable may misbehave if it doesn't have the permissions it
 721    thinks it does).  However, the caller may indicate that setuid
 722    executables are allowed, for example if we are going to exec them
 723    but not trace into them (iow, client sys_execve when
 724    clo_trace_children == False).
 725
 726    If VKI_EACCES is returned (iow, permission was refused), then
 727    *is_setuid is set to True iff permission was refused because the
 728    executable is setuid.
 729 */
 730 /* returns: 0 = success, non-0 is failure */
 731 Int VG_(check_executable)(/*OUT*/Bool* is_setuid,
 732                           const HChar* f, Bool allow_setuid)
 733 {
 734    struct vg_stat st;
 735    SysRes res = VG_(stat)(f, &st);
 736
 737    if (is_setuid)
 738       *is_setuid = False;
 739
 740    if (sr_isError(res)) {
 741       return sr_Err(res);
 742    }
 743
 744    if ( VKI_S_ISDIR (st.mode) ) {
 745       return VKI_EACCES;
 746    }
 747
 748    if ( (st.mode & (VKI_S_ISUID | VKI_S_ISGID)) && !allow_setuid ) {
 749       if (is_setuid)
 750          *is_setuid = True;
 751       return VKI_EACCES;
 752    }
 753
 754    res = VG_(getxattr)(f, "security.capability", (Addr)0, 0);
 755    if (!sr_isError(res) && !allow_setuid) {
 756       if (is_setuid)
 757          *is_setuid = True;
 758       return VKI_EACCES;
 759    }
 760
 761    if (VG_(geteuid)() == st.uid) {
 762       if (!(st.mode & VKI_S_IXUSR))
 763          return VKI_EACCES;
 764    } else {
 765       Int grpmatch = 0;
 766
 767       if (VG_(getegid)() == st.gid)
 768          grpmatch = 1;
 769       else {
 770          UInt *groups = NULL;
 771          Int   ngrp;
 772
 773          /* Find out # groups, allocate large enough array and fetch groups */
 774          ngrp = VG_(getgroups)(0, NULL);
 775          if (ngrp != -1) {
 776             groups = VG_(malloc)("check_executable", ngrp * sizeof *groups);
 777             ngrp   = VG_(getgroups)(ngrp, groups);
 778          }
 779
 780          Int i;
 781          /* ngrp will be -1 if VG_(getgroups) failed. */
 782          for (i = 0; i < ngrp; i++) {
 783             if (groups[i] == st.gid) {
 784                grpmatch = 1;
 785                break;
 786             }
 787          }
 788          VG_(free)(groups);
 789       }
 790
 791       if (grpmatch) {
 792          if (!(st.mode & VKI_S_IXGRP)) {
 793             return VKI_EACCES;
 794          }
 795       } else if (!(st.mode & VKI_S_IXOTH)) {
 796          return VKI_EACCES;
 797       }
 798    }
 799
 800    return 0;
 801 }
 802
 803 SysRes VG_(pread) ( Int fd, void* buf, Int count, OffT offset )
 804 {
 805    SysRes res;
 806    // on 32 bits platforms, we receive a 32 bits OffT but
 807    // we must extend it to pass a long long 64 bits.
 808 #  if defined(VGP_x86_linux)
 809    vg_assert(sizeof(OffT) == 4);
 810    res = VG_(do_syscall5)(__NR_pread64, fd, (UWord)buf, count,
 811                           offset, 0); // Little endian long long
 812    return res;
 813 #  elif defined(VGP_arm_linux)
 814    vg_assert(sizeof(OffT) == 4);
 815    res = VG_(do_syscall5)(__NR_pread64, fd, (UWord)buf, count,
 816                           0, offset); // Big endian long long
 817    return res;
 818 #  elif defined(VGP_ppc32_linux)
 819    vg_assert(sizeof(OffT) == 4);
 820    res = VG_(do_syscall6)(__NR_pread64, fd, (UWord)buf, count,
 821                           0, // Padding needed on PPC32
 822                           0, offset); // Big endian long long
 823    return res;
 824 #  elif defined(VGP_mips32_linux) && (VKI_LITTLE_ENDIAN)
 825    vg_assert(sizeof(OffT) == 4);
 826    res = VG_(do_syscall6)(__NR_pread64, fd, (UWord)buf, count,
 827                           0, offset, 0);
 828    return res;
 829 #  elif defined(VGP_mips32_linux) && (VKI_BIG_ENDIAN)
 830    vg_assert(sizeof(OffT) == 4);
 831    res = VG_(do_syscall6)(__NR_pread64, fd, (UWord)buf, count,
 832                           0, 0, offset);
 833    return res;
 834 #  elif defined(VGP_amd64_linux) || defined(VGP_s390x_linux) \
 835       || defined(VGP_ppc64be_linux)  || defined(VGP_ppc64le_linux) \
 836       || defined(VGP_mips64_linux) \
 837   || defined(VGP_arm64_linux) || defined(VGP_tilegx_linux)
 838    res = VG_(do_syscall4)(__NR_pread64, fd, (UWord)buf, count, offset);
 839    return res;
 840 #  elif defined(VGP_amd64_darwin)
 841    vg_assert(sizeof(OffT) == 8);
 842    res = VG_(do_syscall4)(__NR_pread_nocancel, fd, (UWord)buf, count, offset);
 843    return res;
 844 #  elif defined(VGP_x86_darwin)
 845    vg_assert(sizeof(OffT) == 8);
 846    res = VG_(do_syscall5)(__NR_pread_nocancel, fd, (UWord)buf, count,
 847                           offset & 0xffffffff, offset >> 32);
 848    return res;
 849 #  elif defined(VGP_x86_solaris)
 850    vg_assert(sizeof(OffT) == 4);
 851    res = VG_(do_syscall4)(__NR_pread, fd, (UWord)buf, count, offset);
 852    return res;
 853 #  elif defined(VGP_amd64_solaris)
 854    vg_assert(sizeof(OffT) == 8);
 855    res = VG_(do_syscall4)(__NR_pread, fd, (UWord)buf, count, offset);
 856    return res;
 857 #  else
 858 #    error "Unknown platform"
 859 #  endif
 860 }
 861
 862 /* Return the name of a directory for temporary files. */
 863 const HChar *VG_(tmpdir)(void)
 864 {
 865    const HChar *tmpdir;
 866
 867    tmpdir = VG_(getenv)("TMPDIR");
 868    if (tmpdir == NULL || *tmpdir == '\0') tmpdir = VG_TMPDIR;
 869    if (tmpdir == NULL || *tmpdir == '\0') tmpdir = "/tmp";    /* fallback */
 870
 871    return tmpdir;
 872 }
 873
 874 static const HChar mkstemp_format[] = "%s/valgrind_%s_%08x";
 875
 876 SizeT VG_(mkstemp_fullname_bufsz) ( SizeT part_of_name_len )
 877 {
 878    return VG_(strlen)(mkstemp_format)
 879       + VG_(strlen)(VG_(tmpdir)()) - 2 // %s tmpdir
 880       + part_of_name_len - 2           // %s part_of_name
 881       + 8 - 4                          // %08x
 882       + 1;                             // trailing 0
 883 }
 884
 885
 886 Int VG_(mkstemp) ( const HChar* part_of_name, /*OUT*/HChar* fullname )
 887 {
 888    Int    n, tries;
 889    UInt   seed;
 890    SysRes sres;
 891    const HChar *tmpdir;
 892
 893    vg_assert(part_of_name);
 894    vg_assert(fullname);
 895    n = VG_(strlen)(part_of_name);
 896    vg_assert(n > 0 && n < 100);
 897
 898    seed = (VG_(getpid)() << 9) ^ VG_(getppid)();
 899
 900    /* Determine sensible location for temporary files */
 901    tmpdir = VG_(tmpdir)();
 902
 903    tries = 0;
 904    while (True) {
 905       if (tries++ > 10)
 906          return -1;
 907       VG_(sprintf)( fullname, mkstemp_format,
 908                     tmpdir, part_of_name, VG_(random)( &seed ));
 909       if (0)
 910          VG_(printf)("VG_(mkstemp): trying: %s\n", fullname);
 911
 912       sres = VG_(open)(fullname,
 913                        VKI_O_CREAT|VKI_O_RDWR|VKI_O_EXCL|VKI_O_TRUNC,
 914                        VKI_S_IRUSR|VKI_S_IWUSR);
 915       if (sr_isError(sres)) {
 916          VG_(umsg)("VG_(mkstemp): failed to create temp file: %s\n", fullname);
 917          continue;
 918       }
 919       /* VG_(safe_fd) doesn't return if it fails. */
 920       return VG_(safe_fd)( sr_Res(sres) );
 921    }
 922    /* NOTREACHED */
 923 }
 924
 925
 926 /* ---------------------------------------------------------------------
 927    Socket-related stuff.
 928    ------------------------------------------------------------------ */
 929
 930 static
 931 Int parse_inet_addr_and_port ( const HChar* str, UInt* ip_addr, UShort* port );
 932
 933 static
 934 Int my_connect ( Int sockfd, struct vki_sockaddr_in* serv_addr, Int addrlen );
 935
 936 UInt VG_(htonl) ( UInt x )
 937 {
 938 #  if defined(VG_BIGENDIAN)
 939    return x;
 940 #  else
 941    return
 942       (((x >> 24) & 0xFF) << 0) | (((x >> 16) & 0xFF) << 8)
 943       | (((x >> 8) & 0xFF) << 16) | (((x >> 0) & 0xFF) << 24);
 944 #  endif
 945 }
 946
 947 UInt VG_(ntohl) ( UInt x )
 948 {
 949 #  if defined(VG_BIGENDIAN)
 950    return x;
 951 #  else
 952    return
 953       (((x >> 24) & 0xFF) << 0) | (((x >> 16) & 0xFF) << 8)
 954       | (((x >> 8) & 0xFF) << 16) | (((x >> 0) & 0xFF) << 24);
 955 #  endif
 956 }
 957
 958 UShort VG_(htons) ( UShort x )
 959 {
 960 #  if defined(VG_BIGENDIAN)
 961    return x;
 962 #  else
 963    return
 964       (((x >> 8) & 0xFF) << 0) | (((x >> 0) & 0xFF) << 8);
 965 #  endif
 966 }
 967
 968 UShort VG_(ntohs) ( UShort x )
 969 {
 970 #  if defined(VG_BIGENDIAN)
 971    return x;
 972 #  else
 973    return
 974       (((x >> 8) & 0xFF) << 0) | (((x >> 0) & 0xFF) << 8);
 975 #  endif
 976 }
 977
 978
 979 /* The main function.
 980
 981    Supplied string contains either an ip address "192.168.0.1" or
 982    an ip address and port pair, "192.168.0.1:1500".  Parse these,
 983    and return:
 984      -1 if there is a parse error
 985      -2 if no parse error, but specified host:port cannot be opened
 986      the relevant file (socket) descriptor, otherwise.
 987  is used.
 988 */
 989 Int VG_(connect_via_socket)( const HChar* str )
 990 {
 991 #  if defined(VGO_linux) || defined(VGO_darwin) || defined(VGO_solaris)
 992    Int sd, res;
 993    struct vki_sockaddr_in servAddr;
 994    UInt   ip   = 0;
 995    UShort port = VG_CLO_DEFAULT_LOGPORT;
 996    Bool   ok   = parse_inet_addr_and_port(str, &ip, &port);
 997    if (!ok)
 998       return -1;
 999
1000    //if (0)
1001    //   VG_(printf)("ip = %d.%d.%d.%d, port %d\n",
1002    //               (ip >> 24) & 0xFF, (ip >> 16) & 0xFF,
1003    //               (ip >> 8) & 0xFF, ip & 0xFF,
1004    //               (UInt)port );
1005
1006    servAddr.sin_family = VKI_AF_INET;
1007    servAddr.sin_addr.s_addr = VG_(htonl)(ip);
1008    servAddr.sin_port = VG_(htons)(port);
1009
1010    /* create socket */
1011    sd = VG_(socket)(VKI_AF_INET, VKI_SOCK_STREAM, 0 /* IPPROTO_IP ? */);
1012    if (sd < 0) {
1013       /* this shouldn't happen ... nevertheless */
1014       return -2;
1015    }
1016
1017    /* connect to server */
1018    res = my_connect(sd, &servAddr, sizeof(servAddr));
1019    if (res < 0) {
1020       /* connection failed */
1021       return -2;
1022    }
1023
1024    return sd;
1025
1026 #  else
1027 #    error "Unknown OS"
1028 #  endif
1029 }
1030
1031
1032 /* Let d = one or more digits.  Accept either:
1033    d.d.d.d  or  d.d.d.d:d
1034 */
1035 static Int parse_inet_addr_and_port ( const HChar* str, UInt* ip_addr, UShort* port )
1036 {
1037 #  define GET_CH ((*str) ? (*str++) : 0)
1038    UInt ipa, i, j, c, any;
1039    ipa = 0;
1040    for (i = 0; i < 4; i++) {
1041       j = 0;
1042       any = 0;
1043       while (1) {
1044          c = GET_CH;
1045          if (c < '0' || c > '9') break;
1046          j = 10 * j + (int)(c - '0');
1047          any = 1;
1048       }
1049       if (any == 0 || j > 255) goto syntaxerr;
1050       ipa = (ipa << 8) + j;
1051       if (i <= 2 && c != '.') goto syntaxerr;
1052    }
1053    if (c == 0 || c == ':')
1054       *ip_addr = ipa;
1055    if (c == 0) goto ok;
1056    if (c != ':') goto syntaxerr;
1057    j = 0;
1058    any = 0;
1059    while (1) {
1060       c = GET_CH;
1061       if (c < '0' || c > '9') break;
1062       j = j * 10 + (int)(c - '0');
1063       any = 1;
1064       if (j > 65535) goto syntaxerr;
1065    }
1066    if (any == 0 || c != 0) goto syntaxerr;
1067    if (j < 1024) goto syntaxerr;
1068    *port = (UShort)j;
1069  ok:
1070    return 1;
1071  syntaxerr:
1072    return 0;
1073 #  undef GET_CH
1074 }
1075
1076 // GrP fixme safe_fd?
1077 Int VG_(socket) ( Int domain, Int type, Int protocol )
1078 {
1079 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
1080       || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
1081       || defined(VGP_s390x_linux)
1082    SysRes res;
1083    UWord  args[3];
1084    args[0] = domain;
1085    args[1] = type;
1086    args[2] = protocol;
1087    res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_SOCKET, (UWord)&args);
1088    return sr_isError(res) ? -1 : sr_Res(res);
1089
1090 #  elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \
1091         || defined(VGP_mips32_linux) || defined(VGP_mips64_linux) \
1092         || defined(VGP_arm64_linux) || defined(VGP_tilegx_linux)
1093    SysRes res;
1094    res = VG_(do_syscall3)(__NR_socket, domain, type, protocol );
1095    return sr_isError(res) ? -1 : sr_Res(res);
1096
1097 #  elif defined(VGO_darwin)
1098    SysRes res;
1099    res = VG_(do_syscall3)(__NR_socket, domain, type, protocol);
1100    if (!sr_isError(res)) {
1101        // Set SO_NOSIGPIPE so write() returns EPIPE instead of raising SIGPIPE
1102        Int optval = 1;
1103        SysRes res2;
1104        res2 = VG_(do_syscall5)(__NR_setsockopt, sr_Res(res), VKI_SOL_SOCKET,
1105                                VKI_SO_NOSIGPIPE, (UWord)&optval,
1106                                sizeof(optval));
1107        // ignore setsockopt() error
1108    }
1109    return sr_isError(res) ? -1 : sr_Res(res);
1110
1111 #  elif defined(VGO_solaris)
1112    /* XXX There doesn't seem to be an easy way to convince the send syscall to
1113       only return EPIPE instead of raising SIGPIPE. EPIPE is only returned if
1114       SM_KERNEL is set on the socket. Without serious hackery it looks we
1115       can't set this flag.
1116
1117       Should we wrap the send syscall below into sigprocmask calls to block
1118       SIGPIPE?
1119     */
1120    SysRes res;
1121    res = VG_(do_syscall5)(__NR_so_socket, domain, type, protocol,
1122                           0 /*devpath*/, VKI_SOV_DEFAULT /*version*/);
1123    return sr_isError(res) ? -1 : sr_Res(res);
1124
1125 #  else
1126 #    error "Unknown arch"
1127 #  endif
1128 }
1129
1130
1131 static
1132 Int my_connect ( Int sockfd, struct vki_sockaddr_in* serv_addr, Int addrlen )
1133 {
1134 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
1135       || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
1136       || defined(VGP_s390x_linux)
1137    SysRes res;
1138    UWord  args[3];
1139    args[0] = sockfd;
1140    args[1] = (UWord)serv_addr;
1141    args[2] = addrlen;
1142    res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_CONNECT, (UWord)&args);
1143    return sr_isError(res) ? -1 : sr_Res(res);
1144
1145 #  elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \
1146         || defined(VGP_mips32_linux) || defined(VGP_mips64_linux) \
1147         || defined(VGP_arm64_linux) || defined(VGP_tilegx_linux)
1148    SysRes res;
1149    res = VG_(do_syscall3)(__NR_connect, sockfd, (UWord)serv_addr, addrlen);
1150    return sr_isError(res) ? -1 : sr_Res(res);
1151
1152 #  elif defined(VGO_darwin)
1153    SysRes res;
1154    res = VG_(do_syscall3)(__NR_connect_nocancel,
1155                           sockfd, (UWord)serv_addr, addrlen);
1156    return sr_isError(res) ? -1 : sr_Res(res);
1157
1158 #  elif defined(VGO_solaris)
1159    SysRes res;
1160    res = VG_(do_syscall4)(__NR_connect, sockfd, (UWord)serv_addr, addrlen,
1161                           VKI_SOV_DEFAULT /*version*/);
1162    return sr_isError(res) ? -1 : sr_Res(res);
1163
1164 #  else
1165 #    error "Unknown arch"
1166 #  endif
1167 }
1168
1169 Int VG_(write_socket)( Int sd, const void *msg, Int count )
1170 {
1171    /* This is actually send(). */
1172
1173    /* For Linux, VKI_MSG_NOSIGNAL is a request not to send SIGPIPE on
1174       errors on stream oriented sockets when the other end breaks the
1175       connection. The EPIPE error is still returned.
1176
1177       For Darwin, VG_(socket)() sets SO_NOSIGPIPE to get EPIPE instead of
1178       SIGPIPE */
1179
1180 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
1181       || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
1182       || defined(VGP_s390x_linux)
1183    SysRes res;
1184    UWord  args[4];
1185    args[0] = sd;
1186    args[1] = (UWord)msg;
1187    args[2] = count;
1188    args[3] = VKI_MSG_NOSIGNAL;
1189    res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_SEND, (UWord)&args);
1190    return sr_isError(res) ? -1 : sr_Res(res);
1191
1192 #  elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \
1193         || defined(VGP_mips32_linux) || defined(VGP_mips64_linux) \
1194         || defined(VGP_arm64_linux) || defined(VGP_tilegx_linux)
1195    SysRes res;
1196    res = VG_(do_syscall6)(__NR_sendto, sd, (UWord)msg,
1197                                        count, VKI_MSG_NOSIGNAL, 0,0);
1198    return sr_isError(res) ? -1 : sr_Res(res);
1199
1200 #  elif defined(VGP_x86_darwin) || defined(VGP_amd64_darwin)
1201    SysRes res;
1202    res = VG_(do_syscall3)(__NR_write_nocancel, sd, (UWord)msg, count);
1203    return sr_isError(res) ? -1 : sr_Res(res);
1204
1205 #  elif defined(VGO_solaris)
1206    SysRes res;
1207    res = VG_(do_syscall4)(__NR_send, sd, (UWord)msg, count, 0 /*flags*/);
1208    return sr_isError(res) ? -1 : sr_Res(res);
1209
1210 #  else
1211 #    error "Unknown platform"
1212 #  endif
1213 }
1214
1215 Int VG_(getsockname) ( Int sd, struct vki_sockaddr *name, Int *namelen)
1216 {
1217 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
1218       || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
1219       || defined(VGP_s390x_linux) \
1220       || defined(VGP_mips32_linux)
1221    SysRes res;
1222    UWord  args[3];
1223    args[0] = sd;
1224    args[1] = (UWord)name;
1225    args[2] = (UWord)namelen;
1226    res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_GETSOCKNAME, (UWord)&args);
1227    return sr_isError(res) ? -1 : sr_Res(res);
1228
1229 #  elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \
1230         || defined(VGP_mips64_linux) || defined(VGP_arm64_linux) \
1231         || defined(VGP_tilegx_linux)
1232    SysRes res;
1233    res = VG_(do_syscall3)( __NR_getsockname,
1234                            (UWord)sd, (UWord)name, (UWord)namelen );
1235    return sr_isError(res) ? -1 : sr_Res(res);
1236
1237 #  elif defined(VGO_darwin)
1238    SysRes res;
1239    res = VG_(do_syscall3)( __NR_getsockname,
1240                            (UWord)sd, (UWord)name, (UWord)namelen );
1241    return sr_isError(res) ? -1 : sr_Res(res);
1242
1243 #  elif defined(VGO_solaris)
1244    SysRes res;
1245    res = VG_(do_syscall4)(__NR_getsockname, sd, (UWord)name, (UWord)namelen,
1246                           VKI_SOV_DEFAULT /*version*/);
1247    return sr_isError(res) ? -1 : sr_Res(res);
1248
1249 #  else
1250 #    error "Unknown platform"
1251 #  endif
1252 }
1253
1254 Int VG_(getpeername) ( Int sd, struct vki_sockaddr *name, Int *namelen)
1255 {
1256 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
1257       || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
1258       || defined(VGP_s390x_linux) \
1259       || defined(VGP_mips32_linux)
1260    SysRes res;
1261    UWord  args[3];
1262    args[0] = sd;
1263    args[1] = (UWord)name;
1264    args[2] = (UWord)namelen;
1265    res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_GETPEERNAME, (UWord)&args);
1266    return sr_isError(res) ? -1 : sr_Res(res);
1267
1268 #  elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \
1269         || defined(VGP_mips64_linux) || defined(VGP_arm64_linux) \
1270         || defined(VGP_tilegx_linux)
1271    SysRes res;
1272    res = VG_(do_syscall3)( __NR_getpeername,
1273                            (UWord)sd, (UWord)name, (UWord)namelen );
1274    return sr_isError(res) ? -1 : sr_Res(res);
1275
1276 #  elif defined(VGO_darwin)
1277    SysRes res;
1278    res = VG_(do_syscall3)( __NR_getpeername,
1279                            (UWord)sd, (UWord)name, (UWord)namelen );
1280    return sr_isError(res) ? -1 : sr_Res(res);
1281
1282 #  elif defined(VGO_solaris)
1283    SysRes res;
1284    res = VG_(do_syscall4)(__NR_getpeername, sd, (UWord)name, (UWord)namelen,
1285                           VKI_SOV_DEFAULT /*version*/);
1286    return sr_isError(res) ? -1 : sr_Res(res);
1287
1288 #  else
1289 #    error "Unknown platform"
1290 #  endif
1291 }
1292
1293 Int VG_(getsockopt) ( Int sd, Int level, Int optname, void *optval,
1294                       Int *optlen)
1295 {
1296 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
1297       || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
1298       || defined(VGP_s390x_linux)
1299    SysRes res;
1300    UWord  args[5];
1301    args[0] = sd;
1302    args[1] = level;
1303    args[2] = optname;
1304    args[3] = (UWord)optval;
1305    args[4] = (UWord)optlen;
1306    res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_GETSOCKOPT, (UWord)&args);
1307    return sr_isError(res) ? -1 : sr_Res(res);
1308
1309 #  elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \
1310         || defined(VGP_mips32_linux) || defined(VGP_mips64_linux) \
1311         || defined(VGP_arm64_linux) || defined(VGP_tilegx_linux)
1312    SysRes res;
1313    res = VG_(do_syscall5)( __NR_getsockopt,
1314                            (UWord)sd, (UWord)level, (UWord)optname,
1315                            (UWord)optval, (UWord)optlen );
1316    return sr_isError(res) ? -1 : sr_Res(res);
1317
1318 #  elif defined(VGO_darwin)
1319    SysRes res;
1320    res = VG_(do_syscall5)( __NR_getsockopt,
1321                            (UWord)sd, (UWord)level, (UWord)optname,
1322                            (UWord)optval, (UWord)optlen );
1323    return sr_isError(res) ? -1 : sr_Res(res);
1324
1325 #  elif defined(VGO_solaris)
1326    SysRes res;
1327    res = VG_(do_syscall6)(__NR_getsockopt, sd, level, optname, (UWord)optval,
1328                           (UWord)optlen, VKI_SOV_DEFAULT /*version*/);
1329    return sr_isError(res) ? -1 : sr_Res(res);
1330
1331 #  else
1332 #    error "Unknown platform"
1333 #  endif
1334 }
1335
1336
1337 Int VG_(setsockopt) ( Int sd, Int level, Int optname, void *optval,
1338                       Int optlen)
1339 {
1340 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
1341       || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
1342       || defined(VGP_s390x_linux)
1343    SysRes res;
1344    UWord  args[5];
1345    args[0] = sd;
1346    args[1] = level;
1347    args[2] = optname;
1348    args[3] = (UWord)optval;
1349    args[4] = (UWord)optlen;
1350    res = VG_(do_syscall2)(__NR_socketcall, VKI_SYS_SETSOCKOPT, (UWord)&args);
1351    return sr_isError(res) ? -1 : sr_Res(res);
1352
1353 #  elif defined(VGP_amd64_linux) || defined(VGP_arm_linux) \
1354         || defined(VGP_mips32_linux) || defined(VGP_mips64_linux) \
1355         || defined(VGP_arm64_linux) || defined(VGP_tilegx_linux)
1356    SysRes res;
1357    res = VG_(do_syscall5)( __NR_setsockopt,
1358                            (UWord)sd, (UWord)level, (UWord)optname,
1359                            (UWord)optval, (UWord)optlen );
1360    return sr_isError(res) ? -1 : sr_Res(res);
1361
1362 #  elif defined(VGO_darwin)
1363    SysRes res;
1364    res = VG_(do_syscall5)( __NR_setsockopt,
1365                            (UWord)sd, (UWord)level, (UWord)optname,
1366                            (UWord)optval, (UWord)optlen );
1367    return sr_isError(res) ? -1 : sr_Res(res);
1368
1369 #  elif defined(VGO_solaris)
1370    SysRes res;
1371    res = VG_(do_syscall6)( __NR_setsockopt,
1372                            (UWord)sd, (UWord)level, (UWord)optname,
1373                            (UWord)optval, (UWord)optlen,
1374                            VKI_SOV_DEFAULT /*version*/ );
1375    return sr_isError(res) ? -1 : sr_Res(res);
1376
1377 #  else
1378 #    error "Unknown platform"
1379 #  endif
1380 }
1381
1382
1383 const HChar *VG_(basename)(const HChar *path)
1384 {
1385    static HChar *buf = NULL;
1386    static SizeT  buf_len = 0;
1387    const HChar *p, *end;
1388
1389    if (path == NULL  ||
1390        0 == VG_(strcmp)(path, ""))
1391    {
1392       return ".";
1393    }
1394
1395    p = path + VG_(strlen)(path);
1396    while (p > path  &&  *p == '/') {
1397       // skip all trailing '/'
1398       p--;
1399    }
1400
1401    if (p == path  &&  *p == '/') return "/"; // all slashes
1402
1403    end = p;
1404
1405    while (p > path  &&  *p != '/') {
1406       // now skip non '/'
1407       p--;
1408    }
1409
1410    if (*p == '/') p++;
1411
1412    SizeT need = end-p+1 + 1;
1413    if (need > buf_len) {
1414       buf_len = (buf_len == 0) ? 500 : need;
1415       buf = VG_(realloc)("basename", buf, buf_len);
1416    }
1417    VG_(strncpy)(buf, p, end-p+1);
1418    buf[end-p+1] = '\0';
1419
1420    return buf;
1421 }
1422
1423
1424 const HChar *VG_(dirname)(const HChar *path)
1425 {
1426    static HChar *buf = NULL;
1427    static SizeT  buf_len = 0;
1428
1429    const HChar *p;
1430
1431    if (path == NULL  ||
1432        0 == VG_(strcmp)(path, "")  ||
1433        0 == VG_(strcmp)(path, "/"))
1434    {
1435       return ".";
1436    }
1437
1438    p = path + VG_(strlen)(path);
1439    while (p > path  &&  *p == '/') {
1440       // skip all trailing '/'
1441       p--;
1442    }
1443
1444    while (p > path  &&  *p != '/') {
1445       // now skip non '/'
1446       p--;
1447    }
1448
1449    if (p == path) {
1450       if (*p == '/') return "/"; // all slashes
1451       else return "."; // no slashes
1452    }
1453
1454    while (p > path  &&  *p == '/') {
1455       // skip '/' again
1456       p--;
1457    }
1458
1459    SizeT need = p-path+1 + 1;
1460    if (need > buf_len) {
1461       buf_len = (buf_len == 0) ? 500 : need;
1462       buf = VG_(realloc)("dirname", buf, buf_len);
1463    }
1464    VG_(strncpy)(buf, path, p-path+1);
1465    buf[p-path+1] = '\0';
1466
1467    return buf;
1468 }
1469
1470
1471 /*--------------------------------------------------------------------*/
1472 /*--- end                                                          ---*/
1473 /*--------------------------------------------------------------------*/