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