git.el: Fix typo in git-update-saved-file error handling.
[git] / lockfile.c
1 /*
2  * Copyright (c) 2005, Junio C Hamano
3  */
4 #include "cache.h"
5
6 static struct lock_file *lock_file_list;
7 static const char *alternate_index_output;
8
9 static void remove_lock_file(void)
10 {
11         pid_t me = getpid();
12
13         while (lock_file_list) {
14                 if (lock_file_list->owner == me &&
15                     lock_file_list->filename[0])
16                         unlink(lock_file_list->filename);
17                 lock_file_list = lock_file_list->next;
18         }
19 }
20
21 static void remove_lock_file_on_signal(int signo)
22 {
23         remove_lock_file();
24         signal(SIGINT, SIG_DFL);
25         raise(signo);
26 }
27
28 /*
29  * p = absolute or relative path name
30  *
31  * Return a pointer into p showing the beginning of the last path name
32  * element.  If p is empty or the root directory ("/"), just return p.
33  */
34 static char *last_path_elm(char *p)
35 {
36         /* r starts pointing to null at the end of the string */
37         char *r = strchr(p, '\0');
38
39         if (r == p)
40                 return p; /* just return empty string */
41
42         r--; /* back up to last non-null character */
43
44         /* back up past trailing slashes, if any */
45         while (r > p && *r == '/')
46                 r--;
47
48         /*
49          * then go backwards until I hit a slash, or the beginning of
50          * the string
51          */
52         while (r > p && *(r-1) != '/')
53                 r--;
54         return r;
55 }
56
57
58 /* We allow "recursive" symbolic links. Only within reason, though */
59 #define MAXDEPTH 5
60
61 /*
62  * p = path that may be a symlink
63  * s = full size of p
64  *
65  * If p is a symlink, attempt to overwrite p with a path to the real
66  * file or directory (which may or may not exist), following a chain of
67  * symlinks if necessary.  Otherwise, leave p unmodified.
68  *
69  * This is a best-effort routine.  If an error occurs, p will either be
70  * left unmodified or will name a different symlink in a symlink chain
71  * that started with p's initial contents.
72  *
73  * Always returns p.
74  */
75
76 static char *resolve_symlink(char *p, size_t s)
77 {
78         int depth = MAXDEPTH;
79
80         while (depth--) {
81                 char link[PATH_MAX];
82                 int link_len = readlink(p, link, sizeof(link));
83                 if (link_len < 0) {
84                         /* not a symlink anymore */
85                         return p;
86                 }
87                 else if (link_len < sizeof(link))
88                         /* readlink() never null-terminates */
89                         link[link_len] = '\0';
90                 else {
91                         warning("%s: symlink too long", p);
92                         return p;
93                 }
94
95                 if (link[0] == '/') {
96                         /* absolute path simply replaces p */
97                         if (link_len < s)
98                                 strcpy(p, link);
99                         else {
100                                 warning("%s: symlink too long", p);
101                                 return p;
102                         }
103                 } else {
104                         /*
105                          * link is a relative path, so I must replace the
106                          * last element of p with it.
107                          */
108                         char *r = (char*)last_path_elm(p);
109                         if (r - p + link_len < s)
110                                 strcpy(r, link);
111                         else {
112                                 warning("%s: symlink too long", p);
113                                 return p;
114                         }
115                 }
116         }
117         return p;
118 }
119
120
121 static int lock_file(struct lock_file *lk, const char *path)
122 {
123         int fd;
124
125         if (strlen(path) >= sizeof(lk->filename)) return -1;
126         strcpy(lk->filename, path);
127         /*
128          * subtract 5 from size to make sure there's room for adding
129          * ".lock" for the lock file name
130          */
131         resolve_symlink(lk->filename, sizeof(lk->filename)-5);
132         strcat(lk->filename, ".lock");
133         fd = open(lk->filename, O_RDWR | O_CREAT | O_EXCL, 0666);
134         if (0 <= fd) {
135                 if (!lock_file_list) {
136                         signal(SIGINT, remove_lock_file_on_signal);
137                         atexit(remove_lock_file);
138                 }
139                 lk->owner = getpid();
140                 if (!lk->on_list) {
141                         lk->next = lock_file_list;
142                         lock_file_list = lk;
143                         lk->on_list = 1;
144                 }
145                 if (adjust_shared_perm(lk->filename))
146                         return error("cannot fix permission bits on %s",
147                                      lk->filename);
148         }
149         else
150                 lk->filename[0] = 0;
151         return fd;
152 }
153
154 int hold_lock_file_for_update(struct lock_file *lk, const char *path, int die_on_error)
155 {
156         int fd = lock_file(lk, path);
157         if (fd < 0 && die_on_error)
158                 die("unable to create '%s.lock': %s", path, strerror(errno));
159         return fd;
160 }
161
162 int commit_lock_file(struct lock_file *lk)
163 {
164         char result_file[PATH_MAX];
165         int i;
166         strcpy(result_file, lk->filename);
167         i = strlen(result_file) - 5; /* .lock */
168         result_file[i] = 0;
169         i = rename(lk->filename, result_file);
170         lk->filename[0] = 0;
171         return i;
172 }
173
174 int hold_locked_index(struct lock_file *lk, int die_on_error)
175 {
176         return hold_lock_file_for_update(lk, get_index_file(), die_on_error);
177 }
178
179 void set_alternate_index_output(const char *name)
180 {
181         alternate_index_output = name;
182 }
183
184 int commit_locked_index(struct lock_file *lk)
185 {
186         if (alternate_index_output) {
187                 int result = rename(lk->filename, alternate_index_output);
188                 lk->filename[0] = 0;
189                 return result;
190         }
191         else
192                 return commit_lock_file(lk);
193 }
194
195 void rollback_lock_file(struct lock_file *lk)
196 {
197         if (lk->filename[0])
198                 unlink(lk->filename);
199         lk->filename[0] = 0;
200 }