third_party/android_crazy_linker/src/tests/test_util.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // A set of common helper functions used by crazy_linker tests.
   6 // IMPORTANT: ALL FUNCTIONS HERE ARE INLINED. This avoids adding a
   7 // dependency on another source file for all tests that include this
   8 // header.
   9
  10 #ifndef TEST_UTIL_H
  11 #define TEST_UTIL_H
  12
  13 #include <crazy_linker.h>
  14
  15 #include <dirent.h>
  16 #include <errno.h>
  17 #include <limits.h>
  18 #include <stdarg.h>
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <sys/mman.h>
  22 #include <sys/socket.h>
  23 #include <sys/stat.h>
  24 #include <sys/uio.h>
  25 #include <unistd.h>
  26 #ifndef __STDC_FORMAT_MACROS
  27 #define __STDC_FORMAT_MACROS // to get PRI and SCN in 32-bit inttypes.h
  28 #endif
  29 #include <inttypes.h>
  30
  31 namespace {
  32
  33 // Print an error message and exit the process.
  34 // Message must be terminated by a newline.
  35 inline void Panic(const char* fmt, ...) {
  36   va_list args;
  37   fprintf(stderr, "PANIC: ");
  38   va_start(args, fmt);
  39   vfprintf(stderr, fmt, args);
  40   va_end(args);
  41   exit(1);
  42 }
  43
  44 // Print an error message, the errno message, then exit the process.
  45 // Message must not be terminated by a newline.
  46 inline void PanicErrno(const char* fmt, ...) {
  47   int old_errno = errno;
  48   va_list args;
  49   fprintf(stderr, "PANIC: ");
  50   va_start(args, fmt);
  51   vfprintf(stderr, fmt, args);
  52   va_end(args);
  53   fprintf(stderr, ": %s\n", strerror(old_errno));
  54   exit(1);
  55 }
  56
  57 // Simple string class.
  58 class String {
  59  public:
  60   String() : str_(NULL), len_(0) {}
  61
  62   String(const String& other) { String(other.str_, other.len_); }
  63
  64   String(const char* str) { String(str, strlen(str)); }
  65
  66   String(const char* str, size_t len) : str_(NULL), len_(0) {
  67     Append(str, len);
  68   }
  69
  70   ~String() {
  71     if (str_) {
  72       free(str_);
  73       str_ = NULL;
  74     }
  75   }
  76
  77   String& operator+=(const char* str) {
  78     Append(str, strlen(str));
  79     return *this;
  80   }
  81
  82   String& operator+=(const String& other) {
  83     Append(other.str_, other.len_);
  84     return *this;
  85   }
  86
  87   String& operator+=(char ch) {
  88     Append(&ch, 1);
  89     return *this;
  90   }
  91
  92   const char* c_str() const { return len_ ? str_ : ""; }
  93   char* ptr() { return str_; }
  94   size_t size() const { return len_; }
  95
  96   void Append(const char* str, size_t len) {
  97     size_t old_len = len_;
  98     Resize(len_ + len);
  99     memcpy(str_ + old_len, str, len);
 100   }
 101
 102   void Resize(size_t len) {
 103     str_ = reinterpret_cast<char*>(realloc(str_, len + 1));
 104     if (len > len_)
 105       memset(str_ + len_, '\0', len - len_);
 106     str_[len] = '\0';
 107     len_ = len;
 108   }
 109
 110   void Format(const char* fmt, ...) {
 111     va_list args;
 112     va_start(args, fmt);
 113     Resize(128);
 114     for (;;) {
 115       va_list args2;
 116       va_copy(args2, args);
 117       int ret = vsnprintf(str_, len_ + 1, fmt, args2);
 118       va_end(args2);
 119       if (ret < static_cast<int>(len_ + 1))
 120         break;
 121
 122       Resize(len_ * 2);
 123     }
 124   }
 125
 126  private:
 127   char* str_;
 128   size_t len_;
 129 };
 130
 131 // Helper class to create a temporary directory that gets deleted on scope exit,
 132 // as well as all regular files it contains.
 133 class TempDirectory {
 134  public:
 135   TempDirectory() {
 136     snprintf(path_, sizeof path_, "/data/local/tmp/temp-XXXXXX");
 137     if (!mktemp(path_))
 138       Panic("Could not create temporary directory name: %s\n", strerror(errno));
 139     if (mkdir(path_, 0700) < 0)
 140       Panic("Could not create temporary directory %s: %s\n", strerror(errno));
 141   }
 142
 143   ~TempDirectory() {
 144     // Remove any file in this directory.
 145     DIR* d = opendir(path_);
 146     if (!d)
 147       Panic("Could not open directory %s: %s\n", strerror(errno));
 148
 149     struct dirent* entry;
 150     while ((entry = readdir(d)) != NULL) {
 151       if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, ".."))
 152         continue;
 153       String file_path;
 154       file_path.Format("%s/%s", path_, entry->d_name);
 155       if (unlink(file_path.c_str()) < 0)
 156         Panic("Could not remove %s: %s\n", file_path.c_str(), strerror(errno));
 157     }
 158     closedir(d);
 159
 160     if (rmdir(path_) < 0)
 161       Panic("Could not remove dir %s: %s\n", path_, strerror(errno));
 162   }
 163
 164   const char* path() const { return path_; }
 165
 166  private:
 167   char path_[PATH_MAX];
 168 };
 169
 170 // Scoped FILE* class. Always closed on destruction.
 171 class ScopedFILE {
 172  public:
 173   ScopedFILE() : file_(NULL) {}
 174
 175   ~ScopedFILE() {
 176     if (file_) {
 177       fclose(file_);
 178       file_ = NULL;
 179     }
 180   }
 181
 182   void Open(const char* path, const char* mode) {
 183     file_ = fopen(path, mode);
 184     if (!file_)
 185       Panic("Could not open file for reading: %s: %s\n", path, strerror(errno));
 186   }
 187
 188   FILE* file() const { return file_; }
 189
 190  private:
 191   FILE* file_;
 192 };
 193
 194 // Retrieve current executable path as a String.
 195 inline String GetCurrentExecutable() {
 196   String path;
 197   path.Resize(PATH_MAX);
 198   ssize_t ret =
 199       TEMP_FAILURE_RETRY(readlink("/proc/self/exe", path.ptr(), path.size()));
 200   if (ret < 0)
 201     Panic("Could not read /proc/self/exe: %s\n", strerror(errno));
 202
 203   return path;
 204 }
 205
 206 // Retrieve current executable directory as a String.
 207 inline String GetCurrentExecutableDirectory() {
 208   String path = GetCurrentExecutable();
 209   // Find basename.
 210   const char* p = reinterpret_cast<const char*>(strrchr(path.c_str(), '/'));
 211   if (p == NULL)
 212     Panic("Current executable does not have directory root?: %s\n",
 213           path.c_str());
 214
 215   path.Resize(p - path.c_str());
 216   return path;
 217 }
 218
 219 // Copy a file named |src_file_name| in directory |src_file_dir| into
 220 // a file named |dst_file_name| in directory |dst_file_dir|. Panics on error.
 221 inline void CopyFile(const char* src_file_name,
 222                      const char* src_file_dir,
 223                      const char* dst_file_name,
 224                      const char* dst_file_dir) {
 225   String src_path;
 226   src_path.Format("%s/%s", src_file_dir, src_file_name);
 227
 228   ScopedFILE src_file;
 229   src_file.Open(src_path.c_str(), "rb");
 230
 231   String dst_path;
 232   dst_path.Format("%s/%s", dst_file_dir, dst_file_name);
 233   ScopedFILE dst_file;
 234   dst_file.Open(dst_path.c_str(), "wb");
 235
 236   char buffer[8192];
 237   for (;;) {
 238     size_t read = fread(buffer, 1, sizeof buffer, src_file.file());
 239     if (read > 0) {
 240       size_t written = fwrite(buffer, 1, read, dst_file.file());
 241       if (written != read)
 242         Panic("Wrote %d bytes instead of %d into %s\n",
 243               written,
 244               read,
 245               dst_path.c_str());
 246     }
 247     if (read < sizeof buffer)
 248       break;
 249   }
 250 }
 251
 252 // Send a file descriptor |fd| through |socket|.
 253 // Return 0 on success, -1/errno on failure.
 254 inline int SendFd(int socket, int fd) {
 255   struct iovec iov;
 256
 257   char buffer[1];
 258   buffer[0] = 0;
 259
 260   iov.iov_base = buffer;
 261   iov.iov_len = 1;
 262
 263   struct msghdr msg;
 264   struct cmsghdr* cmsg;
 265   char cms[CMSG_SPACE(sizeof(int))];
 266
 267   ::memset(&msg, 0, sizeof(msg));
 268   msg.msg_iov = &iov;
 269   msg.msg_iovlen = 1;
 270   msg.msg_control = reinterpret_cast<caddr_t>(cms);
 271   msg.msg_controllen = CMSG_LEN(sizeof(int));
 272
 273   cmsg = CMSG_FIRSTHDR(&msg);
 274   cmsg->cmsg_len = CMSG_LEN(sizeof(int));
 275   cmsg->cmsg_level = SOL_SOCKET;
 276   cmsg->cmsg_type = SCM_RIGHTS;
 277   ::memcpy(CMSG_DATA(cmsg), &fd, sizeof(int));
 278
 279   int ret = sendmsg(socket, &msg, 0);
 280   if (ret < 0)
 281     return -1;
 282
 283   if (ret != iov.iov_len) {
 284     errno = EIO;
 285     return -1;
 286   }
 287
 288   return 0;
 289 }
 290
 291 inline int ReceiveFd(int socket, int* fd) {
 292   char buffer[1];
 293   struct iovec iov;
 294
 295   iov.iov_base = buffer;
 296   iov.iov_len = 1;
 297
 298   struct msghdr msg;
 299   struct cmsghdr* cmsg;
 300   char cms[CMSG_SPACE(sizeof(int))];
 301
 302   ::memset(&msg, 0, sizeof msg);
 303   msg.msg_name = 0;
 304   msg.msg_namelen = 0;
 305   msg.msg_iov = &iov;
 306   msg.msg_iovlen = 1;
 307
 308   msg.msg_control = reinterpret_cast<caddr_t>(cms);
 309   msg.msg_controllen = sizeof(cms);
 310
 311   int ret = recvmsg(socket, &msg, 0);
 312   if (ret < 0)
 313     return -1;
 314   if (ret == 0) {
 315     errno = EIO;
 316     return -1;
 317   }
 318
 319   cmsg = CMSG_FIRSTHDR(&msg);
 320   ::memcpy(fd, CMSG_DATA(cmsg), sizeof(int));
 321   return 0;
 322 }
 323
 324 // Check that there are exactly |expected_count| memory mappings in
 325 // /proc/self/maps that point to a RELRO ashmem region.
 326 inline void CheckRelroMaps(int expected_count) {
 327   printf("Checking for %d RELROs in /proc/self/maps\n", expected_count);
 328
 329   FILE* file = fopen("/proc/self/maps", "rb");
 330   if (!file)
 331     Panic("Could not open /proc/self/maps (pid %d): %s\n",
 332           getpid(),
 333           strerror(errno));
 334
 335   char line[512];
 336   int count_relros = 0;
 337   printf("proc/%d/maps:\n", getpid());
 338   while (fgets(line, sizeof line, file)) {
 339     if (strstr(line, "with_relro")) {
 340       // The supported library names are "lib<name>_with_relro.so".
 341       printf("%s", line);
 342       if (strstr(line, "/dev/ashmem/RELRO:")) {
 343         count_relros++;
 344         // Check that they are read-only mappings.
 345         if (!strstr(line, " r--"))
 346           Panic("Shared RELRO mapping is not readonly!\n");
 347         // Check that they can't be remapped read-write.
 348         uint64_t vma_start, vma_end;
 349         if (sscanf(line, "%" SCNx64 "-%" SCNx64, &vma_start, &vma_end) != 2)
 350           Panic("Could not parse VM address range!\n");
 351         int ret = ::mprotect(
 352             (void*)vma_start, vma_end - vma_start, PROT_READ | PROT_WRITE);
 353         if (ret == 0)
 354           Panic("Could remap shared RELRO as writable, should not happen!\n");
 355
 356         if (errno != EACCES)
 357           Panic("remapping shared RELRO to writable failed with: %s\n",
 358                 strerror(errno));
 359       }
 360     }
 361   }
 362   fclose(file);
 363
 364   if (count_relros != expected_count)
 365     Panic(
 366         "Invalid shared RELRO sections in /proc/self/maps: %d"
 367         " (expected %d)\n",
 368         count_relros,
 369         expected_count);
 370
 371   printf("RELRO count check ok!\n");
 372 }
 373
 374 struct RelroInfo {
 375   size_t start;
 376   size_t size;
 377   int fd;
 378 };
 379
 380 struct RelroLibrary {
 381   const char* name;
 382   crazy_library_t* library;
 383   RelroInfo relro;
 384
 385   void Init(const char* name, crazy_context_t* context) {
 386     printf("Loading %s\n", name);
 387     this->name = name;
 388     if (!crazy_library_open(&this->library, name, context)) {
 389       Panic("Could not open %s: %s\n", name, crazy_context_get_error(context));
 390     }
 391   }
 392
 393   void Close() { crazy_library_close(this->library); }
 394
 395   void CreateSharedRelro(crazy_context_t* context, size_t load_address) {
 396     if (!crazy_library_create_shared_relro(this->library,
 397                                            context,
 398                                            load_address,
 399                                            &this->relro.start,
 400                                            &this->relro.size,
 401                                            &this->relro.fd)) {
 402       Panic("Could not create shared RELRO for %s: %s",
 403             this->name,
 404             crazy_context_get_error(context));
 405     }
 406
 407     printf("Parent %s relro info relro_start=%p relro_size=%p relro_fd=%d\n",
 408            this->name,
 409            (void*)this->relro.start,
 410            (void*)this->relro.size,
 411            this->relro.fd);
 412   }
 413
 414   void EnableSharedRelro(crazy_context_t* context) {
 415     CreateSharedRelro(context, 0);
 416     UseSharedRelro(context);
 417   }
 418
 419   void SendRelroInfo(int fd) {
 420     if (SendFd(fd, this->relro.fd) < 0) {
 421       Panic("Could not send %s RELRO fd: %s", this->name, strerror(errno));
 422     }
 423
 424     int ret =
 425         TEMP_FAILURE_RETRY(::write(fd, &this->relro, sizeof(this->relro)));
 426     if (ret != static_cast<int>(sizeof(this->relro))) {
 427       Panic("Parent could not send %s RELRO info: %s",
 428             this->name,
 429             strerror(errno));
 430     }
 431   }
 432
 433   void ReceiveRelroInfo(int fd) {
 434     // Receive relro information from parent.
 435     int relro_fd = -1;
 436     if (ReceiveFd(fd, &relro_fd) < 0) {
 437       Panic("Could not receive %s relro descriptor from parent", this->name);
 438     }
 439
 440     printf("Child received %s relro fd %d\n", this->name, relro_fd);
 441
 442     int ret = TEMP_FAILURE_RETRY(::read(fd, &this->relro, sizeof(this->relro)));
 443     if (ret != static_cast<int>(sizeof(this->relro))) {
 444       Panic("Could not receive %s relro information from parent", this->name);
 445     }
 446
 447     this->relro.fd = relro_fd;
 448     printf("Child received %s relro start=%p size=%p\n",
 449            this->name,
 450            (void*)this->relro.start,
 451            (void*)this->relro.size);
 452   }
 453
 454   void UseSharedRelro(crazy_context_t* context) {
 455     if (!crazy_library_use_shared_relro(this->library,
 456                                         context,
 457                                         this->relro.start,
 458                                         this->relro.size,
 459                                         this->relro.fd)) {
 460       Panic("Could not use %s shared RELRO: %s\n",
 461             this->name,
 462             crazy_context_get_error(context));
 463     }
 464   }
 465 };
 466
 467 }  // namespace
 468
 469 #endif  // TEST_UTIL_H