See ChangeLog: Sat Jan 16 09:27:30 CET 1999 Werner Koch
[gnupg.git] / util / dotlock.c
1 /* dotlock.c - dotfile locking
2  *      Copyright (C) 1998 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 #include <sys/utsname.h>
29 #include <sys/types.h>
30 #include <sys/time.h>
31 #include <sys/stat.h>
32 #include <fcntl.h>
33 #include <signal.h>
34 #include "types.h"
35 #include "util.h"
36 #include "memory.h"
37
38
39 static int read_lockfile( const char *name );
40
41 /****************
42  * Create a lockfile with the given name. A TIMEOUT of 0
43  * returns immediately, -1 waits forever (hopefully not), other
44  * values are timeouts in milliseconds.
45  * Returns: a char pointer used as handle for release lock
46  *          or NULL in case of an error.
47  *
48  * Notes: This function creates a lock file in the same directory
49  *        as file_to_lock with the name "file_to_lock.lock"
50  *        A temporary file ".#lk.<hostname>.pid[.threadid] is used.
51  *        This function does nothing for Windoze.
52  */
53 const char *
54 make_dotlock( const char *file_to_lock, long timeout )
55 {
56     int  fd=-1, pid;
57     char pidstr[16];
58     const char *handle = NULL;
59     char *lockname = NULL;
60     char *tname = NULL;
61     int have_tfile = 0;
62     struct utsname uts;
63     const char *nodename;
64     const char *dirpart;
65     int dirpartlen;
66     const char *maybe_dead="";
67     int backoff=0;
68
69     sprintf( pidstr, "%10d\n", getpid() );
70     /* fixme: add the hostname to the second line (FQDN or IP addr?) */
71
72     /* create a temporary file */
73     if( uname( &uts ) )
74         nodename = "unknown";
75     else
76         nodename = uts.nodename;
77
78     if( !(dirpart = strrchr( file_to_lock, '/' )) ) {
79         dirpart = ".";
80         dirpartlen = 1;
81     }
82     else {
83         dirpartlen = dirpart - file_to_lock;
84         dirpart = file_to_lock;
85     }
86
87   #ifdef _THREAD_SAFE
88     tname = m_alloc( dirpartlen + 6 + strlen(nodename) + 11+ 20 );
89     sprintf( tname, "%.*s/.#lk.%s.%d.%p",
90                     dirpartlen, dirpart, nodename, getpid(), &pid );
91   #else
92     tname = m_alloc( dirpartlen + 6 + strlen(nodename) + 11 );
93     sprintf( tname, "%.*s/.#lk.%s.%d",
94                     dirpartlen, dirpart, nodename, getpid() );
95   #endif
96     do {
97         errno = 0;
98         fd = open( tname, O_WRONLY|O_CREAT|O_EXCL,
99                           S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR );
100     } while( fd == -1 && errno == EINTR );
101     if( fd == -1 ) {
102         log_error( "failed to create temporary file `%s': %s\n",
103                                               tname, strerror(errno));
104         goto leave;
105     }
106     have_tfile = 1;
107     if( write(fd, pidstr, 11 ) != 11 ) {
108         log_fatal( "error writing to `%s': %s\n", tname, strerror(errno) );
109         goto leave;
110     }
111     if( close(fd) ) {
112         log_error( "error closing `%s': %s\n", tname, strerror(errno));
113         goto leave;
114     }
115     fd = -1;
116
117     lockname = m_alloc( strlen(file_to_lock) + 6 );
118     strcpy(stpcpy(lockname, file_to_lock), ".lock");
119
120   retry:
121     if( !link(tname, lockname) ) {/* fixme: better use stat to check the link count */
122         handle = lockname;
123         lockname = NULL;
124     }
125     else if( errno == EEXIST ) {
126         if( (pid = read_lockfile(lockname)) == -1 ) {
127             if( errno == ENOENT ) {
128                 log_info( "lockfile disappeared\n");
129                 goto retry;
130             }
131             log_info("cannot read lockfile\n");
132         }
133         else if( pid == getpid() ) {
134             log_info( "Oops: lock already hold by us\n");
135             handle = lockname;
136             lockname = NULL;
137         }
138         else if( kill(pid, 0) && errno == ESRCH ) {
139             maybe_dead = " - probably dead";
140          #if 0 /* we should not do this without checking the permissions */
141                /* and the hostname */
142             log_info( "removing stale lockfile (created by %d)", pid );
143             remove( lockname );
144             goto retry;
145          #endif
146         }
147         if( timeout == -1 ) {
148             struct timeval tv;
149             log_info( "waiting for lock (hold by %d%s) ...\n", pid, maybe_dead );
150             /* can't use sleep, cause signals may be blocked */
151             tv.tv_sec = 1 + backoff;
152             tv.tv_usec = 0;
153             select(0, NULL, NULL, NULL, &tv);
154             if( backoff < 10 )
155                 backoff++ ;
156             goto retry;
157         }
158         /* fixme: implement timeouts */
159     }
160     else
161         log_error( "lock not made: link() failed: %s\n", strerror(errno) );
162
163   leave:
164     if( fd != -1 )
165         close(fd);
166     if( have_tfile )
167         remove(tname);
168     m_free(tname);
169     m_free(lockname);
170     return handle;
171 }
172
173 /****************
174  * Create a lockfile for a existing file
175  * Returns: a char pointer used as handle for release lock
176  *          or NULL in case of an error.
177  *
178  * Notes: This function creates a lock file in the same directory
179  *        as file_to_lock with the name "lock.<inode-no>"
180  *
181  * int
182  * make_inodelock( const char *file_to_lock )
183  *
184  */
185
186
187
188
189 /****************
190  * release a lock
191  * Returns: 0 := success
192  */
193 int
194 release_dotlock( const char *lockfile )
195 {
196     int pid = read_lockfile( lockfile );
197     if( pid == -1 ) {
198         log_error( "release_dotlock: lockfile error");
199         return -1;
200     }
201     if( pid != getpid() ) {
202         log_error( "release_dotlock: not our lock (pid=%d)", pid);
203         return -1;
204     }
205     if( remove( lockfile ) ) {
206         log_error( "release_dotlock: error removing lockfile `%s'",
207                                                             lockfile);
208         return -1;
209     }
210     m_free( (char*)lockfile );
211     return 0;
212 }
213
214
215 /****************
216  * Read the lock file and return the pid, returns -1 on error.
217  */
218 static int
219 read_lockfile( const char *name )
220 {
221     int fd, pid;
222     char pidstr[16];
223
224     if( (fd = open(name, O_RDONLY)) == -1 ) {
225         int e = errno;
226         log_debug("error opening lockfile `%s': %s\n", name, strerror(errno) );
227         errno = e;
228         return -1;
229     }
230     if( read(fd, pidstr, 10 ) != 10 ) {
231         log_debug("error reading lockfile `%s'", name );
232         close(fd);
233         errno = 0;
234         return -1;
235     }
236     close(fd);
237     pid = atoi(pidstr);
238     if( !pid || pid == -1 ) {
239         log_error("invalid pid %d in lockfile `%s'", pid, name );
240         errno = 0;
241         return -1;
242     }
243     return pid;
244 }
245