Finished the bulk of changes for gnupg 1.9. This included switching
[gnupg.git] / jnlib / dotlock.c
1 /* dotlock.c - dotfile locking
2  *      Copyright (C) 1998,2000,2001,2003 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <ctype.h>
26 #include <errno.h>
27 #include <unistd.h>
28 #ifndef  HAVE_DOSISH_SYSTEM
29 #include <sys/utsname.h>
30 #endif
31 #include <sys/types.h>
32 #include <sys/time.h>
33 #include <sys/stat.h>
34 #include <fcntl.h>
35 #include <signal.h>
36
37 #include "libjnlib-config.h"
38 #include "dotlock.h"
39
40 struct dotlock_handle {
41     struct dotlock_handle *next;
42     char *tname;    /* name of lockfile template */
43     char *lockname; /* name of the real lockfile */
44     int locked;     /* lock status */
45     int disable;    /* locking */
46 };
47
48
49 static volatile DOTLOCK all_lockfiles;
50 static int never_lock;
51
52 static int read_lockfile( const char *name );
53
54 void
55 disable_dotlock(void)
56 {
57     never_lock = 1;
58 }
59
60 /****************
61  * Create a lockfile with the given name and return an object of
62  * type DOTLOCK which may be used later to actually do the lock.
63  * A cleanup routine gets installed to cleanup left over locks
64  * or other files used together with the lockmechanism.
65  * Althoug the function is called dotlock, this does not necessarily
66  * mean that real lockfiles are used - the function may decide to
67  * use fcntl locking.  Calling the function with NULL only install
68  * the atexit handler and maybe used to assure that the cleanup
69  * is called after all other atexit handlers.
70  *
71  * Notes: This function creates a lock file in the same directory
72  *        as file_to_lock with the name "file_to_lock.lock"
73  *        A temporary file ".#lk.<hostname>.pid[.threadid] is used.
74  *        This function does nothing for Windoze.
75  */
76 DOTLOCK
77 create_dotlock( const char *file_to_lock )
78 {
79     static int initialized;
80     DOTLOCK h;
81     int  fd = -1;
82     char pidstr[16];
83   #ifndef  HAVE_DOSISH_SYSTEM
84     struct utsname utsbuf;
85   #endif
86     const char *nodename;
87     const char *dirpart;
88     int dirpartlen;
89
90     if( !initialized ) {
91         atexit( dotlock_remove_lockfiles );
92         initialized = 1;
93     }
94     if( !file_to_lock )
95         return NULL;
96
97     h = jnlib_xcalloc( 1, sizeof *h );
98     if( never_lock ) {
99         h->disable = 1;
100 #ifdef _REENTRANT
101         /* fixme: aquire mutex on all_lockfiles */
102 #endif
103         h->next = all_lockfiles;
104         all_lockfiles = h;
105         return h;
106     }
107
108 #ifndef HAVE_DOSISH_SYSTEM
109     sprintf( pidstr, "%10d\n", (int)getpid() );
110     /* fixme: add the hostname to the second line (FQDN or IP addr?) */
111
112     /* create a temporary file */
113     if( uname( &utsbuf ) )
114         nodename = "unknown";
115     else
116         nodename = utsbuf.nodename;
117
118 #ifdef __riscos__
119     {
120         char *iter = (char *) nodename;
121         for (; iter[0]; iter++)
122             if (iter[0] == '.')
123                 iter[0] = '/';
124     }
125 #endif /* __riscos__ */
126
127     if( !(dirpart = strrchr( file_to_lock, DIRSEP_C )) ) {
128         dirpart = EXTSEP_S;
129         dirpartlen = 1;
130     }
131     else {
132         dirpartlen = dirpart - file_to_lock;
133         dirpart = file_to_lock;
134     }
135
136   #ifdef _REENTRANT
137     /* fixme: aquire mutex on all_lockfiles */
138   #endif
139     h->next = all_lockfiles;
140     all_lockfiles = h;
141
142     h->tname = jnlib_xmalloc( dirpartlen + 6+30+ strlen(nodename) + 11 );
143 #ifndef __riscos__
144      sprintf( h->tname, "%.*s/.#lk%p.%s.%d",
145              dirpartlen, dirpart, h, nodename, (int)getpid() );
146 #else /* __riscos__ */
147     sprintf( h->tname, "%.*s.lk%p/%s/%d",
148              dirpartlen, dirpart, h, nodename, (int)getpid() );
149 #endif /* __riscos__ */
150
151     do {
152         errno = 0;
153         fd = open( h->tname, O_WRONLY|O_CREAT|O_EXCL,
154                           S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR );
155     } while( fd == -1 && errno == EINTR );
156     if( fd == -1 ) {
157         all_lockfiles = h->next;
158         log_error( "failed to create temporary file `%s': %s\n",
159                                             h->tname, strerror(errno));
160         jnlib_free(h->tname);
161         jnlib_free(h);
162         return NULL;
163     }
164     if( write(fd, pidstr, 11 ) != 11 ) {
165         all_lockfiles = h->next;
166       #ifdef _REENTRANT
167         /* release mutex */
168       #endif
169         log_fatal( "error writing to `%s': %s\n", h->tname, strerror(errno) );
170         close(fd);
171         unlink(h->tname);
172         jnlib_free(h->tname);
173         jnlib_free(h);
174         return NULL;
175     }
176     if( close(fd) ) {
177         all_lockfiles = h->next;
178       #ifdef _REENTRANT
179         /* release mutex */
180       #endif
181         log_fatal( "error writing to `%s': %s\n", h->tname, strerror(errno) );
182         close(fd);
183         unlink(h->tname);
184         jnlib_free(h->tname);
185         jnlib_free(h);
186         return NULL;
187     }
188
189   #ifdef _REENTRANT
190     /* release mutex */
191   #endif
192 #endif /* !HAVE_DOSISH_SYSTEM */
193     h->lockname = jnlib_xmalloc( strlen(file_to_lock) + 6 );
194     strcpy(stpcpy(h->lockname, file_to_lock), EXTSEP_S "lock");
195     return h;
196 }
197
198 static int
199 maybe_deadlock( DOTLOCK h )
200 {
201     DOTLOCK r;
202
203     for( r=all_lockfiles; r; r = r->next ) {
204         if( r != h && r->locked )
205             return 1;
206     }
207     return 0;
208 }
209
210 /****************
211  * Do a lock on H. A TIMEOUT of 0 returns immediately,
212  * -1 waits forever (hopefully not), other
213  * values are timeouts in milliseconds.
214  * Returns: 0 on success
215  */
216 int
217 make_dotlock( DOTLOCK h, long timeout )
218 {
219 #ifdef HAVE_DOSISH_SYSTEM
220     return 0;
221 #else
222     int  pid;
223     const char *maybe_dead="";
224     int backoff=0;
225
226     if( h->disable ) {
227         return 0;
228     }
229
230     if( h->locked ) {
231 #ifndef __riscos__
232         log_debug("oops, `%s' is already locked\n", h->lockname );
233 #endif /* !__riscos__ */
234         return 0;
235     }
236
237     for(;;) {
238 #ifndef __riscos__
239         if( !link(h->tname, h->lockname) ) {
240             /* fixme: better use stat to check the link count */
241             h->locked = 1;
242             return 0; /* okay */
243         }
244         if( errno != EEXIST ) {
245             log_error( "lock not made: link() failed: %s\n", strerror(errno) );
246             return -1;
247         }
248 #else /* __riscos__ */
249         if( !renamefile(h->tname, h->lockname) ) {
250             h->locked = 1;
251             return 0; /* okay */
252         }
253         if( errno != EEXIST ) {
254             log_error( "lock not made: rename() failed: %s\n", strerror(errno) );
255             return -1;
256         }
257 #endif /* __riscos__ */
258         if( (pid = read_lockfile(h->lockname)) == -1 ) {
259             if( errno != ENOENT ) {
260                 log_info("cannot read lockfile\n");
261                 return -1;
262             }
263             log_info( "lockfile disappeared\n");
264             continue;
265         }
266         else if( pid == getpid() ) {
267             log_info( "Oops: lock already held by us\n");
268             h->locked = 1;
269             return 0; /* okay */
270         }
271         else if( kill(pid, 0) && errno == ESRCH ) {
272 #ifndef __riscos__
273             maybe_dead = " - probably dead";
274 #if 0 /* we should not do this without checking the permissions */
275                /* and the hostname */
276             log_info( "removing stale lockfile (created by %d)", pid );
277 #endif
278 #else /* __riscos__ */
279             /* we are *pretty* sure that the other task is dead and therefore
280                we remove the other lock file */
281             maybe_dead = " - probably dead - removing lock";
282             unlink(h->lockname);
283 #endif /* __riscos__ */
284         }
285         if( timeout == -1 ) {
286             struct timeval tv;
287             log_info( "waiting for lock (held by %d%s) %s...\n",
288                       pid, maybe_dead, maybe_deadlock(h)? "(deadlock?) ":"");
289
290
291             /* can't use sleep, cause signals may be blocked */
292             tv.tv_sec = 1 + backoff;
293             tv.tv_usec = 0;
294             select(0, NULL, NULL, NULL, &tv);
295             if( backoff < 10 )
296                 backoff++ ;
297         }
298         else
299             return -1;
300     }
301     /*not reached */
302 #endif /* !HAVE_DOSISH_SYSTEM */
303 }
304
305
306 /****************
307  * release a lock
308  * Returns: 0 := success
309  */
310 int
311 release_dotlock( DOTLOCK h )
312 {
313 #ifdef HAVE_DOSISH_SYSTEM
314     return 0;
315 #else
316     int pid;
317
318     if( h->disable ) {
319         return 0;
320     }
321
322     if( !h->locked ) {
323         log_debug("oops, `%s' is not locked\n", h->lockname );
324         return 0;
325     }
326
327     pid = read_lockfile( h->lockname );
328     if( pid == -1 ) {
329         log_error( "release_dotlock: lockfile error\n");
330         return -1;
331     }
332     if( pid != getpid() ) {
333         log_error( "release_dotlock: not our lock (pid=%d)\n", pid);
334         return -1;
335     }
336 #ifndef __riscos__
337     if( unlink( h->lockname ) ) {
338         log_error( "release_dotlock: error removing lockfile `%s'",
339                                                         h->lockname);
340         return -1;
341     }
342 #else /* __riscos__ */
343     if( renamefile(h->lockname, h->tname) ) {
344         log_error( "release_dotlock: error renaming lockfile `%s' to `%s'",
345                                                         h->lockname, h->tname);
346         return -1;
347     }
348 #endif /* __riscos__ */
349     /* fixme: check that the link count is now 1 */
350     h->locked = 0;
351     return 0;
352 #endif /* !HAVE_DOSISH_SYSTEM */
353 }
354
355
356 /****************
357  * Read the lock file and return the pid, returns -1 on error.
358  */
359 static int
360 read_lockfile( const char *name )
361 {
362 #ifdef HAVE_DOSISH_SYSTEM
363     return 0;
364 #else
365     int fd, pid;
366     char pidstr[16];
367
368     if( (fd = open(name, O_RDONLY)) == -1 ) {
369         int e = errno;
370         log_debug("error opening lockfile `%s': %s\n", name, strerror(errno) );
371         errno = e;
372         return -1;
373     }
374     if( read(fd, pidstr, 10 ) != 10 ) {  /* Read 10 digits w/o newline */
375         log_debug("error reading lockfile `%s'", name );
376         close(fd);
377         errno = 0;
378         return -1;
379     }
380     pidstr[10] = 0;  /* terminate pid string */
381     close(fd);
382     pid = atoi(pidstr);
383 #ifndef __riscos__
384     if( !pid || pid == -1 ) {
385 #else /* __riscos__ */
386     if( (!pid && riscos_getpid()) || pid == -1 ) {
387 #endif /* __riscos__ */
388         log_error("invalid pid %d in lockfile `%s'", pid, name );
389         errno = 0;
390         return -1;
391     }
392     return pid;
393 #endif
394 }
395
396
397 void
398 dotlock_remove_lockfiles()
399 {
400 #ifndef HAVE_DOSISH_SYSTEM
401     DOTLOCK h, h2;
402
403     h = all_lockfiles;
404     all_lockfiles = NULL;
405
406     while( h ) {
407         h2 = h->next;
408         if (!h->disable ) {
409           if( h->locked )
410             unlink( h->lockname );
411           unlink(h->tname);
412           jnlib_free(h->tname);
413           jnlib_free(h->lockname);
414         }
415         jnlib_free(h);
416         h = h2;
417     }
418 #endif
419 }
420