Merge branch 'maint'
[git/mingw.git] / lockfile.c
blob6d756086939b631ab13bf4fcdb8deed2787eed6b
1 /*
2 * Copyright (c) 2005, Junio C Hamano
3 */
4 #include "cache.h"
6 static struct lock_file *lock_file_list;
7 static const char *alternate_index_output;
9 static void remove_lock_file(void)
11 pid_t me = getpid();
13 while (lock_file_list) {
14 if (lock_file_list->owner == me &&
15 lock_file_list->filename[0]) {
16 if (lock_file_list->fd >= 0)
17 close(lock_file_list->fd);
18 unlink(lock_file_list->filename);
20 lock_file_list = lock_file_list->next;
24 static void remove_lock_file_on_signal(int signo)
26 remove_lock_file();
27 signal(signo, SIG_DFL);
28 raise(signo);
32 * p = absolute or relative path name
34 * Return a pointer into p showing the beginning of the last path name
35 * element. If p is empty or the root directory ("/"), just return p.
37 static char *last_path_elm(char *p)
39 /* r starts pointing to null at the end of the string */
40 char *r = strchr(p, '\0');
42 if (r == p)
43 return p; /* just return empty string */
45 r--; /* back up to last non-null character */
47 /* back up past trailing slashes, if any */
48 while (r > p && *r == '/')
49 r--;
52 * then go backwards until I hit a slash, or the beginning of
53 * the string
55 while (r > p && *(r-1) != '/')
56 r--;
57 return r;
61 /* We allow "recursive" symbolic links. Only within reason, though */
62 #define MAXDEPTH 5
65 * p = path that may be a symlink
66 * s = full size of p
68 * If p is a symlink, attempt to overwrite p with a path to the real
69 * file or directory (which may or may not exist), following a chain of
70 * symlinks if necessary. Otherwise, leave p unmodified.
72 * This is a best-effort routine. If an error occurs, p will either be
73 * left unmodified or will name a different symlink in a symlink chain
74 * that started with p's initial contents.
76 * Always returns p.
79 static char *resolve_symlink(char *p, size_t s)
81 int depth = MAXDEPTH;
83 while (depth--) {
84 char link[PATH_MAX];
85 int link_len = readlink(p, link, sizeof(link));
86 if (link_len < 0) {
87 /* not a symlink anymore */
88 return p;
90 else if (link_len < sizeof(link))
91 /* readlink() never null-terminates */
92 link[link_len] = '\0';
93 else {
94 warning("%s: symlink too long", p);
95 return p;
98 if (is_absolute_path(link)) {
99 /* absolute path simply replaces p */
100 if (link_len < s)
101 strcpy(p, link);
102 else {
103 warning("%s: symlink too long", p);
104 return p;
106 } else {
108 * link is a relative path, so I must replace the
109 * last element of p with it.
111 char *r = (char*)last_path_elm(p);
112 if (r - p + link_len < s)
113 strcpy(r, link);
114 else {
115 warning("%s: symlink too long", p);
116 return p;
120 return p;
124 static int lock_file(struct lock_file *lk, const char *path, int flags)
126 if (strlen(path) >= sizeof(lk->filename))
127 return -1;
128 strcpy(lk->filename, path);
130 * subtract 5 from size to make sure there's room for adding
131 * ".lock" for the lock file name
133 if (!(flags & LOCK_NODEREF))
134 resolve_symlink(lk->filename, sizeof(lk->filename)-5);
135 strcat(lk->filename, ".lock");
136 lk->fd = open(lk->filename, O_RDWR | O_CREAT | O_EXCL, 0666);
137 if (0 <= lk->fd) {
138 if (!lock_file_list) {
139 signal(SIGINT, remove_lock_file_on_signal);
140 signal(SIGHUP, remove_lock_file_on_signal);
141 signal(SIGTERM, remove_lock_file_on_signal);
142 signal(SIGQUIT, remove_lock_file_on_signal);
143 atexit(remove_lock_file);
145 lk->owner = getpid();
146 if (!lk->on_list) {
147 lk->next = lock_file_list;
148 lock_file_list = lk;
149 lk->on_list = 1;
151 if (adjust_shared_perm(lk->filename))
152 return error("cannot fix permission bits on %s",
153 lk->filename);
155 else
156 lk->filename[0] = 0;
157 return lk->fd;
160 int hold_lock_file_for_update(struct lock_file *lk, const char *path, int flags)
162 int fd = lock_file(lk, path, flags);
163 if (fd < 0 && (flags & LOCK_DIE_ON_ERROR))
164 die("unable to create '%s.lock': %s", path, strerror(errno));
165 return fd;
168 int hold_lock_file_for_append(struct lock_file *lk, const char *path, int flags)
170 int fd, orig_fd;
172 fd = lock_file(lk, path, flags);
173 if (fd < 0) {
174 if (flags & LOCK_DIE_ON_ERROR)
175 die("unable to create '%s.lock': %s", path, strerror(errno));
176 return fd;
179 orig_fd = open(path, O_RDONLY);
180 if (orig_fd < 0) {
181 if (errno != ENOENT) {
182 if (flags & LOCK_DIE_ON_ERROR)
183 die("cannot open '%s' for copying", path);
184 close(fd);
185 return error("cannot open '%s' for copying", path);
187 } else if (copy_fd(orig_fd, fd)) {
188 if (flags & LOCK_DIE_ON_ERROR)
189 exit(128);
190 close(fd);
191 return -1;
193 return fd;
196 int close_lock_file(struct lock_file *lk)
198 int fd = lk->fd;
199 lk->fd = -1;
200 return close(fd);
203 int commit_lock_file(struct lock_file *lk)
205 char result_file[PATH_MAX];
206 size_t i;
207 if (lk->fd >= 0 && close_lock_file(lk))
208 return -1;
209 strcpy(result_file, lk->filename);
210 i = strlen(result_file) - 5; /* .lock */
211 result_file[i] = 0;
212 if (rename(lk->filename, result_file))
213 return -1;
214 lk->filename[0] = 0;
215 return 0;
218 int hold_locked_index(struct lock_file *lk, int die_on_error)
220 return hold_lock_file_for_update(lk, get_index_file(),
221 die_on_error
222 ? LOCK_DIE_ON_ERROR
223 : 0);
226 void set_alternate_index_output(const char *name)
228 alternate_index_output = name;
231 int commit_locked_index(struct lock_file *lk)
233 if (alternate_index_output) {
234 if (lk->fd >= 0 && close_lock_file(lk))
235 return -1;
236 if (rename(lk->filename, alternate_index_output))
237 return -1;
238 lk->filename[0] = 0;
239 return 0;
241 else
242 return commit_lock_file(lk);
245 void rollback_lock_file(struct lock_file *lk)
247 if (lk->filename[0]) {
248 if (lk->fd >= 0)
249 close(lk->fd);
250 unlink(lk->filename);
252 lk->filename[0] = 0;