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
42namespace google_breakpad {
43
44bool 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
99bool 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
122bool 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