1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
/*
* C Implementation: cow
*
* Copy-on-write functions
*
* License: BSD-style license
* Copyright: Radek Podgorny <radek@podgorny.cz>,
* Bernd Schubert <bernd-schubert@gmx.de>
*/
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <locale.h>
#include <errno.h>
#include <stdio.h>
#include <dirent.h>
#include "opts.h"
#include "findbranch.h"
#include "general.h"
#include "cow.h"
#include "cow_utils.h"
#include "string.h"
#include "debug.h"
#include "usyslog.h"
/**
* l_nbranch (lower nbranch than nbranch) is write protected, create the dir path on
* nbranch for an other COW operation.
*/
int path_create_cow(const char *path, int nbranch_ro, int nbranch_rw) {
DBG("%s\n", path);
if (!uopt.cow_enabled) RETURN(0);
return path_create(path, nbranch_ro, nbranch_rw);
}
/**
* Same as path_create_cow(), but ignore the last segment in path,
* i.e. it might be a filename.
*/
int path_create_cutlast_cow(const char *path, int nbranch_ro, int nbranch_rw) {
DBG("%s\n", path);
char *dname = u_dirname(path);
if (dname == NULL) RETURN(-ENOMEM);
int ret = path_create_cow(dname, nbranch_ro, nbranch_rw);
free(dname);
RETURN(ret);
}
/**
* initiate the cow-copy action
*/
int cow_cp(const char *path, int branch_ro, int branch_rw, bool copy_dir) {
DBG("%s\n", path);
// create the path to the file
path_create_cutlast_cow(path, branch_ro, branch_rw);
char from[PATHLEN_MAX], to[PATHLEN_MAX];
if (BUILD_PATH(from, uopt.branches[branch_ro].path, path)) {
RETURN(-ENAMETOOLONG);
}
if (BUILD_PATH(to, uopt.branches[branch_rw].path, path)) {
RETURN(-ENAMETOOLONG);
}
setlocale(LC_ALL, "");
struct cow cow;
cow.uid = getuid();
// Copy the umask for explicit mode setting.
cow.umask = umask(0);
umask(cow.umask);
cow.from_path = from;
cow.to_path = to;
struct stat buf;
lstat(cow.from_path, &buf);
cow.stat = &buf;
int res;
switch (buf.st_mode & S_IFMT) {
case S_IFLNK:
res = copy_link(&cow);
break;
case S_IFDIR:
if (copy_dir) {
res = copy_directory(path, branch_ro, branch_rw);
} else {
res = path_create_cow(path, branch_ro, branch_rw);
}
break;
case S_IFBLK:
case S_IFCHR:
res = copy_special(&cow);
break;
case S_IFIFO:
res = copy_fifo(&cow);
break;
case S_IFSOCK:
USYSLOG(LOG_WARNING, "COW of sockets not supported: %s\n", cow.from_path);
RETURN(1);
default:
res = copy_file(&cow);
}
RETURN(res);
}
/**
* copy a directory between branches (includes all contents of the directory)
*/
int copy_directory(const char *path, int branch_ro, int branch_rw) {
DBG("%s\n", path);
/* create the directory on the destination branch */
int res = path_create_cow(path, branch_ro, branch_rw);
if (res != 0) {
RETURN(res);
}
/* determine path to source directory on read-only branch */
char from[PATHLEN_MAX];
if (BUILD_PATH(from, uopt.branches[branch_ro].path, path)) RETURN(1);
DIR *dp = opendir(from);
if (dp == NULL) RETURN(1);
struct dirent *de;
while ((de = readdir(dp)) != NULL) {
if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
char member[PATHLEN_MAX];
if (BUILD_PATH(member, path, "/", de->d_name)) {
res = 1;
break;
}
res = cow_cp(member, branch_ro, branch_rw, true);
if (res != 0) break;
}
closedir(dp);
RETURN(res);
}
|
