Home | History | Annotate | Download | only in tests 
      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
    470