discover/sysinfo: Add system_info_reinit()
[petitboot] / lib / file / file.c
1 /*
2  *  Copyright (C) 2013 Jeremy Kerr <jk@ozlabs.org>
3  *  Copyright (C) 2016 Raptor Engineering, LLC
4  *
5  *  This program is free software; you can redistribute it and/or modify
6  *  it under the terms of the GNU General Public License as published by
7  *  the Free Software Foundation; version 2 of the License.
8  *
9  *  This program is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  *  GNU General Public License for more details.
13  *
14  *  You should have received a copy of the GNU General Public License
15  *  along with this program; if not, write to the Free Software
16  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17  */
18
19 #include <fcntl.h>
20 #include <unistd.h>
21 #include <stdlib.h>
22 #include <errno.h>
23 #include <sys/stat.h>
24 #include <sys/types.h>
25
26 #include <talloc/talloc.h>
27 #include <log/log.h>
28
29 #include "file.h"
30
31 #define MAX_FILENAME_SIZE       8192
32 #define FILE_XFER_BUFFER_SIZE   8192
33
34 static const int max_file_size = 1024 * 1024;
35
36 int copy_file_secure_dest(void *ctx, const char *source_file,
37                 char **destination_file)
38 {
39         char readlink_buffer[MAX_FILENAME_SIZE + 1];
40         char dest_filename[MAX_FILENAME_SIZE] = "";
41         char template[] = "/tmp/petitbootXXXXXX";
42         FILE *destination_handle, *source_handle;
43         int destination_fd, result = 0;
44         unsigned char *buffer;
45         ssize_t r;
46         size_t l1;
47         mode_t oldmask;
48
49         source_handle = fopen(source_file, "r");
50         if (!source_handle) {
51                 pb_log("%s: unable to open source file '%s': %m\n",
52                         __func__, source_file);
53                         return -1;
54         }
55
56         oldmask = umask(0644);
57         destination_fd = mkstemp(template);
58         umask(oldmask);
59         if (destination_fd < 0) {
60                 pb_log("%s: unable to create temp file, %m\n", __func__);
61                 fclose(source_handle);
62                 return -1;
63         }
64         destination_handle = fdopen(destination_fd, "w");
65         if (!destination_handle) {
66                 pb_log("%s: unable to open destination file, %m\n", __func__);
67                 fclose(source_handle);
68                 close(destination_fd);
69                 return -1;
70         }
71
72         buffer = talloc_array(ctx, unsigned char, FILE_XFER_BUFFER_SIZE);
73         if (!buffer) {
74                 pb_log("%s: failed: unable to allocate file transfer buffer\n",
75                         __func__);
76                 result = -1;
77                 goto out;
78         }
79
80         /* Copy data */
81         while ((l1 = fread(buffer, 1, FILE_XFER_BUFFER_SIZE, source_handle)) > 0) {
82                 size_t l2 = fwrite(buffer, 1, l1, destination_handle);
83                 if (l2 < l1) {
84                         if (ferror(destination_handle)) {
85                                 /* General error */
86                                 result = -1;
87                                 pb_log("%s: failed: unknown fault\n", __func__);
88                         }
89                         else {
90                                 /* No space on destination device */
91                                 result = -1;
92                                 pb_log("%s: failed: temporary storage full\n",
93                                         __func__);
94                         }
95                         break;
96                 }
97         }
98
99         if (result) {
100                 *destination_file = NULL;
101                 goto out;
102         }
103
104         snprintf(readlink_buffer, MAX_FILENAME_SIZE, "/proc/self/fd/%d",
105                 destination_fd);
106         r = readlink(readlink_buffer, dest_filename, MAX_FILENAME_SIZE);
107         if (r < 0) {
108                 /* readlink failed */
109                 result = -1;
110                 r = 0;
111                 pb_log("%s: failed: unable to obtain temporary filename\n",
112                         __func__);
113         }
114         dest_filename[r] = '\0';
115
116         *destination_file = talloc_strdup(ctx, dest_filename);
117 out:
118         talloc_free(buffer);
119         fclose(source_handle);
120         fclose(destination_handle);
121         close(destination_fd);
122         return result;
123 }
124
125 int read_file(void *ctx, const char *filename, char **bufp, int *lenp)
126 {
127         struct stat statbuf;
128         int rc, fd, i, len;
129         char *buf;
130
131         fd = open(filename, O_RDONLY);
132         if (fd < 0)
133                 return -1;
134
135         rc = fstat(fd, &statbuf);
136         if (rc < 0)
137                 goto err_close;
138
139         len = statbuf.st_size;
140         if (len > max_file_size)
141                 goto err_close;
142
143         buf = talloc_array(ctx, char, len + 1);
144         if (!buf)
145                 goto err_close;
146
147         for (i = 0; i < len; i += rc) {
148                 rc = read(fd, buf + i, len - i);
149
150                 /* unexpected EOF: trim and return */
151                 if (rc == 0) {
152                         len = i;
153                         break;
154                 }
155
156                 if (rc < 0)
157                         goto err_free;
158
159         }
160
161         buf[len] = '\0';
162
163         close(fd);
164         *bufp = buf;
165         *lenp = len;
166         return 0;
167
168 err_free:
169         talloc_free(buf);
170 err_close:
171         close(fd);
172         return -1;
173 }
174
175 static int write_fd(int fd, char *buf, int len)
176 {
177         int i, rc;
178
179         for (i = 0; i < len; i += rc) {
180                 rc = write(fd, buf + i, len - i);
181                 if (rc < 0 && errno != -EINTR)
182                         return rc;
183         }
184
185         return 0;
186 }
187
188 int replace_file(const char *filename, char *buf, int len)
189 {
190         char *tempfile;
191         mode_t oldmask;
192         int rc, fd;
193
194         tempfile = talloc_asprintf(NULL, "%s.XXXXXX", filename);
195
196         oldmask = umask(0644);
197         fd = mkstemp(tempfile);
198         umask(oldmask);
199         if (fd < 0) {
200                 talloc_free(tempfile);
201                 return fd;
202         }
203
204         rc = write_fd(fd, buf, len);
205         if (rc) {
206                 unlink(tempfile);
207         } else {
208                 rc = rename(tempfile, filename);
209         }
210
211         talloc_free(tempfile);
212
213         fchmod(fd, 0644);
214
215         close(fd);
216         return rc;
217 }