1caf54c4fSMartin Matuska /*-
26c95142eSMartin Matuska * Copyright (c) 2003-2010 Tim Kientzle
3caf54c4fSMartin Matuska * All rights reserved.
4caf54c4fSMartin Matuska *
5caf54c4fSMartin Matuska * Redistribution and use in source and binary forms, with or without
6caf54c4fSMartin Matuska * modification, are permitted provided that the following conditions
7caf54c4fSMartin Matuska * are met:
8caf54c4fSMartin Matuska * 1. Redistributions of source code must retain the above copyright
9caf54c4fSMartin Matuska * notice, this list of conditions and the following disclaimer.
10caf54c4fSMartin Matuska * 2. Redistributions in binary form must reproduce the above copyright
11caf54c4fSMartin Matuska * notice, this list of conditions and the following disclaimer in the
12caf54c4fSMartin Matuska * documentation and/or other materials provided with the distribution.
13caf54c4fSMartin Matuska *
14caf54c4fSMartin Matuska * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15caf54c4fSMartin Matuska * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16caf54c4fSMartin Matuska * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17caf54c4fSMartin Matuska * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18caf54c4fSMartin Matuska * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19caf54c4fSMartin Matuska * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20caf54c4fSMartin Matuska * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21caf54c4fSMartin Matuska * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22caf54c4fSMartin Matuska * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23caf54c4fSMartin Matuska * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24caf54c4fSMartin Matuska */
25caf54c4fSMartin Matuska
26caf54c4fSMartin Matuska #include "archive_platform.h"
27caf54c4fSMartin Matuska
286c95142eSMartin Matuska #ifdef HAVE_SYS_IOCTL_H
296c95142eSMartin Matuska #include <sys/ioctl.h>
306c95142eSMartin Matuska #endif
31caf54c4fSMartin Matuska #ifdef HAVE_SYS_STAT_H
32caf54c4fSMartin Matuska #include <sys/stat.h>
33caf54c4fSMartin Matuska #endif
34caf54c4fSMartin Matuska #ifdef HAVE_ERRNO_H
35caf54c4fSMartin Matuska #include <errno.h>
36caf54c4fSMartin Matuska #endif
37caf54c4fSMartin Matuska #ifdef HAVE_FCNTL_H
38caf54c4fSMartin Matuska #include <fcntl.h>
39caf54c4fSMartin Matuska #endif
40caf54c4fSMartin Matuska #ifdef HAVE_IO_H
41caf54c4fSMartin Matuska #include <io.h>
42caf54c4fSMartin Matuska #endif
43caf54c4fSMartin Matuska #ifdef HAVE_STDLIB_H
44caf54c4fSMartin Matuska #include <stdlib.h>
45caf54c4fSMartin Matuska #endif
46caf54c4fSMartin Matuska #ifdef HAVE_STRING_H
47caf54c4fSMartin Matuska #include <string.h>
48caf54c4fSMartin Matuska #endif
49caf54c4fSMartin Matuska #ifdef HAVE_UNISTD_H
50caf54c4fSMartin Matuska #include <unistd.h>
51caf54c4fSMartin Matuska #endif
526c95142eSMartin Matuska #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
536c95142eSMartin Matuska #include <sys/disk.h>
546c95142eSMartin Matuska #elif defined(__NetBSD__) || defined(__OpenBSD__)
556c95142eSMartin Matuska #include <sys/disklabel.h>
566c95142eSMartin Matuska #include <sys/dkio.h>
576c95142eSMartin Matuska #elif defined(__DragonFly__)
586c95142eSMartin Matuska #include <sys/diskslice.h>
596c95142eSMartin Matuska #endif
60caf54c4fSMartin Matuska
61caf54c4fSMartin Matuska #include "archive.h"
62acc60b03SMartin Matuska #include "archive_private.h"
636c95142eSMartin Matuska #include "archive_string.h"
64caf54c4fSMartin Matuska
65caf54c4fSMartin Matuska #ifndef O_BINARY
66caf54c4fSMartin Matuska #define O_BINARY 0
67caf54c4fSMartin Matuska #endif
68acc60b03SMartin Matuska #ifndef O_CLOEXEC
69acc60b03SMartin Matuska #define O_CLOEXEC 0
70acc60b03SMartin Matuska #endif
71caf54c4fSMartin Matuska
72caf54c4fSMartin Matuska struct read_file_data {
73caf54c4fSMartin Matuska int fd;
74caf54c4fSMartin Matuska size_t block_size;
75caf54c4fSMartin Matuska void *buffer;
76caf54c4fSMartin Matuska mode_t st_mode; /* Mode bits for opened file. */
776c95142eSMartin Matuska char use_lseek;
786c95142eSMartin Matuska enum fnt_e { FNT_STDIN, FNT_MBS, FNT_WCS } filename_type;
796c95142eSMartin Matuska union {
806c95142eSMartin Matuska char m[1];/* MBS filename. */
816c95142eSMartin Matuska wchar_t w[1];/* WCS filename. */
826c95142eSMartin Matuska } filename; /* Must be last! */
83caf54c4fSMartin Matuska };
84caf54c4fSMartin Matuska
85acc60b03SMartin Matuska static int file_open(struct archive *, void *);
86caf54c4fSMartin Matuska static int file_close(struct archive *, void *);
87acc60b03SMartin Matuska static int file_close2(struct archive *, void *);
88acc60b03SMartin Matuska static int file_switch(struct archive *, void *, void *);
89caf54c4fSMartin Matuska static ssize_t file_read(struct archive *, void *, const void **buff);
906c95142eSMartin Matuska static int64_t file_seek(struct archive *, void *, int64_t request, int);
916c95142eSMartin Matuska static int64_t file_skip(struct archive *, void *, int64_t request);
926c95142eSMartin Matuska static int64_t file_skip_lseek(struct archive *, void *, int64_t request);
93caf54c4fSMartin Matuska
94caf54c4fSMartin Matuska int
archive_read_open_file(struct archive * a,const char * filename,size_t block_size)95caf54c4fSMartin Matuska archive_read_open_file(struct archive *a, const char *filename,
96caf54c4fSMartin Matuska size_t block_size)
97caf54c4fSMartin Matuska {
98caf54c4fSMartin Matuska return (archive_read_open_filename(a, filename, block_size));
99caf54c4fSMartin Matuska }
100caf54c4fSMartin Matuska
101caf54c4fSMartin Matuska int
archive_read_open_filename(struct archive * a,const char * filename,size_t block_size)102caf54c4fSMartin Matuska archive_read_open_filename(struct archive *a, const char *filename,
103caf54c4fSMartin Matuska size_t block_size)
104caf54c4fSMartin Matuska {
105cdf63a70SMartin Matuska const char *filenames[2];
106cdf63a70SMartin Matuska filenames[0] = filename;
107cdf63a70SMartin Matuska filenames[1] = NULL;
108acc60b03SMartin Matuska return archive_read_open_filenames(a, filenames, block_size);
109acc60b03SMartin Matuska }
1106c95142eSMartin Matuska
111acc60b03SMartin Matuska int
archive_read_open_filenames(struct archive * a,const char ** filenames,size_t block_size)112acc60b03SMartin Matuska archive_read_open_filenames(struct archive *a, const char **filenames,
113acc60b03SMartin Matuska size_t block_size)
114acc60b03SMartin Matuska {
115acc60b03SMartin Matuska struct read_file_data *mine;
116acc60b03SMartin Matuska const char *filename = NULL;
117acc60b03SMartin Matuska if (filenames)
118acc60b03SMartin Matuska filename = *(filenames++);
119acc60b03SMartin Matuska
120acc60b03SMartin Matuska archive_clear_error(a);
121acc60b03SMartin Matuska do
122acc60b03SMartin Matuska {
123acc60b03SMartin Matuska if (filename == NULL)
124acc60b03SMartin Matuska filename = "";
125acc60b03SMartin Matuska mine = (struct read_file_data *)calloc(1,
126acc60b03SMartin Matuska sizeof(*mine) + strlen(filename));
127acc60b03SMartin Matuska if (mine == NULL)
128acc60b03SMartin Matuska goto no_memory;
129acc60b03SMartin Matuska strcpy(mine->filename.m, filename);
130acc60b03SMartin Matuska mine->block_size = block_size;
131acc60b03SMartin Matuska mine->fd = -1;
132acc60b03SMartin Matuska mine->buffer = NULL;
133acc60b03SMartin Matuska mine->st_mode = mine->use_lseek = 0;
1346c95142eSMartin Matuska if (filename == NULL || filename[0] == '\0') {
135acc60b03SMartin Matuska mine->filename_type = FNT_STDIN;
1366c95142eSMartin Matuska } else
137acc60b03SMartin Matuska mine->filename_type = FNT_MBS;
138acc60b03SMartin Matuska if (archive_read_append_callback_data(a, mine) != (ARCHIVE_OK))
139acc60b03SMartin Matuska return (ARCHIVE_FATAL);
140acc60b03SMartin Matuska if (filenames == NULL)
141acc60b03SMartin Matuska break;
142acc60b03SMartin Matuska filename = *(filenames++);
143acc60b03SMartin Matuska } while (filename != NULL && filename[0] != '\0');
144acc60b03SMartin Matuska archive_read_set_open_callback(a, file_open);
145acc60b03SMartin Matuska archive_read_set_read_callback(a, file_read);
146acc60b03SMartin Matuska archive_read_set_skip_callback(a, file_skip);
147acc60b03SMartin Matuska archive_read_set_close_callback(a, file_close);
148acc60b03SMartin Matuska archive_read_set_switch_callback(a, file_switch);
149acc60b03SMartin Matuska archive_read_set_seek_callback(a, file_seek);
150acc60b03SMartin Matuska
151acc60b03SMartin Matuska return (archive_read_open1(a));
152acc60b03SMartin Matuska no_memory:
153acc60b03SMartin Matuska archive_set_error(a, ENOMEM, "No memory");
154acc60b03SMartin Matuska return (ARCHIVE_FATAL);
1556c95142eSMartin Matuska }
1566c95142eSMartin Matuska
157b9128a37SMartin Matuska /*
158b9128a37SMartin Matuska * This function is an implementation detail of archive_read_open_filename_w,
159b9128a37SMartin Matuska * which is exposed as a separate API on Windows.
160b9128a37SMartin Matuska */
161b9128a37SMartin Matuska #if !defined(_WIN32) || defined(__CYGWIN__)
162b9128a37SMartin Matuska static
163b9128a37SMartin Matuska #endif
1646c95142eSMartin Matuska int
archive_read_open_filenames_w(struct archive * a,const wchar_t ** wfilenames,size_t block_size)165b9128a37SMartin Matuska archive_read_open_filenames_w(struct archive *a, const wchar_t **wfilenames,
1666c95142eSMartin Matuska size_t block_size)
1676c95142eSMartin Matuska {
168b9128a37SMartin Matuska struct read_file_data *mine;
169b9128a37SMartin Matuska const wchar_t *wfilename = NULL;
170b9128a37SMartin Matuska if (wfilenames)
171b9128a37SMartin Matuska wfilename = *(wfilenames++);
172b9128a37SMartin Matuska
173b9128a37SMartin Matuska archive_clear_error(a);
174b9128a37SMartin Matuska do
175acc60b03SMartin Matuska {
176b9128a37SMartin Matuska if (wfilename == NULL)
177b9128a37SMartin Matuska wfilename = L"";
178b9128a37SMartin Matuska mine = (struct read_file_data *)calloc(1,
179b9128a37SMartin Matuska sizeof(*mine) + wcslen(wfilename) * sizeof(wchar_t));
180b9128a37SMartin Matuska if (mine == NULL)
181b9128a37SMartin Matuska goto no_memory;
182acc60b03SMartin Matuska mine->block_size = block_size;
183b9128a37SMartin Matuska mine->fd = -1;
1846c95142eSMartin Matuska
1856c95142eSMartin Matuska if (wfilename == NULL || wfilename[0] == L'\0') {
186acc60b03SMartin Matuska mine->filename_type = FNT_STDIN;
1876c95142eSMartin Matuska } else {
1886c95142eSMartin Matuska #if defined(_WIN32) && !defined(__CYGWIN__)
189acc60b03SMartin Matuska mine->filename_type = FNT_WCS;
190acc60b03SMartin Matuska wcscpy(mine->filename.w, wfilename);
1916c95142eSMartin Matuska #else
1926c95142eSMartin Matuska /*
1936c95142eSMartin Matuska * POSIX system does not support a wchar_t interface for
194cdf63a70SMartin Matuska * open() system call, so we have to translate a wchar_t
1956c95142eSMartin Matuska * filename to multi-byte one and use it.
1966c95142eSMartin Matuska */
1976c95142eSMartin Matuska struct archive_string fn;
1986c95142eSMartin Matuska
1996c95142eSMartin Matuska archive_string_init(&fn);
2006c95142eSMartin Matuska if (archive_string_append_from_wcs(&fn, wfilename,
2016c95142eSMartin Matuska wcslen(wfilename)) != 0) {
202fd082e96SMartin Matuska if (errno == ENOMEM)
203fd082e96SMartin Matuska archive_set_error(a, errno,
204fd082e96SMartin Matuska "Can't allocate memory");
205fd082e96SMartin Matuska else
2066c95142eSMartin Matuska archive_set_error(a, EINVAL,
207fd082e96SMartin Matuska "Failed to convert a wide-character"
208fd082e96SMartin Matuska " filename to a multi-byte filename");
2096c95142eSMartin Matuska archive_string_free(&fn);
210acc60b03SMartin Matuska free(mine);
2116c95142eSMartin Matuska return (ARCHIVE_FATAL);
2126c95142eSMartin Matuska }
213acc60b03SMartin Matuska mine->filename_type = FNT_MBS;
214acc60b03SMartin Matuska strcpy(mine->filename.m, fn.s);
2156c95142eSMartin Matuska archive_string_free(&fn);
2166c95142eSMartin Matuska #endif
2176c95142eSMartin Matuska }
218acc60b03SMartin Matuska if (archive_read_append_callback_data(a, mine) != (ARCHIVE_OK))
219acc60b03SMartin Matuska return (ARCHIVE_FATAL);
220b9128a37SMartin Matuska if (wfilenames == NULL)
221b9128a37SMartin Matuska break;
222b9128a37SMartin Matuska wfilename = *(wfilenames++);
223b9128a37SMartin Matuska } while (wfilename != NULL && wfilename[0] != '\0');
224acc60b03SMartin Matuska archive_read_set_open_callback(a, file_open);
225acc60b03SMartin Matuska archive_read_set_read_callback(a, file_read);
226acc60b03SMartin Matuska archive_read_set_skip_callback(a, file_skip);
227acc60b03SMartin Matuska archive_read_set_close_callback(a, file_close);
228acc60b03SMartin Matuska archive_read_set_switch_callback(a, file_switch);
229acc60b03SMartin Matuska archive_read_set_seek_callback(a, file_seek);
230acc60b03SMartin Matuska
231acc60b03SMartin Matuska return (archive_read_open1(a));
232b9128a37SMartin Matuska no_memory:
233b9128a37SMartin Matuska archive_set_error(a, ENOMEM, "No memory");
234b9128a37SMartin Matuska return (ARCHIVE_FATAL);
235b9128a37SMartin Matuska }
236b9128a37SMartin Matuska
237b9128a37SMartin Matuska int
archive_read_open_filename_w(struct archive * a,const wchar_t * wfilename,size_t block_size)238b9128a37SMartin Matuska archive_read_open_filename_w(struct archive *a, const wchar_t *wfilename,
239b9128a37SMartin Matuska size_t block_size)
240b9128a37SMartin Matuska {
241b9128a37SMartin Matuska const wchar_t *wfilenames[2];
242b9128a37SMartin Matuska wfilenames[0] = wfilename;
243b9128a37SMartin Matuska wfilenames[1] = NULL;
244b9128a37SMartin Matuska return archive_read_open_filenames_w(a, wfilenames, block_size);
2456c95142eSMartin Matuska }
2466c95142eSMartin Matuska
2476c95142eSMartin Matuska static int
file_open(struct archive * a,void * client_data)248acc60b03SMartin Matuska file_open(struct archive *a, void *client_data)
2496c95142eSMartin Matuska {
250caf54c4fSMartin Matuska struct stat st;
251acc60b03SMartin Matuska struct read_file_data *mine = (struct read_file_data *)client_data;
2526c95142eSMartin Matuska void *buffer;
2536c95142eSMartin Matuska const char *filename = NULL;
254f55be4fcSMartin Matuska #if defined(_WIN32) && !defined(__CYGWIN__)
2556c95142eSMartin Matuska const wchar_t *wfilename = NULL;
256f55be4fcSMartin Matuska #endif
2579f3de9e2SMartin Matuska int fd = -1;
2586c95142eSMartin Matuska int is_disk_like = 0;
2596c95142eSMartin Matuska #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2606c95142eSMartin Matuska off_t mediasize = 0; /* FreeBSD-specific, so off_t okay here. */
2616c95142eSMartin Matuska #elif defined(__NetBSD__) || defined(__OpenBSD__)
2626c95142eSMartin Matuska struct disklabel dl;
2636c95142eSMartin Matuska #elif defined(__DragonFly__)
2646c95142eSMartin Matuska struct partinfo pi;
2656c95142eSMartin Matuska #endif
266caf54c4fSMartin Matuska
267caf54c4fSMartin Matuska archive_clear_error(a);
268acc60b03SMartin Matuska if (mine->filename_type == FNT_STDIN) {
2696c95142eSMartin Matuska /* We used to delegate stdin support by
2706c95142eSMartin Matuska * directly calling archive_read_open_fd(a,0,block_size)
271caf54c4fSMartin Matuska * here, but that doesn't (and shouldn't) handle the
272caf54c4fSMartin Matuska * end-of-file flush when reading stdout from a pipe.
273caf54c4fSMartin Matuska * Basically, read_open_fd() is intended for folks who
274caf54c4fSMartin Matuska * are willing to handle such details themselves. This
275caf54c4fSMartin Matuska * API is intended to be a little smarter for folks who
276caf54c4fSMartin Matuska * want easy handling of the common case.
277caf54c4fSMartin Matuska */
278caf54c4fSMartin Matuska fd = 0;
279caf54c4fSMartin Matuska #if defined(__CYGWIN__) || defined(_WIN32)
280caf54c4fSMartin Matuska setmode(0, O_BINARY);
281caf54c4fSMartin Matuska #endif
2826c95142eSMartin Matuska filename = "";
283acc60b03SMartin Matuska } else if (mine->filename_type == FNT_MBS) {
284acc60b03SMartin Matuska filename = mine->filename.m;
285acc60b03SMartin Matuska fd = open(filename, O_RDONLY | O_BINARY | O_CLOEXEC);
286acc60b03SMartin Matuska __archive_ensure_cloexec_flag(fd);
287caf54c4fSMartin Matuska if (fd < 0) {
288caf54c4fSMartin Matuska archive_set_error(a, errno,
289caf54c4fSMartin Matuska "Failed to open '%s'", filename);
290caf54c4fSMartin Matuska return (ARCHIVE_FATAL);
291caf54c4fSMartin Matuska }
2926c95142eSMartin Matuska } else {
2936c95142eSMartin Matuska #if defined(_WIN32) && !defined(__CYGWIN__)
294acc60b03SMartin Matuska wfilename = mine->filename.w;
2956c95142eSMartin Matuska fd = _wopen(wfilename, O_RDONLY | O_BINARY);
2966c95142eSMartin Matuska if (fd < 0 && errno == ENOENT) {
2976c95142eSMartin Matuska wchar_t *fullpath;
2986c95142eSMartin Matuska fullpath = __la_win_permissive_name_w(wfilename);
2996c95142eSMartin Matuska if (fullpath != NULL) {
3006c95142eSMartin Matuska fd = _wopen(fullpath, O_RDONLY | O_BINARY);
3016c95142eSMartin Matuska free(fullpath);
3026c95142eSMartin Matuska }
3036c95142eSMartin Matuska }
3046c95142eSMartin Matuska if (fd < 0) {
3056c95142eSMartin Matuska archive_set_error(a, errno,
3066c95142eSMartin Matuska "Failed to open '%S'", wfilename);
3076c95142eSMartin Matuska return (ARCHIVE_FATAL);
3086c95142eSMartin Matuska }
3096c95142eSMartin Matuska #else
3106c95142eSMartin Matuska archive_set_error(a, ARCHIVE_ERRNO_MISC,
3116c95142eSMartin Matuska "Unexpedted operation in archive_read_open_filename");
3129f3de9e2SMartin Matuska goto fail;
3136c95142eSMartin Matuska #endif
314caf54c4fSMartin Matuska }
315caf54c4fSMartin Matuska if (fstat(fd, &st) != 0) {
316f55be4fcSMartin Matuska #if defined(_WIN32) && !defined(__CYGWIN__)
317acc60b03SMartin Matuska if (mine->filename_type == FNT_WCS)
3186c95142eSMartin Matuska archive_set_error(a, errno, "Can't stat '%S'",
3196c95142eSMartin Matuska wfilename);
3206c95142eSMartin Matuska else
321f55be4fcSMartin Matuska #endif
3226c95142eSMartin Matuska archive_set_error(a, errno, "Can't stat '%s'",
3236c95142eSMartin Matuska filename);
3249f3de9e2SMartin Matuska goto fail;
325caf54c4fSMartin Matuska }
326caf54c4fSMartin Matuska
3276c95142eSMartin Matuska /*
3286c95142eSMartin Matuska * Determine whether the input looks like a disk device or a
3296c95142eSMartin Matuska * tape device. The results are used below to select an I/O
3306c95142eSMartin Matuska * strategy:
3316c95142eSMartin Matuska * = "disk-like" devices support arbitrary lseek() and will
3326c95142eSMartin Matuska * support I/O requests of any size. So we get easy skipping
3336c95142eSMartin Matuska * and can cheat on block sizes to get better performance.
3346c95142eSMartin Matuska * = "tape-like" devices require strict blocking and use
3356c95142eSMartin Matuska * specialized ioctls for seeking.
3366c95142eSMartin Matuska * = "socket-like" devices cannot seek at all but can improve
3376c95142eSMartin Matuska * performance by using nonblocking I/O to read "whatever is
3386c95142eSMartin Matuska * available right now".
3396c95142eSMartin Matuska *
3406c95142eSMartin Matuska * Right now, we only specially recognize disk-like devices,
3416c95142eSMartin Matuska * but it should be straightforward to add probes and strategy
3426c95142eSMartin Matuska * here for tape-like and socket-like devices.
3436c95142eSMartin Matuska */
3446c95142eSMartin Matuska if (S_ISREG(st.st_mode)) {
3456c95142eSMartin Matuska /* Safety: Tell the extractor not to overwrite the input. */
3466c95142eSMartin Matuska archive_read_extract_set_skip_file(a, st.st_dev, st.st_ino);
3476c95142eSMartin Matuska /* Regular files act like disks. */
3486c95142eSMartin Matuska is_disk_like = 1;
3496c95142eSMartin Matuska }
3506c95142eSMartin Matuska #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
3516c95142eSMartin Matuska /* FreeBSD: if it supports DIOCGMEDIASIZE ioctl, it's disk-like. */
3526c95142eSMartin Matuska else if (S_ISCHR(st.st_mode) &&
3536c95142eSMartin Matuska ioctl(fd, DIOCGMEDIASIZE, &mediasize) == 0 &&
3546c95142eSMartin Matuska mediasize > 0) {
3556c95142eSMartin Matuska is_disk_like = 1;
3566c95142eSMartin Matuska }
3576c95142eSMartin Matuska #elif defined(__NetBSD__) || defined(__OpenBSD__)
3586c95142eSMartin Matuska /* Net/OpenBSD: if it supports DIOCGDINFO ioctl, it's disk-like. */
3596c95142eSMartin Matuska else if ((S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) &&
3606c95142eSMartin Matuska ioctl(fd, DIOCGDINFO, &dl) == 0 &&
3616c95142eSMartin Matuska dl.d_partitions[DISKPART(st.st_rdev)].p_size > 0) {
3626c95142eSMartin Matuska is_disk_like = 1;
3636c95142eSMartin Matuska }
3646c95142eSMartin Matuska #elif defined(__DragonFly__)
3656c95142eSMartin Matuska /* DragonFly BSD: if it supports DIOCGPART ioctl, it's disk-like. */
3666c95142eSMartin Matuska else if (S_ISCHR(st.st_mode) &&
3676c95142eSMartin Matuska ioctl(fd, DIOCGPART, &pi) == 0 &&
3686c95142eSMartin Matuska pi.media_size > 0) {
3696c95142eSMartin Matuska is_disk_like = 1;
3706c95142eSMartin Matuska }
3716c95142eSMartin Matuska #elif defined(__linux__)
3726c95142eSMartin Matuska /* Linux: All block devices are disk-like. */
3736c95142eSMartin Matuska else if (S_ISBLK(st.st_mode) &&
3746c95142eSMartin Matuska lseek(fd, 0, SEEK_CUR) == 0 &&
3756c95142eSMartin Matuska lseek(fd, 0, SEEK_SET) == 0 &&
3766c95142eSMartin Matuska lseek(fd, 0, SEEK_END) > 0 &&
3776c95142eSMartin Matuska lseek(fd, 0, SEEK_SET) == 0) {
3786c95142eSMartin Matuska is_disk_like = 1;
3796c95142eSMartin Matuska }
3806c95142eSMartin Matuska #endif
3816c95142eSMartin Matuska /* TODO: Add an "is_tape_like" variable and appropriate tests. */
3826c95142eSMartin Matuska
3836c95142eSMartin Matuska /* Disk-like devices prefer power-of-two block sizes. */
3846c95142eSMartin Matuska /* Use provided block_size as a guide so users have some control. */
3856c95142eSMartin Matuska if (is_disk_like) {
3866c95142eSMartin Matuska size_t new_block_size = 64 * 1024;
387acc60b03SMartin Matuska while (new_block_size < mine->block_size
3886c95142eSMartin Matuska && new_block_size < 64 * 1024 * 1024)
3896c95142eSMartin Matuska new_block_size *= 2;
390acc60b03SMartin Matuska mine->block_size = new_block_size;
3916c95142eSMartin Matuska }
392acc60b03SMartin Matuska buffer = malloc(mine->block_size);
3939f3de9e2SMartin Matuska if (buffer == NULL) {
394caf54c4fSMartin Matuska archive_set_error(a, ENOMEM, "No memory");
3959f3de9e2SMartin Matuska goto fail;
396caf54c4fSMartin Matuska }
3976c95142eSMartin Matuska mine->buffer = buffer;
398caf54c4fSMartin Matuska mine->fd = fd;
399caf54c4fSMartin Matuska /* Remember mode so close can decide whether to flush. */
400caf54c4fSMartin Matuska mine->st_mode = st.st_mode;
4016c95142eSMartin Matuska
4026c95142eSMartin Matuska /* Disk-like inputs can use lseek(). */
403acc60b03SMartin Matuska if (is_disk_like)
4046c95142eSMartin Matuska mine->use_lseek = 1;
4056c95142eSMartin Matuska
406acc60b03SMartin Matuska return (ARCHIVE_OK);
4079f3de9e2SMartin Matuska fail:
4089f3de9e2SMartin Matuska /*
4099f3de9e2SMartin Matuska * Don't close file descriptors not opened or ones pointing referring
4109f3de9e2SMartin Matuska * to `FNT_STDIN`.
4119f3de9e2SMartin Matuska */
4129f3de9e2SMartin Matuska if (fd != -1 && fd != 0)
4139f3de9e2SMartin Matuska close(fd);
4149f3de9e2SMartin Matuska return (ARCHIVE_FATAL);
415caf54c4fSMartin Matuska }
416caf54c4fSMartin Matuska
417caf54c4fSMartin Matuska static ssize_t
file_read(struct archive * a,void * client_data,const void ** buff)418caf54c4fSMartin Matuska file_read(struct archive *a, void *client_data, const void **buff)
419caf54c4fSMartin Matuska {
420caf54c4fSMartin Matuska struct read_file_data *mine = (struct read_file_data *)client_data;
421caf54c4fSMartin Matuska ssize_t bytes_read;
422caf54c4fSMartin Matuska
4236c95142eSMartin Matuska /* TODO: If a recent lseek() operation has left us
4246c95142eSMartin Matuska * mis-aligned, read and return a short block to try to get
4256c95142eSMartin Matuska * us back in alignment. */
4266c95142eSMartin Matuska
4276c95142eSMartin Matuska /* TODO: Someday, try mmap() here; if that succeeds, give
4286c95142eSMartin Matuska * the entire file to libarchive as a single block. That
4296c95142eSMartin Matuska * could be a lot faster than block-by-block manual I/O. */
4306c95142eSMartin Matuska
4316c95142eSMartin Matuska /* TODO: We might be able to improve performance on pipes and
4326c95142eSMartin Matuska * sockets by setting non-blocking I/O and just accepting
4336c95142eSMartin Matuska * whatever we get here instead of waiting for a full block
4346c95142eSMartin Matuska * worth of data. */
4356c95142eSMartin Matuska
436caf54c4fSMartin Matuska *buff = mine->buffer;
437caf54c4fSMartin Matuska for (;;) {
438caf54c4fSMartin Matuska bytes_read = read(mine->fd, mine->buffer, mine->block_size);
439caf54c4fSMartin Matuska if (bytes_read < 0) {
440caf54c4fSMartin Matuska if (errno == EINTR)
441caf54c4fSMartin Matuska continue;
4426c95142eSMartin Matuska else if (mine->filename_type == FNT_STDIN)
4436c95142eSMartin Matuska archive_set_error(a, errno,
4446c95142eSMartin Matuska "Error reading stdin");
4456c95142eSMartin Matuska else if (mine->filename_type == FNT_MBS)
4466c95142eSMartin Matuska archive_set_error(a, errno,
4476c95142eSMartin Matuska "Error reading '%s'", mine->filename.m);
448caf54c4fSMartin Matuska else
4496c95142eSMartin Matuska archive_set_error(a, errno,
4506c95142eSMartin Matuska "Error reading '%S'", mine->filename.w);
451caf54c4fSMartin Matuska }
452caf54c4fSMartin Matuska return (bytes_read);
453caf54c4fSMartin Matuska }
454caf54c4fSMartin Matuska }
455caf54c4fSMartin Matuska
4566c95142eSMartin Matuska /*
4576c95142eSMartin Matuska * Regular files and disk-like block devices can use simple lseek
4586c95142eSMartin Matuska * without needing to round the request to the block size.
4596c95142eSMartin Matuska *
4606c95142eSMartin Matuska * TODO: This can leave future reads mis-aligned. Since we know the
4616c95142eSMartin Matuska * offset here, we should store it and use it in file_read() above
4626c95142eSMartin Matuska * to determine whether we should perform a short read to get back
4636c95142eSMartin Matuska * into alignment. Long series of mis-aligned reads can negatively
4646c95142eSMartin Matuska * impact disk throughput. (Of course, the performance impact should
4656c95142eSMartin Matuska * be carefully tested; extra code complexity is only worthwhile if
4666c95142eSMartin Matuska * it does provide measurable improvement.)
4676c95142eSMartin Matuska *
4686c95142eSMartin Matuska * TODO: Be lazy about the actual seek. There are a few pathological
4696c95142eSMartin Matuska * cases where libarchive makes a bunch of seek requests in a row
4706c95142eSMartin Matuska * without any intervening reads. This isn't a huge performance
4716c95142eSMartin Matuska * problem, since the kernel handles seeks lazily already, but
4726c95142eSMartin Matuska * it would be very slightly faster if we simply remembered the
4736c95142eSMartin Matuska * seek request here and then actually performed the seek at the
4746c95142eSMartin Matuska * top of the read callback above.
4756c95142eSMartin Matuska */
4766c95142eSMartin Matuska static int64_t
file_skip_lseek(struct archive * a,void * client_data,int64_t request)4776c95142eSMartin Matuska file_skip_lseek(struct archive *a, void *client_data, int64_t request)
478caf54c4fSMartin Matuska {
479caf54c4fSMartin Matuska struct read_file_data *mine = (struct read_file_data *)client_data;
4806c95142eSMartin Matuska #if defined(_WIN32) && !defined(__CYGWIN__)
4816c95142eSMartin Matuska /* We use _lseeki64() on Windows. */
4826c95142eSMartin Matuska int64_t old_offset, new_offset;
4836c95142eSMartin Matuska #else
484caf54c4fSMartin Matuska off_t old_offset, new_offset;
4856c95142eSMartin Matuska #endif
486caf54c4fSMartin Matuska
4876c95142eSMartin Matuska /* We use off_t here because lseek() is declared that way. */
488caf54c4fSMartin Matuska
4896c95142eSMartin Matuska /* TODO: Deal with case where off_t isn't 64 bits.
4906c95142eSMartin Matuska * This shouldn't be a problem on Linux or other POSIX
4916c95142eSMartin Matuska * systems, since the configuration logic for libarchive
492acc60b03SMartin Matuska * tries to obtain a 64-bit off_t.
493caf54c4fSMartin Matuska */
4946c95142eSMartin Matuska if ((old_offset = lseek(mine->fd, 0, SEEK_CUR)) >= 0 &&
4956c95142eSMartin Matuska (new_offset = lseek(mine->fd, request, SEEK_CUR)) >= 0)
4966c95142eSMartin Matuska return (new_offset - old_offset);
497caf54c4fSMartin Matuska
4986c95142eSMartin Matuska /* If lseek() fails, don't bother trying again. */
4996c95142eSMartin Matuska mine->use_lseek = 0;
5006c95142eSMartin Matuska
5016c95142eSMartin Matuska /* Let libarchive recover with read+discard */
502caf54c4fSMartin Matuska if (errno == ESPIPE)
503caf54c4fSMartin Matuska return (0);
5046c95142eSMartin Matuska
5056c95142eSMartin Matuska /* If the input is corrupted or truncated, fail. */
5066c95142eSMartin Matuska if (mine->filename_type == FNT_STDIN)
507caf54c4fSMartin Matuska archive_set_error(a, errno, "Error seeking in stdin");
5086c95142eSMartin Matuska else if (mine->filename_type == FNT_MBS)
509caf54c4fSMartin Matuska archive_set_error(a, errno, "Error seeking in '%s'",
5106c95142eSMartin Matuska mine->filename.m);
5116c95142eSMartin Matuska else
5126c95142eSMartin Matuska archive_set_error(a, errno, "Error seeking in '%S'",
5136c95142eSMartin Matuska mine->filename.w);
514caf54c4fSMartin Matuska return (-1);
515caf54c4fSMartin Matuska }
5166c95142eSMartin Matuska
5176c95142eSMartin Matuska
5186c95142eSMartin Matuska /*
5196c95142eSMartin Matuska * TODO: Implement another file_skip_XXXX that uses MTIO ioctls to
5206c95142eSMartin Matuska * accelerate operation on tape drives.
5216c95142eSMartin Matuska */
5226c95142eSMartin Matuska
5236c95142eSMartin Matuska static int64_t
file_skip(struct archive * a,void * client_data,int64_t request)5246c95142eSMartin Matuska file_skip(struct archive *a, void *client_data, int64_t request)
5256c95142eSMartin Matuska {
5266c95142eSMartin Matuska struct read_file_data *mine = (struct read_file_data *)client_data;
5276c95142eSMartin Matuska
5286c95142eSMartin Matuska /* Delegate skip requests. */
5296c95142eSMartin Matuska if (mine->use_lseek)
5306c95142eSMartin Matuska return (file_skip_lseek(a, client_data, request));
5316c95142eSMartin Matuska
5326c95142eSMartin Matuska /* If we can't skip, return 0; libarchive will read+discard instead. */
5336c95142eSMartin Matuska return (0);
5346c95142eSMartin Matuska }
5356c95142eSMartin Matuska
5366c95142eSMartin Matuska /*
5376c95142eSMartin Matuska * TODO: Store the offset and use it in the read callback.
5386c95142eSMartin Matuska */
5396c95142eSMartin Matuska static int64_t
file_seek(struct archive * a,void * client_data,int64_t request,int whence)5406c95142eSMartin Matuska file_seek(struct archive *a, void *client_data, int64_t request, int whence)
5416c95142eSMartin Matuska {
5426c95142eSMartin Matuska struct read_file_data *mine = (struct read_file_data *)client_data;
543fd082e96SMartin Matuska int64_t r;
5446c95142eSMartin Matuska
5456c95142eSMartin Matuska /* We use off_t here because lseek() is declared that way. */
5466c95142eSMartin Matuska /* See above for notes about when off_t is less than 64 bits. */
5476c95142eSMartin Matuska r = lseek(mine->fd, request, whence);
5486c95142eSMartin Matuska if (r >= 0)
5496c95142eSMartin Matuska return r;
5506c95142eSMartin Matuska
5516c95142eSMartin Matuska /* If the input is corrupted or truncated, fail. */
5526c95142eSMartin Matuska if (mine->filename_type == FNT_STDIN)
5536c95142eSMartin Matuska archive_set_error(a, errno, "Error seeking in stdin");
5546c95142eSMartin Matuska else if (mine->filename_type == FNT_MBS)
5556c95142eSMartin Matuska archive_set_error(a, errno, "Error seeking in '%s'",
5566c95142eSMartin Matuska mine->filename.m);
5576c95142eSMartin Matuska else
5586c95142eSMartin Matuska archive_set_error(a, errno, "Error seeking in '%S'",
5596c95142eSMartin Matuska mine->filename.w);
5606c95142eSMartin Matuska return (ARCHIVE_FATAL);
561caf54c4fSMartin Matuska }
562caf54c4fSMartin Matuska
563caf54c4fSMartin Matuska static int
file_close2(struct archive * a,void * client_data)564acc60b03SMartin Matuska file_close2(struct archive *a, void *client_data)
565caf54c4fSMartin Matuska {
566caf54c4fSMartin Matuska struct read_file_data *mine = (struct read_file_data *)client_data;
567caf54c4fSMartin Matuska
568caf54c4fSMartin Matuska (void)a; /* UNUSED */
569caf54c4fSMartin Matuska
570caf54c4fSMartin Matuska /* Only flush and close if open succeeded. */
571caf54c4fSMartin Matuska if (mine->fd >= 0) {
572caf54c4fSMartin Matuska /*
573caf54c4fSMartin Matuska * Sometimes, we should flush the input before closing.
574caf54c4fSMartin Matuska * Regular files: faster to just close without flush.
5756c95142eSMartin Matuska * Disk-like devices: Ditto.
5766c95142eSMartin Matuska * Tapes: must not flush (user might need to
577caf54c4fSMartin Matuska * read the "next" item on a non-rewind device).
578caf54c4fSMartin Matuska * Pipes and sockets: must flush (otherwise, the
579caf54c4fSMartin Matuska * program feeding the pipe or socket may complain).
580caf54c4fSMartin Matuska * Here, I flush everything except for regular files and
581caf54c4fSMartin Matuska * device nodes.
582caf54c4fSMartin Matuska */
583caf54c4fSMartin Matuska if (!S_ISREG(mine->st_mode)
584caf54c4fSMartin Matuska && !S_ISCHR(mine->st_mode)
585caf54c4fSMartin Matuska && !S_ISBLK(mine->st_mode)) {
586caf54c4fSMartin Matuska ssize_t bytesRead;
587caf54c4fSMartin Matuska do {
588caf54c4fSMartin Matuska bytesRead = read(mine->fd, mine->buffer,
589caf54c4fSMartin Matuska mine->block_size);
590caf54c4fSMartin Matuska } while (bytesRead > 0);
591caf54c4fSMartin Matuska }
592caf54c4fSMartin Matuska /* If a named file was opened, then it needs to be closed. */
5936c95142eSMartin Matuska if (mine->filename_type != FNT_STDIN)
594caf54c4fSMartin Matuska close(mine->fd);
595caf54c4fSMartin Matuska }
596caf54c4fSMartin Matuska free(mine->buffer);
597acc60b03SMartin Matuska mine->buffer = NULL;
598acc60b03SMartin Matuska mine->fd = -1;
599acc60b03SMartin Matuska return (ARCHIVE_OK);
600acc60b03SMartin Matuska }
601acc60b03SMartin Matuska
602acc60b03SMartin Matuska static int
file_close(struct archive * a,void * client_data)603acc60b03SMartin Matuska file_close(struct archive *a, void *client_data)
604acc60b03SMartin Matuska {
605acc60b03SMartin Matuska struct read_file_data *mine = (struct read_file_data *)client_data;
606acc60b03SMartin Matuska file_close2(a, client_data);
607caf54c4fSMartin Matuska free(mine);
608caf54c4fSMartin Matuska return (ARCHIVE_OK);
609caf54c4fSMartin Matuska }
610acc60b03SMartin Matuska
611acc60b03SMartin Matuska static int
file_switch(struct archive * a,void * client_data1,void * client_data2)612acc60b03SMartin Matuska file_switch(struct archive *a, void *client_data1, void *client_data2)
613acc60b03SMartin Matuska {
614acc60b03SMartin Matuska file_close2(a, client_data1);
615acc60b03SMartin Matuska return file_open(a, client_data2);
616acc60b03SMartin Matuska }
617