Home | History | Annotate | Download | only in tests 
      1 // Copyright (c) 2011, Google Inc.
      2 // All rights reserved.
      3 //
      4 // Redistribution and use in source and binary forms, with or without
      5 // modification, are permitted provided that the following conditions are
      6 // met:
      7 //
      8 //     * Redistributions of source code must retain the above copyright
      9 // notice, this list of conditions and the following disclaimer.
     10 //     * Redistributions in binary form must reproduce the above
     11 // copyright notice, this list of conditions and the following disclaimer
     12 // in the documentation and/or other materials provided with the
     13 // distribution.
     14 //     * Neither the name of Google Inc. nor the names of its
     15 // contributors may be used to endorse or promote products derived from
     16 // this software without specific prior written permission.
     17 //
     18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     29 
     30 // file_utils.cc: Implement utility functions for file manipulation.
     31 // See file_utils.h for details.
     32 
     33 #include <fcntl.h>
     34 #include <stdio.h>
     35 #include <string.h>
     36 #include <sys/stat.h>
     37 #include <unistd.h>
     38 
     39 #include "common/linux/eintr_wrapper.h"
     40 #include "common/tests/file_utils.h"
     41 
     42 namespace google_breakpad {
     43 
     44 bool CopyFile(const char* from_path, const char* to_path) {
     45   int infile = HANDLE_EINTR(open(from_path, O_RDONLY));
     46   if (infile < 0) {
     47     perror("open");
     48     return false;
     49   }
     50 
     51   int outfile = HANDLE_EINTR(creat(to_path, 0666));
     52   if (outfile < 0) {
     53     perror("creat");
     54     if (IGNORE_EINTR(close(infile)) < 0) {
     55       perror("close");
     56     }
     57     return false;
     58   }
     59 
     60   char buffer[1024];
     61   bool result = true;
     62 
     63   while (result) {
     64     ssize_t bytes_read = HANDLE_EINTR(read(infile, buffer, sizeof(buffer)));
     65     if (bytes_read < 0) {
     66       perror("read");
     67       result = false;
     68       break;
     69     }
     70     if (bytes_read == 0)
     71       break;
     72     ssize_t bytes_written_per_read = 0;
     73     do {
     74       ssize_t bytes_written_partial = HANDLE_EINTR(write(
     75           outfile,
     76           &buffer[bytes_written_per_read],
     77           bytes_read - bytes_written_per_read));
     78       if (bytes_written_partial < 0) {
     79         perror("write");
     80         result = false;
     81         break;
     82       }
     83       bytes_written_per_read += bytes_written_partial;
     84     } while (bytes_written_per_read < bytes_read);
     85   }
     86 
     87   if (IGNORE_EINTR(close(infile)) == -1) {
     88     perror("close");
     89     result = false;
     90   }
     91   if (IGNORE_EINTR(close(outfile)) == -1) {
     92     perror("close");
     93     result = false;
     94   }
     95 
     96   return result;
     97 }
     98 
     99 bool ReadFile(const char* path, void* buffer, ssize_t* buffer_size) {
    100   int fd = HANDLE_EINTR(open(path, O_RDONLY));
    101   if (fd == -1) {
    102     perror("open");
    103     return false;
    104   }
    105 
    106   bool ok = true;
    107   if (buffer && buffer_size && *buffer_size > 0) {
    108     memset(buffer, 0, sizeof(*buffer_size));
    109     *buffer_size = HANDLE_EINTR(read(fd, buffer, *buffer_size));
    110     if (*buffer_size == -1) {
    111       perror("read");
    112       ok = false;
    113     }
    114   }
    115   if (IGNORE_EINTR(close(fd)) == -1) {
    116     perror("close");
    117     ok = false;
    118   }
    119   return ok;
    120 }
    121 
    122 bool WriteFile(const char* path, const void* buffer, size_t buffer_size) {
    123   int fd = HANDLE_EINTR(open(path, O_CREAT | O_TRUNC | O_WRONLY, S_IRWXU));
    124   if (fd == -1) {
    125     perror("open");
    126     return false;
    127   }
    128 
    129   bool ok = true;
    130   if (buffer) {
    131     size_t bytes_written_total = 0;
    132     ssize_t bytes_written_partial = 0;
    133     const char* data = reinterpret_cast<const char*>(buffer);
    134     while (bytes_written_total < buffer_size) {
    135       bytes_written_partial =
    136           HANDLE_EINTR(write(fd, data + bytes_written_total,
    137                              buffer_size - bytes_written_total));
    138       if (bytes_written_partial < 0) {
    139         perror("write");
    140         ok = false;
    141         break;
    142       }
    143       bytes_written_total += bytes_written_partial;
    144     }
    145   }
    146   if (IGNORE_EINTR(close(fd)) == -1) {
    147     perror("close");
    148     ok = false;
    149   }
    150   return ok;
    151 }
    152 
    153 }  // namespace google_breakpad
    154