d8e2c011701b05a539ba4c65ea83545541204542
[nfs-utils.git] / utils / statd / sm-notify.c
1 /*
2  * Send NSM notify calls to all hosts listed in /var/lib/sm
3  *
4  * Copyright (C) 2004-2006 Olaf Kirch <okir@suse.de>
5  */
6
7 #ifdef HAVE_CONFIG_H
8 #include <config.h>
9 #endif
10
11 #include <sys/types.h>
12 #include <sys/socket.h>
13 #include <sys/stat.h>
14 #include <sys/poll.h>
15 #include <sys/param.h>
16 #include <sys/syslog.h>
17 #include <arpa/inet.h>
18 #include <dirent.h>
19 #include <time.h>
20 #include <stdio.h>
21 #include <getopt.h>
22 #include <stdlib.h>
23 #include <fcntl.h>
24 #include <unistd.h>
25 #include <string.h>
26 #include <stdarg.h>
27 #include <netdb.h>
28 #include <errno.h>
29 #include <grp.h>
30
31 #ifndef BASEDIR
32 # ifdef NFS_STATEDIR
33 #  define BASEDIR               NFS_STATEDIR
34 # else
35 #  define BASEDIR               "/var/lib/nfs"
36 # endif
37 #endif
38
39 #define DEFAULT_SM_STATE_PATH   BASEDIR "/state"
40 #define DEFAULT_SM_DIR_PATH     BASEDIR "/sm"
41 #define DEFAULT_SM_BAK_PATH     DEFAULT_SM_DIR_PATH ".bak"
42
43 char *_SM_BASE_PATH = BASEDIR;
44 char *_SM_STATE_PATH = DEFAULT_SM_STATE_PATH;
45 char *_SM_DIR_PATH = DEFAULT_SM_DIR_PATH;
46 char *_SM_BAK_PATH = DEFAULT_SM_BAK_PATH;
47
48 #define NSM_PROG        100024
49 #define NSM_PROGRAM     100024
50 #define NSM_VERSION     1
51 #define NSM_TIMEOUT     2
52 #define NSM_NOTIFY      6
53 #define NSM_MAX_TIMEOUT 120     /* don't make this too big */
54 #define MAXMSGSIZE      256
55
56 struct nsm_host {
57         struct nsm_host *       next;
58         char *                  name;
59         char *                  path;
60         struct sockaddr_storage addr;
61         struct addrinfo         *ai;
62         time_t                  last_used;
63         time_t                  send_next;
64         unsigned int            timeout;
65         unsigned int            retries;
66         unsigned int            xid;
67 };
68
69 static char             nsm_hostname[256];
70 static uint32_t         nsm_state;
71 static int              opt_debug = 0;
72 static int              opt_quiet = 0;
73 static int              opt_update_state = 1;
74 static unsigned int     opt_max_retry = 15 * 60;
75 static char *           opt_srcaddr = 0;
76 static uint16_t         opt_srcport = 0;
77 static int              log_syslog = 0;
78
79 static unsigned int     nsm_get_state(int);
80 static void             notify(void);
81 static int              notify_host(int, struct nsm_host *);
82 static void             recv_reply(int);
83 static void             backup_hosts(const char *, const char *);
84 static void             get_hosts(const char *);
85 static void             insert_host(struct nsm_host *);
86 static struct nsm_host *find_host(uint32_t);
87 static void             nsm_log(int fac, const char *fmt, ...);
88 static int              record_pid(void);
89 static void             drop_privs(void);
90 static void             set_kernel_nsm_state(int state);
91
92 static struct nsm_host *        hosts = NULL;
93
94 /*
95  * Address handling utilities
96  */
97
98 static unsigned short smn_get_port(const struct sockaddr *sap)
99 {
100         switch (sap->sa_family) {
101         case AF_INET:
102                 return ntohs(((struct sockaddr_in *)sap)->sin_port);
103         case AF_INET6:
104                 return ntohs(((struct sockaddr_in6 *)sap)->sin6_port);
105         }
106         return 0;
107 }
108
109 static void smn_set_port(struct sockaddr *sap, const unsigned short port)
110 {
111         switch (sap->sa_family) {
112         case AF_INET:
113                 ((struct sockaddr_in *)sap)->sin_port = htons(port);
114                 break;
115         case AF_INET6:
116                 ((struct sockaddr_in6 *)sap)->sin6_port = htons(port);
117                 break;
118         }
119 }
120
121 static struct addrinfo *smn_lookup(const sa_family_t family, const char *name)
122 {
123         struct addrinfo *ai, hint = {
124                 .ai_family      = family,
125                 .ai_protocol    = IPPROTO_UDP,
126         };
127
128         if (getaddrinfo(name, NULL, &hint, &ai) != 0)
129                 return NULL;
130
131         return ai;
132 }
133
134 int
135 main(int argc, char **argv)
136 {
137         int     c;
138         int     force = 0;
139
140         while ((c = getopt(argc, argv, "dm:np:v:qP:f")) != -1) {
141                 switch (c) {
142                 case 'f':
143                         force = 1;
144                         break;
145                 case 'd':
146                         opt_debug++;
147                         break;
148                 case 'm':
149                         opt_max_retry = atoi(optarg) * 60;
150                         break;
151                 case 'n':
152                         opt_update_state = 0;
153                         break;
154                 case 'p':
155                         opt_srcport = atoi(optarg);
156                         break;
157                 case 'v':
158                         opt_srcaddr = optarg;
159                         break;
160                 case 'q':
161                         opt_quiet = 1;
162                         break;
163                 case 'P':
164                         _SM_BASE_PATH = strdup(optarg);
165                         _SM_STATE_PATH = malloc(strlen(optarg)+1+sizeof("state"));
166                         _SM_DIR_PATH = malloc(strlen(optarg)+1+sizeof("sm"));
167                         _SM_BAK_PATH = malloc(strlen(optarg)+1+sizeof("sm.bak"));
168                         if (_SM_BASE_PATH == NULL ||
169                             _SM_STATE_PATH == NULL ||
170                             _SM_DIR_PATH == NULL ||
171                             _SM_BAK_PATH == NULL) {
172                                 nsm_log(LOG_ERR, "unable to allocate memory");
173                                 exit(1);
174                         }
175                         strcat(strcpy(_SM_STATE_PATH, _SM_BASE_PATH), "/state");
176                         strcat(strcpy(_SM_DIR_PATH, _SM_BASE_PATH), "/sm");
177                         strcat(strcpy(_SM_BAK_PATH, _SM_BASE_PATH), "/sm.bak");
178                         break;
179
180                 default:
181                         goto usage;
182                 }
183         }
184
185         if (optind < argc) {
186 usage:          fprintf(stderr,
187                         "Usage: sm-notify [-dfq] [-m max-retry-minutes] [-p srcport]\n"
188                         "            [-P /path/to/state/directory] [-v my_host_name]\n");
189                 exit(1);
190         }
191
192         log_syslog = 1;
193         openlog("sm-notify", LOG_PID, LOG_DAEMON);
194
195         if (strcmp(_SM_BASE_PATH, BASEDIR) == 0) {
196                 if (record_pid() == 0 && force == 0 && opt_update_state == 1) {
197                         /* already run, don't try again */
198                         nsm_log(LOG_NOTICE, "Already notifying clients; Exiting!");
199                         exit(0);
200                 }
201         }
202
203         if (opt_srcaddr) {
204                 strncpy(nsm_hostname, opt_srcaddr, sizeof(nsm_hostname)-1);
205         } else
206         if (gethostname(nsm_hostname, sizeof(nsm_hostname)) < 0) {
207                 nsm_log(LOG_ERR, "Failed to obtain name of local host: %s",
208                         strerror(errno));
209                 exit(1);
210         }
211
212         backup_hosts(_SM_DIR_PATH, _SM_BAK_PATH);
213         get_hosts(_SM_BAK_PATH);
214
215         /* If there are not hosts to notify, just exit */
216         if (!hosts) {
217                 nsm_log(LOG_DEBUG, "No hosts to notify; exiting");
218                 return 0;
219         }
220
221         /* Get and update the NSM state. This will call sync() */
222         nsm_state = nsm_get_state(opt_update_state);
223         set_kernel_nsm_state(nsm_state);
224
225         if (!opt_debug) {
226                 if (!opt_quiet)
227                         printf("Backgrounding to notify hosts...\n");
228
229                 if (daemon(0, 0) < 0) {
230                         nsm_log(LOG_ERR, "unable to background: %s",
231                                         strerror(errno));
232                         exit(1);
233                 }
234
235                 close(0);
236                 close(1);
237                 close(2);
238         }
239
240         notify();
241
242         if (hosts) {
243                 struct nsm_host *hp;
244
245                 while ((hp = hosts) != 0) {
246                         hosts = hp->next;
247                         nsm_log(LOG_NOTICE,
248                                 "Unable to notify %s, giving up",
249                                 hp->name);
250                 }
251                 exit(1);
252         }
253
254         exit(0);
255 }
256
257 /*
258  * Notify hosts
259  */
260 static void
261 notify(void)
262 {
263         struct sockaddr_storage address;
264         struct sockaddr *local_addr = (struct sockaddr *)&address;
265         time_t  failtime = 0;
266         int     sock = -1;
267         int retry_cnt = 0;
268
269  retry:
270         sock = socket(AF_INET, SOCK_DGRAM, 0);
271         if (sock < 0) {
272                 nsm_log(LOG_ERR, "Failed to create RPC socket: %s",
273                         strerror(errno));
274                 exit(1);
275         }
276         fcntl(sock, F_SETFL, O_NONBLOCK);
277
278         memset(&address, 0, sizeof(address));
279         local_addr->sa_family = AF_INET;        /* Default to IPv4 */
280
281         /* Bind source IP if provided on command line */
282         if (opt_srcaddr) {
283                 struct addrinfo *ai = smn_lookup(AF_INET, opt_srcaddr);
284                 if (!ai) {
285                         nsm_log(LOG_ERR,
286                                 "Not a valid hostname or address: \"%s\"",
287                                 opt_srcaddr);
288                         exit(1);
289                 }
290
291                 /* We know it's IPv4 at this point */
292                 memcpy(local_addr, ai->ai_addr, ai->ai_addrlen);
293
294                 freeaddrinfo(ai);
295         }
296
297         /* Use source port if provided on the command line,
298          * otherwise use bindresvport */
299         if (opt_srcport) {
300                 smn_set_port(local_addr, opt_srcport);
301                 if (bind(sock, local_addr, sizeof(struct sockaddr_in)) < 0) {
302                         nsm_log(LOG_ERR, "Failed to bind RPC socket: %s",
303                                 strerror(errno));
304                         exit(1);
305                 }
306         } else {
307                 struct servent *se;
308                 struct sockaddr_in *sin = (struct sockaddr_in *)local_addr;
309                 (void) bindresvport(sock, sin);
310                 /* try to avoid known ports */
311                 se = getservbyport(sin->sin_port, "udp");
312                 if (se && retry_cnt < 100) {
313                         retry_cnt++;
314                         close(sock);
315                         goto retry;
316                 }
317         }
318
319         if (opt_max_retry)
320                 failtime = time(NULL) + opt_max_retry;
321
322         drop_privs();
323
324         while (hosts) {
325                 struct pollfd   pfd;
326                 time_t          now = time(NULL);
327                 unsigned int    sent = 0;
328                 struct nsm_host *hp;
329                 long            wait;
330
331                 if (failtime && now >= failtime)
332                         break;
333
334                 while (hosts && ((wait = hosts->send_next - now) <= 0)) {
335                         /* Never send more than 10 packets at once */
336                         if (sent++ >= 10)
337                                 break;
338
339                         /* Remove queue head */
340                         hp = hosts;
341                         hosts = hp->next;
342
343                         if (notify_host(sock, hp)){
344                                 unlink(hp->path);
345                                 free(hp->name);
346                                 free(hp->path);
347                                 free(hp);
348                                 continue;
349                         }
350
351                         /* Set the timeout for this call, using an
352                            exponential timeout strategy */
353                         wait = hp->timeout;
354                         if ((hp->timeout <<= 1) > NSM_MAX_TIMEOUT)
355                                 hp->timeout = NSM_MAX_TIMEOUT;
356                         hp->send_next = now + wait;
357                         hp->retries++;
358
359                         insert_host(hp);
360                 }
361                 if (hosts == NULL)
362                         return;
363
364                 nsm_log(LOG_DEBUG, "Host %s due in %ld seconds",
365                                 hosts->name, wait);
366
367                 pfd.fd = sock;
368                 pfd.events = POLLIN;
369
370                 wait *= 1000;
371                 if (wait < 100)
372                         wait = 100;
373                 if (poll(&pfd, 1, wait) != 1)
374                         continue;
375
376                 recv_reply(sock);
377         }
378 }
379
380 /*
381  * Send notification to a single host
382  */
383 static int
384 notify_host(int sock, struct nsm_host *host)
385 {
386         struct sockaddr_storage address;
387         struct sockaddr *dest = (struct sockaddr *)&address;
388         socklen_t destlen = sizeof(address);
389         static unsigned int     xid = 0;
390         uint32_t                msgbuf[MAXMSGSIZE], *p;
391         unsigned int            len;
392
393         if (!xid)
394                 xid = getpid() + time(NULL);
395         if (!host->xid)
396                 host->xid = xid++;
397
398         if (host->ai == NULL) {
399                 host->ai = smn_lookup(AF_UNSPEC, host->name);
400                 if (host->ai == NULL) {
401                         nsm_log(LOG_WARNING,
402                                 "%s doesn't seem to be a valid address,"
403                                 " skipped", host->name);
404                         return 1;
405                 }
406         }
407
408         memset(msgbuf, 0, sizeof(msgbuf));
409         p = msgbuf;
410         *p++ = htonl(host->xid);
411         *p++ = 0;
412         *p++ = htonl(2);
413
414         /* If we retransmitted 4 times, reset the port to force
415          * a new portmap lookup (in case statd was restarted).
416          * We also rotate through multiple IP addresses at this
417          * point.
418          */
419         if (host->retries >= 4) {
420                 struct addrinfo *first = host->ai;
421                 struct addrinfo **next = &host->ai;
422
423                 /* remove the first entry from the list */
424                 host->ai = first->ai_next;
425                 first->ai_next = NULL;
426                 /* find the end of the list */
427                 next = &first->ai_next;
428                 while ( *next )
429                         next = & (*next)->ai_next;
430                 /* put first entry at end */
431                 *next = first;
432                 memcpy(&host->addr, first->ai_addr, first->ai_addrlen);
433                 smn_set_port((struct sockaddr *)&host->addr, 0);
434                 host->retries = 0;
435         }
436
437         memcpy(dest, &host->addr, destlen);
438         if (smn_get_port(dest) == 0) {
439                 /* Build a PMAP packet */
440                 nsm_log(LOG_DEBUG, "Sending portmap query to %s", host->name);
441
442                 smn_set_port(dest, 111);
443                 *p++ = htonl(100000);
444                 *p++ = htonl(2);
445                 *p++ = htonl(3);
446
447                 /* Auth and verf */
448                 *p++ = 0; *p++ = 0;
449                 *p++ = 0; *p++ = 0;
450
451                 *p++ = htonl(NSM_PROGRAM);
452                 *p++ = htonl(NSM_VERSION);
453                 *p++ = htonl(IPPROTO_UDP);
454                 *p++ = 0;
455         } else {
456                 /* Build an SM_NOTIFY packet */
457                 nsm_log(LOG_DEBUG, "Sending SM_NOTIFY to %s", host->name);
458
459                 *p++ = htonl(NSM_PROGRAM);
460                 *p++ = htonl(NSM_VERSION);
461                 *p++ = htonl(NSM_NOTIFY);
462
463                 /* Auth and verf */
464                 *p++ = 0; *p++ = 0;
465                 *p++ = 0; *p++ = 0;
466
467                 /* state change */
468                 len = strlen(nsm_hostname);
469                 *p++ = htonl(len);
470                 memcpy(p, nsm_hostname, len);
471                 p += (len + 3) >> 2;
472                 *p++ = htonl(nsm_state);
473         }
474         len = (p - msgbuf) << 2;
475
476         if (sendto(sock, msgbuf, len, 0, dest, destlen) < 0)
477                 nsm_log(LOG_WARNING, "Sending Reboot Notification to "
478                         "'%s' failed: errno %d (%s)", host->name, errno, strerror(errno));
479         
480         return 0;
481 }
482
483 /*
484  * Receive reply from remote host
485  */
486 static void
487 recv_reply(int sock)
488 {
489         struct nsm_host *hp;
490         struct sockaddr *sap;
491         uint32_t        msgbuf[MAXMSGSIZE], *p, *end;
492         uint32_t        xid;
493         int             res;
494
495         res = recv(sock, msgbuf, sizeof(msgbuf), 0);
496         if (res < 0)
497                 return;
498
499         nsm_log(LOG_DEBUG, "Received packet...");
500
501         p = msgbuf;
502         end = p + (res >> 2);
503
504         xid = ntohl(*p++);
505         if (*p++ != htonl(1)    /* must be REPLY */
506          || *p++ != htonl(0)    /* must be ACCEPTED */
507          || *p++ != htonl(0)    /* must be NULL verifier */
508          || *p++ != htonl(0)
509          || *p++ != htonl(0))   /* must be SUCCESS */
510                 return;
511
512         /* Before we look at the data, find the host struct for
513            this reply */
514         if ((hp = find_host(xid)) == NULL)
515                 return;
516         sap = (struct sockaddr *)&hp->addr;
517
518         if (smn_get_port(sap) == 0) {
519                 /* This was a portmap request */
520                 unsigned int    port;
521
522                 port = ntohl(*p++);
523                 if (p > end)
524                         goto fail;
525
526                 hp->send_next = time(NULL);
527                 if (port == 0) {
528                         /* No binding for statd. Delay the next
529                          * portmap query for max timeout */
530                         nsm_log(LOG_DEBUG, "No statd on %s", hp->name);
531                         hp->timeout = NSM_MAX_TIMEOUT;
532                         hp->send_next += NSM_MAX_TIMEOUT;
533                 } else {
534                         smn_set_port(sap, port);
535                         if (hp->timeout >= NSM_MAX_TIMEOUT / 4)
536                                 hp->timeout = NSM_MAX_TIMEOUT / 4;
537                 }
538                 hp->xid = 0;
539         } else {
540                 /* Successful NOTIFY call. Server returns void,
541                  * so nothing we need to do here (except
542                  * check that we didn't read past the end of the
543                  * packet)
544                  */
545                 if (p <= end) {
546                         nsm_log(LOG_DEBUG, "Host %s notified successfully",
547                                         hp->name);
548                         unlink(hp->path);
549                         free(hp->name);
550                         free(hp->path);
551                         free(hp);
552                         freeaddrinfo(hp->ai);
553                         return;
554                 }
555         }
556
557 fail:   /* Re-insert the host */
558         insert_host(hp);
559 }
560
561 /*
562  * Back up all hosts from the sm directory to sm.bak
563  */
564 static void
565 backup_hosts(const char *dirname, const char *bakname)
566 {
567         struct dirent   *de;
568         DIR             *dir;
569
570         if (!(dir = opendir(dirname))) {
571                 nsm_log(LOG_WARNING,
572                         "Failed to open %s: %s", dirname, strerror(errno));
573                 return;
574         }
575
576         while ((de = readdir(dir)) != NULL) {
577                 char    src[1024], dst[1024];
578
579                 if (de->d_name[0] == '.')
580                         continue;
581
582                 snprintf(src, sizeof(src), "%s/%s", dirname, de->d_name);
583                 snprintf(dst, sizeof(dst), "%s/%s", bakname, de->d_name);
584                 if (rename(src, dst) < 0) {
585                         nsm_log(LOG_WARNING,
586                                 "Failed to rename %s -> %s: %m",
587                                 src, dst);
588                 }
589         }
590         closedir(dir);
591 }
592
593 /*
594  * Get all entries from sm.bak and convert them to host entries
595  */
596 static void
597 get_hosts(const char *dirname)
598 {
599         struct nsm_host *host;
600         struct dirent   *de;
601         DIR             *dir;
602
603         if (!(dir = opendir(dirname))) {
604                 nsm_log(LOG_WARNING,
605                         "Failed to open %s: %s", dirname, strerror(errno));
606                 return;
607         }
608
609         host = NULL;
610         while ((de = readdir(dir)) != NULL) {
611                 struct stat     stb;
612                 char            path[1024];
613
614                 if (de->d_name[0] == '.')
615                         continue;
616                 if (host == NULL)
617                         host = calloc(1, sizeof(*host));
618                 if (host == NULL) {
619                         nsm_log(LOG_WARNING, "Unable to allocate memory");
620                         return;
621                 }
622
623                 snprintf(path, sizeof(path), "%s/%s", dirname, de->d_name);
624                 if (stat(path, &stb) < 0)
625                         continue;
626
627                 host->last_used = stb.st_mtime;
628                 host->timeout = NSM_TIMEOUT;
629                 host->path = strdup(path);
630                 host->name = strdup(de->d_name);
631                 host->retries = 100; /* force address retry */
632
633                 insert_host(host);
634                 host = NULL;
635         }
636         closedir(dir);
637
638         if (host)
639                 free(host);
640 }
641
642 /*
643  * Insert host into sorted list
644  */
645 static void
646 insert_host(struct nsm_host *host)
647 {
648         struct nsm_host **where, *p;
649
650         where = &hosts;
651         while ((p = *where) != 0) {
652                 /* Sort in ascending order of timeout */
653                 if (host->send_next < p->send_next)
654                         break;
655                 /* If we have the same timeout, put the
656                  * most recently used host first.
657                  * This makes sure that "recent" hosts
658                  * get notified first.
659                  */
660                 if (host->send_next == p->send_next
661                  && host->last_used > p->last_used)
662                         break;
663                 where = &p->next;
664         }
665
666         host->next = *where;
667         *where = host;
668 }
669
670 /*
671  * Find host given the XID
672  */
673 static struct nsm_host *
674 find_host(uint32_t xid)
675 {
676         struct nsm_host **where, *p;
677
678         where = &hosts;
679         while ((p = *where) != 0) {
680                 if (p->xid == xid) {
681                         *where = p->next;
682                         return p;
683                 }
684                 where = &p->next;
685         }
686         return NULL;
687 }
688
689
690 /*
691  * Retrieve the current NSM state
692  */
693 static unsigned int
694 nsm_get_state(int update)
695 {
696         char            newfile[PATH_MAX];
697         int             fd, state;
698
699         if ((fd = open(_SM_STATE_PATH, O_RDONLY)) < 0) {
700                 if (!opt_quiet) {
701                         nsm_log(LOG_WARNING, "%s: %m", _SM_STATE_PATH);
702                         nsm_log(LOG_WARNING, "Creating %s, set initial state 1",
703                                 _SM_STATE_PATH);
704                 }
705                 state = 1;
706                 update = 1;
707         } else {
708                 if (read(fd, &state, sizeof(state)) != sizeof(state)) {
709                         nsm_log(LOG_WARNING,
710                                 "%s: bad file size, setting state = 1",
711                                 _SM_STATE_PATH);
712                         state = 1;
713                         update = 1;
714                 } else {
715                         if (!(state & 1))
716                                 state += 1;
717                 }
718                 close(fd);
719         }
720
721         if (update) {
722                 state += 2;
723                 snprintf(newfile, sizeof(newfile),
724                                 "%s.new", _SM_STATE_PATH);
725                 if ((fd = open(newfile, O_CREAT|O_WRONLY, 0644)) < 0) {
726                         nsm_log(LOG_ERR, "Cannot create %s: %m", newfile);
727                         exit(1);
728                 }
729                 if (write(fd, &state, sizeof(state)) != sizeof(state)) {
730                         nsm_log(LOG_ERR,
731                                 "Failed to write state to %s", newfile);
732                         exit(1);
733                 }
734                 close(fd);
735                 if (rename(newfile, _SM_STATE_PATH) < 0) {
736                         nsm_log(LOG_ERR,
737                                 "Cannot create %s: %m", _SM_STATE_PATH);
738                         exit(1);
739                 }
740                 sync();
741         }
742
743         return state;
744 }
745
746 /*
747  * Log a message
748  */
749 static void
750 nsm_log(int fac, const char *fmt, ...)
751 {
752         va_list ap;
753
754         if (fac == LOG_DEBUG && !opt_debug)
755                 return;
756
757         va_start(ap, fmt);
758         if (log_syslog)
759                 vsyslog(fac, fmt, ap);
760         else {
761                 vfprintf(stderr, fmt, ap);
762                 fputs("\n", stderr);
763         }
764         va_end(ap);
765 }
766
767 /*
768  * Record pid in /var/run/sm-notify.pid
769  * This file should remain until a reboot, even if the
770  * program exits.
771  * If file already exists, fail.
772  */
773 static int record_pid(void)
774 {
775         char pid[20];
776         int fd;
777
778         snprintf(pid, 20, "%d\n", getpid());
779         fd = open("/var/run/sm-notify.pid", O_CREAT|O_EXCL|O_WRONLY, 0600);
780         if (fd < 0)
781                 return 0;
782         write(fd, pid, strlen(pid));
783         close(fd);
784         return 1;
785 }
786
787 /* Drop privileges to match owner of state-directory
788  * (in case a reply triggers some unknown bug).
789  */
790 static void drop_privs(void)
791 {
792         struct stat st;
793
794         if (stat(_SM_DIR_PATH, &st) == -1 &&
795             stat(_SM_BASE_PATH, &st) == -1) {
796                 st.st_uid = 0;
797                 st.st_gid = 0;
798         }
799
800         if (st.st_uid == 0) {
801                 nsm_log(LOG_WARNING,
802                         "sm-notify running as root. chown %s to choose different user",
803                     _SM_DIR_PATH);
804                 return;
805         }
806
807         setgroups(0, NULL);
808         if (setgid(st.st_gid) == -1
809             || setuid(st.st_uid) == -1) {
810                 nsm_log(LOG_ERR, "Fail to drop privileges");
811                 exit(1);
812         }
813 }
814
815 static void set_kernel_nsm_state(int state)
816 {
817         int fd;
818
819         fd = open("/proc/sys/fs/nfs/nsm_local_state",O_WRONLY);
820         if (fd >= 0) {
821                 char buf[20];
822                 snprintf(buf, sizeof(buf), "%d", state);
823                 write(fd, buf, strlen(buf));
824                 close(fd);
825         }
826 }