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