]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/test/test-copy.c
2 This file is part of systemd
4 Copyright 2014 Ronny Chevalier
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include "alloc-util.h"
30 #include "path-util.h"
32 #include "string-util.h"
34 #include "user-util.h"
37 static void test_copy_file(void) {
38 _cleanup_free_
char *buf
= NULL
;
39 char fn
[] = "/tmp/test-copy_file.XXXXXX";
40 char fn_copy
[] = "/tmp/test-copy_file.XXXXXX";
44 log_info("%s", __func__
);
46 fd
= mkostemp_safe(fn
);
50 fd
= mkostemp_safe(fn_copy
);
54 assert_se(write_string_file(fn
, "foo bar bar bar foo", WRITE_STRING_FILE_CREATE
) == 0);
56 assert_se(copy_file(fn
, fn_copy
, 0, 0644, 0, COPY_REFLINK
) == 0);
58 assert_se(read_full_file(fn_copy
, &buf
, &sz
) == 0);
59 assert_se(streq(buf
, "foo bar bar bar foo\n"));
66 static void test_copy_file_fd(void) {
67 char in_fn
[] = "/tmp/test-copy-file-fd-XXXXXX";
68 char out_fn
[] = "/tmp/test-copy-file-fd-XXXXXX";
69 _cleanup_close_
int in_fd
= -1, out_fd
= -1;
70 char text
[] = "boohoo\nfoo\n\tbar\n";
73 log_info("%s", __func__
);
75 in_fd
= mkostemp_safe(in_fn
);
76 assert_se(in_fd
>= 0);
77 out_fd
= mkostemp_safe(out_fn
);
78 assert_se(out_fd
>= 0);
80 assert_se(write_string_file(in_fn
, text
, WRITE_STRING_FILE_CREATE
) == 0);
81 assert_se(copy_file_fd("/a/file/which/does/not/exist/i/guess", out_fd
, COPY_REFLINK
) < 0);
82 assert_se(copy_file_fd(in_fn
, out_fd
, COPY_REFLINK
) >= 0);
83 assert_se(lseek(out_fd
, SEEK_SET
, 0) == 0);
85 assert_se(read(out_fd
, buf
, sizeof(buf
)) == sizeof(text
) - 1);
86 assert_se(streq(buf
, text
));
92 static void test_copy_tree(void) {
93 char original_dir
[] = "/tmp/test-copy_tree/";
94 char copy_dir
[] = "/tmp/test-copy_tree-copy/";
95 char **files
= STRV_MAKE("file", "dir1/file", "dir1/dir2/file", "dir1/dir2/dir3/dir4/dir5/file");
96 char **links
= STRV_MAKE("link", "file",
97 "link2", "dir1/file");
99 const char *unixsockp
;
102 log_info("%s", __func__
);
104 (void) rm_rf(copy_dir
, REMOVE_ROOT
|REMOVE_PHYSICAL
);
105 (void) rm_rf(original_dir
, REMOVE_ROOT
|REMOVE_PHYSICAL
);
107 STRV_FOREACH(p
, files
) {
108 _cleanup_free_
char *f
;
110 assert_se((f
= strappend(original_dir
, *p
)));
112 assert_se(mkdir_parents(f
, 0755) >= 0);
113 assert_se(write_string_file(f
, "file", WRITE_STRING_FILE_CREATE
) == 0);
116 STRV_FOREACH_PAIR(link
, p
, links
) {
117 _cleanup_free_
char *f
, *l
;
119 assert_se((f
= strappend(original_dir
, *p
)));
120 assert_se((l
= strappend(original_dir
, *link
)));
122 assert_se(mkdir_parents(l
, 0755) >= 0);
123 assert_se(symlink(f
, l
) == 0);
126 unixsockp
= strjoina(original_dir
, "unixsock");
127 assert_se(mknod(unixsockp
, S_IFSOCK
|0644, 0) >= 0);
129 assert_se(copy_tree(original_dir
, copy_dir
, UID_INVALID
, GID_INVALID
, COPY_REFLINK
|COPY_MERGE
) == 0);
131 STRV_FOREACH(p
, files
) {
132 _cleanup_free_
char *buf
= NULL
, *f
;
135 assert_se((f
= strappend(copy_dir
, *p
)));
137 assert_se(access(f
, F_OK
) == 0);
138 assert_se(read_full_file(f
, &buf
, &sz
) == 0);
139 assert_se(streq(buf
, "file\n"));
142 STRV_FOREACH_PAIR(link
, p
, links
) {
143 _cleanup_free_
char *target
= NULL
, *f
, *l
;
145 assert_se((f
= strjoin(original_dir
, *p
)));
146 assert_se((l
= strjoin(copy_dir
, *link
)));
148 assert_se(readlink_and_canonicalize(l
, NULL
, &target
) == 0);
149 assert_se(path_equal(f
, target
));
152 unixsockp
= strjoina(copy_dir
, "unixsock");
153 assert_se(stat(unixsockp
, &st
) >= 0);
154 assert_se(S_ISSOCK(st
.st_mode
));
156 assert_se(copy_tree(original_dir
, copy_dir
, UID_INVALID
, GID_INVALID
, COPY_REFLINK
) < 0);
157 assert_se(copy_tree("/tmp/inexistent/foo/bar/fsdoi", copy_dir
, UID_INVALID
, GID_INVALID
, COPY_REFLINK
) < 0);
159 (void) rm_rf(copy_dir
, REMOVE_ROOT
|REMOVE_PHYSICAL
);
160 (void) rm_rf(original_dir
, REMOVE_ROOT
|REMOVE_PHYSICAL
);
163 static void test_copy_bytes(void) {
164 _cleanup_close_pair_
int pipefd
[2] = {-1, -1};
165 _cleanup_close_
int infd
= -1;
167 char buf
[1024], buf2
[1024];
169 infd
= open("/usr/lib/os-release", O_RDONLY
|O_CLOEXEC
);
171 infd
= open("/etc/os-release", O_RDONLY
|O_CLOEXEC
);
172 assert_se(infd
>= 0);
174 assert_se(pipe2(pipefd
, O_CLOEXEC
) == 0);
176 r
= copy_bytes(infd
, pipefd
[1], (uint64_t) -1, 0);
179 r
= read(pipefd
[0], buf
, sizeof(buf
));
182 assert_se(lseek(infd
, 0, SEEK_SET
) == 0);
183 r2
= read(infd
, buf2
, sizeof(buf2
));
186 assert_se(strneq(buf
, buf2
, r
));
188 /* test copy_bytes with invalid descriptors */
189 r
= copy_bytes(pipefd
[0], pipefd
[0], 1, 0);
190 assert_se(r
== -EBADF
);
192 r
= copy_bytes(pipefd
[1], pipefd
[1], 1, 0);
193 assert_se(r
== -EBADF
);
195 r
= copy_bytes(pipefd
[1], infd
, 1, 0);
196 assert_se(r
== -EBADF
);
199 static void test_copy_bytes_regular_file(const char *src
, bool try_reflink
, uint64_t max_bytes
) {
200 char fn2
[] = "/tmp/test-copy-file-XXXXXX";
201 char fn3
[] = "/tmp/test-copy-file-XXXXXX";
202 _cleanup_close_
int fd
= -1, fd2
= -1, fd3
= -1;
204 struct stat buf
, buf2
, buf3
;
206 log_info("%s try_reflink=%s max_bytes=%" PRIu64
, __func__
, yes_no(try_reflink
), max_bytes
);
208 fd
= open(src
, O_RDONLY
| O_CLOEXEC
| O_NOCTTY
);
211 fd2
= mkostemp_safe(fn2
);
214 fd3
= mkostemp_safe(fn3
);
217 r
= copy_bytes(fd
, fd2
, max_bytes
, try_reflink
? COPY_REFLINK
: 0);
218 if (max_bytes
== (uint64_t) -1)
221 assert_se(IN_SET(r
, 0, 1));
223 assert_se(lseek(fd2
, 0, SEEK_SET
) == 0);
225 r
= copy_bytes(fd2
, fd3
, max_bytes
, try_reflink
? COPY_REFLINK
: 0);
226 if (max_bytes
== (uint64_t) -1)
229 /* We cannot distinguish between the input being exactly max_bytes
230 * or longer than max_bytes (without trying to read one more byte,
231 * or calling stat, or FION_READ, etc, and we don't want to do any
232 * of that). So we expect "truncation" since we know that file we
233 * are copying is exactly max_bytes bytes. */
236 assert_se(fstat(fd
, &buf
) == 0);
237 assert_se(fstat(fd2
, &buf2
) == 0);
238 assert_se(fstat(fd3
, &buf3
) == 0);
240 assert_se((uint64_t) buf2
.st_size
== MIN((uint64_t) buf
.st_size
, max_bytes
));
241 assert_se(buf3
.st_size
== buf2
.st_size
);
247 int main(int argc
, char *argv
[]) {
252 test_copy_bytes_regular_file(argv
[0], false, (uint64_t) -1);
253 test_copy_bytes_regular_file(argv
[0], true, (uint64_t) -1);
254 test_copy_bytes_regular_file(argv
[0], false, 1000); /* smaller than copy buffer size */
255 test_copy_bytes_regular_file(argv
[0], true, 1000);
256 test_copy_bytes_regular_file(argv
[0], false, 32000); /* larger than copy buffer size */
257 test_copy_bytes_regular_file(argv
[0], true, 32000);