imapfilter/imapfilter/lock.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <limits.h>
#include <sys/stat.h>
#include <signal.h>

#include "config.h"
#include "imapfilter.h"
#include "pathnames.h"


extern char *home;

static char *lockfile = NULL;   /* Lock file to stop new imapfilter processes. */


pid_t lockfile_pid(void);


/*
 * Create lockfile with the PID of imapfilter as its contents.
 */
void
lockfile_create(void)
{
        FILE *fd;

        create_file(lockfile, S_IRUSR | S_IWUSR);

        fd = fopen(lockfile, "w");
        if (fd == NULL)
                fatal(ERROR_FILEOPEN, "opening lockfile; %s\n",
                    strerror(errno));
        fprintf(fd, "%s\n", ultostr(getpid(), 10));
        fclose(fd);
}


/*
 * Die if another instance of imapfilter is running.
 */
void
lockfile_check(void)
{
        pid_t n;

        if ((n = lockfile_pid())) {
                errno = 0;
                kill(n, 0);
                if (errno == ESRCH) {   /* Process does not exist. */
                        fprintf(stderr, "imapfilter: removing stale lockfile\n");
                        lockfile_remove();
                } else {
                        fprintf(stderr,
                            "imapfilter: another imapfilter "
                            "is running with pid %d\n", (int)(n));
                        exit(ERROR_LOCKFILE);
                }
        }
}


/*
 * Check if lockfile exists and if so, return the PID of the other
 * imapfilter running.
 */
pid_t
lockfile_pid(void)
{
        char line[LINE_MAX];
        char lockf[PATH_MAX];
        FILE *fd;
        pid_t n;

        n = 0;

        snprintf(lockf, PATH_MAX, "%s/%s", home, PATHNAME_LOCK);
        lockfile = xstrdup(lockf);

        if (exists_file(lockfile)) {
                fd = fopen(lockfile, "r");
                if (fd == NULL)
                        fatal(ERROR_FILEOPEN, "opening lockfile; %s\n",
                            strerror(errno));
                if (fgets(line, LINE_MAX - 1, fd)) {
                        errno = 0;
                        n = strtoul(line, NULL, 10);
                        if (errno)
                                n = 0;
                }
                fclose(fd);
        }
        return n;
}


/*
 * Unlink the lockfile.
 */
int
lockfile_remove(void)
{

        if (lockfile == NULL)
                return 0;

        if (unlink(lockfile) && errno != ENOENT) {
                error("removing lockfile; %s\n", strerror(errno));
                return ERROR_FILEOPEN;
        }
        return 0;
}


/*
 * Kill the other instance of imapfilter (if one is running).
 */
void
kill_imapfilter(void)
{
        pid_t n;

        n = lockfile_pid();

        if (n > 0) {
                if (kill(n, SIGTERM))
                        fprintf(stderr, "imapfilter: killing process with "
                            "pid %d; %s\n", (int)(n), strerror(errno));
                lockfile_remove();
                exit(0);
        } else {
                fprintf(stderr, "imapfilter: no other imapfilter is running\n");
                exit(ERROR_UNDEFINED);
        }
}
1	#include <stdio.h>
2	#include <stdlib.h>
3	#include <sys/types.h>
4	#include <unistd.h>
5	#include <string.h>
6	#include <errno.h>
7	#include <limits.h>
8	#include <sys/stat.h>
9	#include <signal.h>
10
11	#include "config.h"
12	#include "imapfilter.h"
13	#include "pathnames.h"
14
15
16	extern char *home;
17
18	static char lockfile = NULL; / Lock file to stop new imapfilter processes. */
19
20
21	pid_t lockfile_pid(void);
22
23
24	/*
25	* Create lockfile with the PID of imapfilter as its contents.
26	*/
27	void
28	lockfile_create(void)
29	{
30	FILE *fd;
31
32	create_file(lockfile, S_IRUSR \| S_IWUSR);
33
34	fd = fopen(lockfile, "w");
35	if (fd == NULL)
36	fatal(ERROR_FILEOPEN, "opening lockfile; %s\n",
37	strerror(errno));
38	fprintf(fd, "%s\n", ultostr(getpid(), 10));
39	fclose(fd);
40	}
41
42
43	/*
44	* Die if another instance of imapfilter is running.
45	*/
46	void
47	lockfile_check(void)
48	{
49	pid_t n;
50
51	if ((n = lockfile_pid())) {
52	errno = 0;
53	kill(n, 0);
54	if (errno == ESRCH) { /* Process does not exist. */
55	fprintf(stderr, "imapfilter: removing stale lockfile\n");
56	lockfile_remove();
57	} else {
58	fprintf(stderr,
59	"imapfilter: another imapfilter "
60	"is running with pid %d\n", (int)(n));
61	exit(ERROR_LOCKFILE);
62	}
63	}
64	}
65
66
67	/*
68	* Check if lockfile exists and if so, return the PID of the other
69	* imapfilter running.
70	*/
71	pid_t
72	lockfile_pid(void)
73	{
74	char line[LINE_MAX];
75	char lockf[PATH_MAX];
76	FILE *fd;
77	pid_t n;
78
79	n = 0;
80
81	snprintf(lockf, PATH_MAX, "%s/%s", home, PATHNAME_LOCK);
82	lockfile = xstrdup(lockf);
83
84	if (exists_file(lockfile)) {
85	fd = fopen(lockfile, "r");
86	if (fd == NULL)
87	fatal(ERROR_FILEOPEN, "opening lockfile; %s\n",
88	strerror(errno));
89	if (fgets(line, LINE_MAX - 1, fd)) {
90	errno = 0;
91	n = strtoul(line, NULL, 10);
92	if (errno)
93	n = 0;
94	}
95	fclose(fd);
96	}
97	return n;
98	}
99
100
101	/*
102	* Unlink the lockfile.
103	*/
104	int
105	lockfile_remove(void)
106	{
107
108	if (lockfile == NULL)
109	return 0;
110
111	if (unlink(lockfile) && errno != ENOENT) {
112	error("removing lockfile; %s\n", strerror(errno));
113	return ERROR_FILEOPEN;
114	}
115	return 0;
116	}
117
118
119	/*
120	* Kill the other instance of imapfilter (if one is running).
121	*/
122	void
123	kill_imapfilter(void)
124	{
125	pid_t n;
126
127	n = lockfile_pid();
128
129	if (n > 0) {
130	if (kill(n, SIGTERM))
131	fprintf(stderr, "imapfilter: killing process with "
132	"pid %d; %s\n", (int)(n), strerror(errno));
133	lockfile_remove();
134	exit(0);
135	} else {
136	fprintf(stderr, "imapfilter: no other imapfilter is running\n");
137	exit(ERROR_UNDEFINED);
138	}
139	}