![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rsync.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pimd / libite|
Return to rsync.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pimd / libite |
1.1 misho 1: /* Micro "rsync" implementation.
2: *
3: * Copyright (c) 2011, 2012 Joachim Nilsson <troglobit@gmail.com>
4: *
5: * Permission to use, copy, modify, and/or distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16: */
17:
18: #include <errno.h>
19: #include <stdlib.h> /* NULL, free() */
20: #include <string.h> /* strlen() */
21: #include <strings.h> /* rindex() */
22: #include <stdio.h>
23: #include <sys/param.h> /* MAX(), isset(), setbit(), TRUE, FALSE, et consortes. :-) */
24: #include <sys/stat.h>
25: #include <sys/types.h>
26:
27: #include "lite.h"
28:
29: static int copy(char *src, char *dst);
30: static int mdir(char *buf, size_t buf_len, char *dir, char *name, mode_t mode);
31: static int prune(char *dst, char **new_files, int new_num);
32:
33:
34: /**
35: * rsync - Synchronize contents and optionally remove non-existing backups
36: * @src: Source directory
37: * @dst: Destination directory
38: * @delete: Prune files from @dst that no longer exist in @src.
39: * @filter: Optional filtering function for source directory.
40: *
41: * This is a miniature implementation of the famous rsync for local use only.
42: * In fact, it is not even a true rsync since it copies all files from @src
43: * to @dst. The @delete option is useful for creating backups, when set all
44: * files removed from src since last backup are pruned from the destination
45: * (backup) directory.
46: *
47: * The filter callback, @filter, if provided, is used to determine what files to
48: * include from the source directory when backing up. If a file is to be skipped
49: * the callback should simply return zero.
50: *
51: * Returns:
52: * POSIX OK(0), or non-zero with @errno set on error.
53: */
54: int rsync(char *src, char *dst, int delete, int (*filter) (const char *file))
55: {
56: char source[256];
57: char dest[256];
58: int i = 0, num = 0, result = 0;
59: char **files; /* Array of file names. */
60:
61: if (!fisdir(dst))
62: makedir(dst, 0755);
63:
64: if (!fisdir(src)) {
65: if (!fexist(src))
66: return 1;
67:
68: if (copy(src, dst))
69: result++;
70:
71: return errno;
72: }
73:
74: /* Copy dir as well? */
75: if (!fisslashdir(src)) {
76: char *ptr = rindex(src, '/');
77:
78: if (!ptr)
79: ptr = src;
80: else
81: ptr++;
82:
83: if (mdir(dest, sizeof(dest), dst, ptr, fmode(src)))
84: return 1;
85: dst = dest;
86: }
87:
88: num = dir(src, "", filter, &files, 0);
89: for (i = 0; i < num; i++) {
90: /* Recursively copy sub-directries */
91: snprintf(source, sizeof(source), "%s%s%s", src, fisslashdir(src) ? "" : "/", files[i]);
92: if (fisdir(source)) {
93: char dst2[256];
94:
95: strcat(source, "/");
96: if (mdir (dst2, sizeof(dst2), dst, files[i], fmode(source))) {
97: result++;
98: continue;
99: }
100:
101: rsync(source, dst2, delete, filter);
102: continue; /* Next file/dir in @src to copy... */
103: }
104:
105: if (copy(source, dst))
106: result++;
107: }
108:
109: /* We ignore any errors from the pruning, that phase albeit useful is only
110: * cosmetic. --Jocke 2011-03-24 */
111: if (delete)
112: prune(dst, files, num);
113:
114: if (num) {
115: for (i = 0; i < num; i++)
116: free(files[i]);
117: free(files);
118: }
119:
120: return result;
121: }
122:
123: static int copy(char *src, char *dst)
124: {
125: errno = 0;
126:
127: copyfile(src, dst, 0, 1);
128: if (errno) {
129: if (errno != EEXIST)
130: return 1;
131:
132: errno = 0;
133: }
134:
135: return 0;
136: }
137:
138: /* Creates dir/name @mode ... skipping / if dir already ends so. */
139: static int mdir(char *buf, size_t buf_len, char *dir, char *name, mode_t mode)
140: {
141: snprintf(buf, buf_len, "%s%s%s/", dir, fisslashdir(dir) ? "" : "/", name);
142: if (mkdir(buf, mode)) {
143: if (EEXIST != errno)
144: return 1;
145:
146: errno = 0;
147: }
148:
149: return 0;
150: }
151:
152:
153: static int find(char *file, char **files, int num)
154: {
155: int n;
156:
157: for (n = 0; n < num; n++)
158: if (!strncmp (files[n], file, MAX(strlen(files[n]), strlen(file))))
159: return 1;
160:
161: return 0;
162: }
163:
164:
165: /* Prune old files, no longer existing on source, from destination directory. */
166: static int prune(char *dst, char **new_files, int new_num)
167: {
168: int num, result = 0;
169: char **files;
170:
171: num = dir(dst, "", NULL, &files, 0);
172: if (num) {
173: int i;
174:
175: for (i = 0; i < num; i++) {
176: if (!find(files[i], new_files, new_num)) {
177: char *name;
178: size_t len = strlen(files[i]) + 2 + strlen(dst);
179:
180: name = malloc(len);
181: if (name) {
182: snprintf(name, len, "%s%s%s", dst, fisslashdir(dst) ? "" : "/", files[i]);
183: if (remove(name))
184: result++;
185: free(name);
186: }
187: }
188: free(files[i]);
189: }
190: free(files);
191: }
192:
193: return result;
194: }
195:
196: #ifdef UNITTEST
197: #define BASE "/tmp/.unittest/"
198: #define SRC BASE "src/"
199: #define DST BASE "dst/"
200:
201: static int verbose = 0;
202: static char *files[] = {
203: SRC "sub1/1.tst",
204: SRC "sub1/2.tst",
205: SRC "sub1/3.tst",
206: SRC "sub2/4.tst",
207: SRC "sub2/5.tst",
208: SRC "sub2/6.tst",
209: SRC "sub3/7.tst",
210: SRC "sub3/8.tst",
211: SRC "sub3/9.tst",
212: NULL
213: };
214:
215: void cleanup_test(void)
216: {
217: system("rm -rf " BASE);
218: }
219:
220: void setup_test(void)
221: {
222: int i;
223: char cmd[256];
224: mode_t dir_modes[] = { 755, 700 };
225: mode_t file_modes[] = { 644, 600 };
226:
227: cleanup_test();
228:
229: mkdir(BASE, 0755);
230: mkdir(SRC, 0755);
231: mkdir(DST, 0755);
232:
233: for (i = 0; files[i]; i++) {
234: snprintf(cmd, sizeof(cmd), "mkdir -m %d -p `dirname %s`",
235: dir_modes[i % 2], files[i]);
236: system(cmd);
237:
238: snprintf(cmd, sizeof(cmd), "touch %s; chmod %d %s", files[i],
239: file_modes[i % 2], files[i]);
240: system(cmd);
241: }
242: }
243:
244: static void check_tree(char *heading, char *dir)
245: {
246: if (verbose) {
247: char cmd[128];
248:
249: if (heading)
250: puts(heading);
251:
252: tree(dir, 1);
253: }
254: }
255:
256: int run_test(void)
257: {
258: int result = 0;
259:
260: #if 0
261: setup_test();
262: check_tree("Before:", BASE);
263:
264: result += rsync(SRC, DST, 0, NULL);
265: check_tree("After:", BASE);
266: cleanup_test();
267: #endif
268:
269: setup_test();
270: result += rsync(BASE "src", DST, 0, NULL);
271: check_tree("Only partial rsync of src <-- No slash!", BASE);
272: #if 0
273: cleanup_test();
274: setup_test();
275: result += rsync(BASE "src/sub1", BASE "dst", 0, NULL);
276: check_tree("Only partial rsync of src/sub1 <-- No slashes!!", BASE);
277:
278: cleanup_test();
279: setup_test();
280: result += rsync(BASE "src/sub1/", DST, 0, NULL);
281: check_tree("Only partial rsync of src/sub1/", BASE);
282:
283: cleanup_test();
284: setup_test();
285: result += rsync(BASE "src/sub1", DST, 0, NULL);
286: check_tree("Only partial rsync of src/sub1 <-- No slash!", BASE);
287:
288: result += rsync("/etc", "/var/tmp", 0, NULL);
289: check_tree("Real life test:", "/var/tmp");
290: #endif
291:
292: return result;
293: }
294:
295: int main(int argc, char *argv[])
296: {
297: if (argc > 1)
298: verbose = !strncmp("-v", argv[1], 2);
299:
300: atexit(cleanup_test);
301:
302: return run_test();
303: }
304: #endif /* UNITTEST */
305:
306: /**
307: * Local Variables:
308: * compile-command: "make V=1 -f rsync.mk"
309: * version-control: t
310: * indent-tabs-mode: t
311: * c-file-style: "linux"
312: * End:
313: */