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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
/* Implement ln -f "atomically"
Copyright 2017-2021 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>. */
/* Written by Paul Eggert. */
/* A naive "ln -f A B" unlinks B and then links A to B. This module
instead links A to a randomly-named temporary T in B's directory,
and then renames T to B. This approach has a window with a
randomly-named temporary, which is safer for many applications than
a window where B does not exist. */
#include <config.h>
#include "system.h"
#include "force-link.h"
#include <tempname.h>
/* A basename pattern suitable for a temporary file. It should work
even on file systems like FAT that support only short names.
"Cu" is short for "Coreutils" or for "Changeable unstable",
take your pick.... */
static char const simple_pattern[] = "CuXXXXXX";
enum { x_suffix_len = sizeof "XXXXXX" - 1 };
/* A size for smallish buffers containing file names. Longer file
names can use malloc. */
enum { smallsize = 256 };
/* Return a template for a file in the same directory as DSTNAME.
Use BUF if the template fits, otherwise use malloc and return NULL
(setting errno) if unsuccessful. */
static char *
samedir_template (char const *dstname, char buf[smallsize])
{
ptrdiff_t dstdirlen = last_component (dstname) - dstname;
size_t dsttmpsize = dstdirlen + sizeof simple_pattern;
char *dsttmp;
if (dsttmpsize <= smallsize)
dsttmp = buf;
else
{
dsttmp = malloc (dsttmpsize);
if (!dsttmp)
return dsttmp;
}
strcpy (mempcpy (dsttmp, dstname, dstdirlen), simple_pattern);
return dsttmp;
}
/* Auxiliaries for force_linkat. */
struct link_arg
{
int srcdir;
char const *srcname;
int dstdir;
int flags;
};
static int
try_link (char *dest, void *arg)
{
struct link_arg *a = arg;
return linkat (a->srcdir, a->srcname, a->dstdir, dest, a->flags);
}
/* Hard-link directory SRCDIR's file SRCNAME to directory DSTDIR's
file DSTNAME, using linkat-style FLAGS to control the linking.
If FORCE and DSTNAME already exists, replace it atomically.
If LINKAT_ERRNO is 0, the hard link is already done; if positive,
the hard link was tried and failed with errno == LINKAT_ERRNO. Return
-1 if successful and DSTNAME already existed,
0 if successful and DSTNAME did not already exist, and
a positive errno value on failure. */
extern int
force_linkat (int srcdir, char const *srcname,
int dstdir, char const *dstname, int flags, bool force,
int linkat_errno)
{
if (linkat_errno < 0)
linkat_errno = (linkat (srcdir, srcname, dstdir, dstname, flags) == 0
? 0 : errno);
if (!force || linkat_errno != EEXIST)
return linkat_errno;
char buf[smallsize];
char *dsttmp = samedir_template (dstname, buf);
if (! dsttmp)
return errno;
struct link_arg arg = { srcdir, srcname, dstdir, flags };
int err;
if (try_tempname_len (dsttmp, 0, &arg, try_link, x_suffix_len) != 0)
err = errno;
else
{
err = renameat (dstdir, dsttmp, dstdir, dstname) == 0 ? -1 : errno;
/* Unlink DSTTMP even if renameat succeeded, in case DSTTMP
and DSTNAME were already the same hard link and renameat
was a no-op. */
unlinkat (dstdir, dsttmp, 0);
}
if (dsttmp != buf)
free (dsttmp);
return err;
}
/* Auxiliaries for force_symlinkat. */
struct symlink_arg
{
char const *srcname;
int dstdir;
};
static int
try_symlink (char *dest, void *arg)
{
struct symlink_arg *a = arg;
return symlinkat (a->srcname, a->dstdir, dest);
}
/* Create a symlink containing SRCNAME in directory DSTDIR's file DSTNAME.
If FORCE and DSTNAME already exists, replace it atomically.
If SYMLINKAT_ERRNO is 0, the symlink is already done; if positive,
the symlink was tried and failed with errno == SYMLINKAT_ERRNO. Return
-1 if successful and DSTNAME already existed,
0 if successful and DSTNAME did not already exist, and
a positive errno value on failure. */
extern int
force_symlinkat (char const *srcname, int dstdir, char const *dstname,
bool force, int symlinkat_errno)
{
if (symlinkat_errno < 0)
symlinkat_errno = symlinkat (srcname, dstdir, dstname) == 0 ? 0 : errno;
if (!force || symlinkat_errno != EEXIST)
return symlinkat_errno;
char buf[smallsize];
char *dsttmp = samedir_template (dstname, buf);
if (!dsttmp)
return errno;
struct symlink_arg arg = { srcname, dstdir };
int err;
if (try_tempname_len (dsttmp, 0, &arg, try_symlink, x_suffix_len) != 0)
err = errno;
else if (renameat (dstdir, dsttmp, dstdir, dstname) != 0)
{
err = errno;
unlinkat (dstdir, dsttmp, 0);
}
else
{
/* Don't worry about renameat being a no-op, since DSTTMP is
newly created. */
err = -1;
}
if (dsttmp != buf)
free (dsttmp);
return err;
}
|
