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 <err.h>
  12 #include <sys/types.h>
  13 #include <sys/socket.h>
  14 #include <sys/stat.h>
  15 #include <sys/poll.h>
  16 #include <sys/param.h>
  17 #include <sys/syslog.h>
  18 #include <arpa/inet.h>
  19 #include <dirent.h>
  20 #include <time.h>
  21 #include <stdio.h>
  22 #include <getopt.h>
  23 #include <stdlib.h>
  24 #include <fcntl.h>
  25 #include <unistd.h>
  26 #include <string.h>
  27 #include <stdarg.h>
  28 #include <netdb.h>
  29 #include <errno.h>
  30 #include <grp.h>
  31
  32 #include "sockaddr.h"
  33 #include "xlog.h"
  34 #include "nsm.h"
  35 #include "nfsrpc.h"
  36
  37 #define NSM_TIMEOUT     2
  38 #define NSM_MAX_TIMEOUT 120     /* don't make this too big */
  39
  40 struct nsm_host {
  41         struct nsm_host *       next;
  42         char *                  name;
  43         char *                  mon_name;
  44         char *                  my_name;
  45         struct addrinfo         *ai;
  46         time_t                  last_used;
  47         time_t                  send_next;
  48         unsigned int            timeout;
  49         unsigned int            retries;
  50         uint32_t                xid;
  51 };
  52
  53 static char             nsm_hostname[SM_MAXSTRLEN + 1];
  54 static int              nsm_state;
  55 static int              nsm_family = AF_INET;
  56 static int              opt_debug = 0;
  57 static _Bool            opt_update_state = true;
  58 static unsigned int     opt_max_retry = 15 * 60;
  59 static char *           opt_srcaddr = NULL;
  60 static char *           opt_srcport = NULL;
  61
  62 static void             notify(const int sock);
  63 static int              notify_host(int, struct nsm_host *);
  64 static void             recv_reply(int);
  65 static void             insert_host(struct nsm_host *);
  66 static struct nsm_host *find_host(uint32_t);
  67 static int              record_pid(void);
  68
  69 static struct nsm_host *        hosts = NULL;
  70
  71 __attribute_malloc__
  72 static struct addrinfo *
  73 smn_lookup(const char *name)
  74 {
  75         struct addrinfo *ai = NULL;
  76         struct addrinfo hint = {
  77                 .ai_family      = (nsm_family == AF_INET ? AF_INET: AF_UNSPEC),
  78                 .ai_protocol    = (int)IPPROTO_UDP,
  79         };
  80         int error;
  81
  82         error = getaddrinfo(name, NULL, &hint, &ai);
  83         if (error != 0) {
  84                 xlog(D_GENERAL, "getaddrinfo(3): %s", gai_strerror(error));
  85                 return NULL;
  86         }
  87
  88         return ai;
  89 }
  90
  91 __attribute_malloc__
  92 static struct nsm_host *
  93 smn_alloc_host(const char *hostname, const char *mon_name,
  94                 const char *my_name, const time_t timestamp)
  95 {
  96         struct nsm_host *host;
  97
  98         host = calloc(1, sizeof(*host));
  99         if (host == NULL)
 100                 goto out_nomem;
 101
 102         host->name = strdup(hostname);
 103         host->mon_name = strdup(mon_name);
 104         host->my_name = strdup(my_name);
 105         if (host->name == NULL ||
 106             host->mon_name == NULL ||
 107             host->my_name == NULL) {
 108                 free(host->my_name);
 109                 free(host->mon_name);
 110                 free(host->name);
 111                 free(host);
 112                 goto out_nomem;
 113         }
 114
 115         host->last_used = timestamp;
 116         host->timeout = NSM_TIMEOUT;
 117         host->retries = 100;            /* force address retry */
 118
 119         return host;
 120
 121 out_nomem:
 122         xlog_warn("Unable to allocate memory");
 123         return NULL;
 124 }
 125
 126 static void smn_forget_host(struct nsm_host *host)
 127 {
 128         xlog(D_CALL, "Removing %s (%s, %s) from notify list",
 129                         host->name, host->mon_name, host->my_name);
 130
 131         nsm_delete_notified_host(host->name, host->mon_name, host->my_name);
 132
 133         free(host->my_name);
 134         free(host->mon_name);
 135         free(host->name);
 136         if (host->ai)
 137                 freeaddrinfo(host->ai);
 138
 139         free(host);
 140 }
 141
 142 static unsigned int
 143 smn_get_host(const char *hostname,
 144                 __attribute__ ((unused)) const struct sockaddr *sap,
 145                 const struct mon *m, const time_t timestamp)
 146 {
 147         struct nsm_host *host;
 148
 149         host = smn_alloc_host(hostname,
 150                 m->mon_id.mon_name, m->mon_id.my_id.my_name, timestamp);
 151         if (host == NULL)
 152                 return 0;
 153
 154         insert_host(host);
 155         xlog(D_GENERAL, "Added host %s to notify list", hostname);
 156         return 1;
 157 }
 158
 159 #ifdef IPV6_SUPPORTED
 160 static int smn_socket(void)
 161 {
 162         int sock;
 163
 164         /*
 165          * Use an AF_INET socket if IPv6 is disabled on the
 166          * local system.
 167          */
 168         sock = socket(AF_INET6, SOCK_DGRAM, 0);
 169         if (sock == -1) {
 170                 if (errno != EAFNOSUPPORT) {
 171                         xlog(L_ERROR, "Failed to create RPC socket: %m");
 172                         return -1;
 173                 }
 174                 sock = socket(AF_INET, SOCK_DGRAM, 0);
 175                 if (sock < 0) {
 176                         xlog(L_ERROR, "Failed to create RPC socket: %m");
 177                         return -1;
 178                 }
 179         } else
 180                 nsm_family = AF_INET6;
 181
 182         if (fcntl(sock, F_SETFL, O_NONBLOCK) == -1) {
 183                 xlog(L_ERROR, "fcntl(3) on RPC socket failed: %m");
 184                 goto out_close;
 185         }
 186
 187         /*
 188          * TI-RPC over IPv6 (udp6/tcp6) does not handle IPv4.  However,
 189          * since sm-notify open-codes all of its RPC support, it can
 190          * use a single socket and let the local network stack provide
 191          * the correct mapping between address families automatically.
 192          * This is the same thing that is done in the kernel.
 193          */
 194         if (nsm_family == AF_INET6) {
 195                 const int zero = 0;
 196                 socklen_t zerolen = (socklen_t)sizeof(zero);
 197
 198                 if (setsockopt(sock, SOL_IPV6, IPV6_V6ONLY,
 199                                         (char *)&zero, zerolen) == -1) {
 200                         xlog(L_ERROR, "setsockopt(3) on RPC socket failed: %m");
 201                         goto out_close;
 202                 }
 203         }
 204
 205         return sock;
 206
 207 out_close:
 208         (void)close(sock);
 209         return -1;
 210 }
 211 #else   /* !IPV6_SUPPORTED */
 212 static int smn_socket(void)
 213 {
 214         int sock;
 215
 216         sock = socket(AF_INET, SOCK_DGRAM, 0);
 217         if (sock == -1) {
 218                 xlog(L_ERROR, "Failed to create RPC socket: %m");
 219                 return -1;
 220         }
 221
 222         if (fcntl(sock, F_SETFL, O_NONBLOCK) == -1) {
 223                 xlog(L_ERROR, "fcntl(3) on RPC socket failed: %m");
 224                 (void)close(sock);
 225                 return -1;
 226         }
 227
 228         return sock;
 229 }
 230 #endif  /* !IPV6_SUPPORTED */
 231
 232 /*
 233  * If admin specified a source address or srcport, then convert those
 234  * to a sockaddr and return it.   Otherwise, return an ANYADDR address.
 235  */
 236 __attribute_malloc__
 237 static struct addrinfo *
 238 smn_bind_address(const char *srcaddr, const char *srcport)
 239 {
 240         struct addrinfo *ai = NULL;
 241         struct addrinfo hint = {
 242                 .ai_flags       = AI_NUMERICSERV,
 243                 .ai_family      = nsm_family,
 244                 .ai_protocol    = (int)IPPROTO_UDP,
 245         };
 246         int error;
 247
 248         if (srcaddr == NULL)
 249                 hint.ai_flags |= AI_PASSIVE;
 250
 251         if (srcport == NULL)
 252                 error = getaddrinfo(srcaddr, "", &hint, &ai);
 253         else
 254                 error = getaddrinfo(srcaddr, srcport, &hint, &ai);
 255         if (error != 0) {
 256                 xlog(L_ERROR,
 257                         "Invalid bind address or port for RPC socket: %s",
 258                                 gai_strerror(error));
 259                 return NULL;
 260         }
 261
 262         return ai;
 263 }
 264
 265 #ifdef HAVE_LIBTIRPC
 266 static int
 267 smn_bindresvport(int sock, struct sockaddr *sap)
 268 {
 269         return bindresvport_sa(sock, sap);
 270 }
 271
 272 #else   /* !HAVE_LIBTIRPC */
 273 static int
 274 smn_bindresvport(int sock, struct sockaddr *sap)
 275 {
 276         if (sap->sa_family != AF_INET) {
 277                 errno = EAFNOSUPPORT;
 278                 return -1;
 279         }
 280
 281         return bindresvport(sock, (struct sockaddr_in *)(char *)sap);
 282 }
 283 #endif  /* !HAVE_LIBTIRPC */
 284
 285 /*
 286  * Prepare a socket for sending RPC requests
 287  *
 288  * Returns a bound datagram socket file descriptor, or -1 if
 289  * an error occurs.
 290  */
 291 static int
 292 smn_create_socket(const char *srcaddr, const char *srcport)
 293 {
 294         int sock, retry_cnt = 0;
 295         struct addrinfo *ai;
 296
 297 retry:
 298         sock = smn_socket();
 299         if (sock == -1)
 300                 return -1;
 301
 302         ai = smn_bind_address(srcaddr, srcport);
 303         if (ai == NULL) {
 304                 (void)close(sock);
 305                 return -1;
 306         }
 307
 308         /* Use source port if provided on the command line,
 309          * otherwise use bindresvport */
 310         if (srcport) {
 311                 if (bind(sock, ai->ai_addr, ai->ai_addrlen) == -1) {
 312                         xlog(L_ERROR, "Failed to bind RPC socket: %m");
 313                         freeaddrinfo(ai);
 314                         (void)close(sock);
 315                         return -1;
 316                 }
 317         } else {
 318                 struct servent *se;
 319
 320                 if (smn_bindresvport(sock, ai->ai_addr) == -1) {
 321                         xlog(L_ERROR,
 322                                 "bindresvport on RPC socket failed: %m");
 323                         freeaddrinfo(ai);
 324                         (void)close(sock);
 325                         return -1;
 326                 }
 327
 328                 /* try to avoid known ports */
 329                 se = getservbyport((int)nfs_get_port(ai->ai_addr), "udp");
 330                 if (se != NULL && retry_cnt < 100) {
 331                         retry_cnt++;
 332                         freeaddrinfo(ai);
 333                         (void)close(sock);
 334                         goto retry;
 335                 }
 336         }
 337
 338         freeaddrinfo(ai);
 339         return sock;
 340 }
 341
 342 int
 343 main(int argc, char **argv)
 344 {
 345         int     c, sock, force = 0;
 346         char *  progname;
 347
 348         progname = strrchr(argv[0], '/');
 349         if (progname != NULL)
 350                 progname++;
 351         else
 352                 progname = argv[0];
 353
 354         while ((c = getopt(argc, argv, "dm:np:v:P:f")) != -1) {
 355                 switch (c) {
 356                 case 'f':
 357                         force = 1;
 358                         break;
 359                 case 'd':
 360                         opt_debug++;
 361                         break;
 362                 case 'm':
 363                         opt_max_retry = atoi(optarg) * 60;
 364                         break;
 365                 case 'n':
 366                         opt_update_state = false;
 367                         break;
 368                 case 'p':
 369                         opt_srcport = optarg;
 370                         break;
 371                 case 'v':
 372                         opt_srcaddr = optarg;
 373                         break;
 374                 case 'P':
 375                         if (!nsm_setup_pathnames(argv[0], optarg))
 376                                 exit(1);
 377                         break;
 378
 379                 default:
 380                         goto usage;
 381                 }
 382         }
 383
 384         if (optind < argc) {
 385 usage:          fprintf(stderr,
 386                         "Usage: %s -notify [-dfq] [-m max-retry-minutes] [-p srcport]\n"
 387                         "            [-P /path/to/state/directory] [-v my_host_name]\n",
 388                         progname);
 389                 exit(1);
 390         }
 391
 392         xlog_syslog(1);
 393         if (opt_debug) {
 394                 xlog_stderr(1);
 395                 xlog_config(D_ALL, 1);
 396         } else
 397                 xlog_stderr(0);
 398
 399         xlog_open(progname);
 400         xlog(L_NOTICE, "Version " VERSION " starting");
 401
 402         if (nsm_is_default_parentdir()) {
 403                 if (record_pid() == 0 && force == 0 && opt_update_state) {
 404                         /* already run, don't try again */
 405                         xlog(L_NOTICE, "Already notifying clients; Exiting!");
 406                         exit(0);
 407                 }
 408         }
 409
 410         if (opt_srcaddr != NULL) {
 411                 struct addrinfo *ai = NULL;
 412                 struct addrinfo hint = {
 413                         .ai_family      = AF_UNSPEC,
 414                         .ai_flags       = AI_NUMERICHOST,
 415                 };
 416
 417                 if (getaddrinfo(opt_srcaddr, NULL, &hint, &ai))
 418                         /* not a presentation address - use it */
 419                         strncpy(nsm_hostname, opt_srcaddr, sizeof(nsm_hostname));
 420                 else {
 421                         /* was a presentation address - look it up in
 422                          * /etc/hosts, so it can be used for my_name */
 423                         int error;
 424
 425                         freeaddrinfo(ai);
 426                         hint.ai_flags = AI_CANONNAME;
 427                         error = getaddrinfo(opt_srcaddr, NULL, &hint, &ai);
 428                         if (error != 0) {
 429                                 xlog(L_ERROR, "Bind address %s is unusable: %s",
 430                                                 opt_srcaddr, gai_strerror(error));
 431                                 exit(1);
 432                         }
 433                         strncpy(nsm_hostname, ai->ai_canonname,
 434                                                         sizeof(nsm_hostname));
 435                         freeaddrinfo(ai);
 436                 }
 437         }
 438
 439         (void)nsm_retire_monitored_hosts();
 440         if (nsm_load_notify_list(smn_get_host) == 0) {
 441                 xlog(D_GENERAL, "No hosts to notify; exiting");
 442                 return 0;
 443         }
 444
 445         nsm_state = nsm_get_state(opt_update_state);
 446         if (nsm_state == 0)
 447                 exit(1);
 448         nsm_update_kernel_state(nsm_state);
 449
 450         if (!opt_debug) {
 451                 xlog(L_NOTICE, "Backgrounding to notify hosts...\n");
 452
 453                 if (daemon(0, 0) < 0) {
 454                         xlog(L_ERROR, "unable to background: %m");
 455                         exit(1);
 456                 }
 457
 458                 close(0);
 459                 close(1);
 460                 close(2);
 461         }
 462
 463         sock = smn_create_socket(opt_srcaddr, opt_srcport);
 464         if (sock == -1)
 465                 exit(1);
 466
 467         if (!nsm_drop_privileges(-1))
 468                 exit(1);
 469
 470         notify(sock);
 471
 472         if (hosts) {
 473                 struct nsm_host *hp;
 474
 475                 while ((hp = hosts) != 0) {
 476                         hosts = hp->next;
 477                         xlog(L_NOTICE, "Unable to notify %s, giving up",
 478                                 hp->name);
 479                 }
 480                 exit(1);
 481         }
 482
 483         exit(0);
 484 }
 485
 486 /*
 487  * Notify hosts
 488  */
 489 static void
 490 notify(const int sock)
 491 {
 492         time_t  failtime = 0;
 493
 494         if (opt_max_retry)
 495                 failtime = time(NULL) + opt_max_retry;
 496
 497         while (hosts) {
 498                 struct pollfd   pfd;
 499                 time_t          now = time(NULL);
 500                 unsigned int    sent = 0;
 501                 struct nsm_host *hp;
 502                 long            wait;
 503
 504                 if (failtime && now >= failtime)
 505                         break;
 506
 507                 while (hosts && ((wait = hosts->send_next - now) <= 0)) {
 508                         /* Never send more than 10 packets at once */
 509                         if (sent++ >= 10)
 510                                 break;
 511
 512                         /* Remove queue head */
 513                         hp = hosts;
 514                         hosts = hp->next;
 515
 516                         if (notify_host(sock, hp))
 517                                 continue;
 518
 519                         /* Set the timeout for this call, using an
 520                            exponential timeout strategy */
 521                         wait = hp->timeout;
 522                         if ((hp->timeout <<= 1) > NSM_MAX_TIMEOUT)
 523                                 hp->timeout = NSM_MAX_TIMEOUT;
 524                         hp->send_next = now + wait;
 525                         hp->retries++;
 526
 527                         insert_host(hp);
 528                 }
 529                 if (hosts == NULL)
 530                         return;
 531
 532                 xlog(D_GENERAL, "Host %s due in %ld seconds",
 533                                 hosts->name, wait);
 534
 535                 pfd.fd = sock;
 536                 pfd.events = POLLIN;
 537
 538                 wait *= 1000;
 539                 if (wait < 100)
 540                         wait = 100;
 541                 if (poll(&pfd, 1, wait) != 1)
 542                         continue;
 543
 544                 recv_reply(sock);
 545         }
 546 }
 547
 548 /*
 549  * Send notification to a single host
 550  */
 551 static int
 552 notify_host(int sock, struct nsm_host *host)
 553 {
 554         const char *my_name = (opt_srcaddr != NULL ?
 555                                         nsm_hostname : host->my_name);
 556         struct sockaddr *sap;
 557         socklen_t salen;
 558
 559         if (host->ai == NULL) {
 560                 host->ai = smn_lookup(host->name);
 561                 if (host->ai == NULL) {
 562                         xlog_warn("DNS resolution of %s failed; "
 563                                 "retrying later", host->name);
 564                         return 0;
 565                 }
 566         }
 567
 568         /* If we retransmitted 4 times, reset the port to force
 569          * a new portmap lookup (in case statd was restarted).
 570          * We also rotate through multiple IP addresses at this
 571          * point.
 572          */
 573         if (host->retries >= 4) {
 574                 /* don't rotate if there is only one addrinfo */
 575                 if (host->ai->ai_next != NULL) {
 576                         struct addrinfo *first = host->ai;
 577                         struct addrinfo **next = &host->ai;
 578
 579                         /* remove the first entry from the list */
 580                         host->ai = first->ai_next;
 581                         first->ai_next = NULL;
 582                         /* find the end of the list */
 583                         next = &first->ai_next;
 584                         while ( *next )
 585                                 next = & (*next)->ai_next;
 586                         /* put first entry at end */
 587                         *next = first;
 588                 }
 589
 590                 nfs_set_port(host->ai->ai_addr, 0);
 591                 host->retries = 0;
 592         }
 593
 594         sap = host->ai->ai_addr;
 595         salen = host->ai->ai_addrlen;
 596
 597         if (nfs_get_port(sap) == 0)
 598                 host->xid = nsm_xmit_rpcbind(sock, sap, SM_PROG, SM_VERS);
 599         else
 600                 host->xid = nsm_xmit_notify(sock, sap, salen,
 601                                         SM_PROG, my_name, nsm_state);
 602
 603         return 0;
 604 }
 605
 606 /*
 607  * Extract the returned port number and set up the SM_NOTIFY call.
 608  */
 609 static void
 610 recv_rpcbind_reply(struct sockaddr *sap, struct nsm_host *host, XDR *xdr)
 611 {
 612         uint16_t port = nsm_recv_rpcbind(sap->sa_family, xdr);
 613
 614         host->send_next = time(NULL);
 615         host->xid = 0;
 616
 617         if (port == 0) {
 618                 /* No binding for statd... */
 619                 xlog(D_GENERAL, "No statd on host %s", host->name);
 620                 host->timeout = NSM_MAX_TIMEOUT;
 621                 host->send_next += NSM_MAX_TIMEOUT;
 622         } else {
 623                 nfs_set_port(sap, port);
 624                 if (host->timeout >= NSM_MAX_TIMEOUT / 4)
 625                         host->timeout = NSM_MAX_TIMEOUT / 4;
 626         }
 627
 628         insert_host(host);
 629 }
 630
 631 /*
 632  * Successful NOTIFY call. Server returns void.
 633  *
 634  * Try sending another SM_NOTIFY with an unqualified "my_name"
 635  * argument.  Reuse the port number.  If "my_name" is already
 636  * unqualified, we're done.
 637  */
 638 static void
 639 recv_notify_reply(struct nsm_host *host)
 640 {
 641         char *dot = strchr(host->my_name, '.');
 642
 643         if (dot != NULL) {
 644                 *dot = '\0';
 645                 host->send_next = time(NULL);
 646                 host->xid = 0;
 647                 if (host->timeout >= NSM_MAX_TIMEOUT / 4)
 648                         host->timeout = NSM_MAX_TIMEOUT / 4;
 649                 insert_host(host);
 650         } else {
 651                 xlog(D_GENERAL, "Host %s notified successfully", host->name);
 652                 smn_forget_host(host);
 653         }
 654 }
 655
 656 /*
 657  * Receive reply from remote host
 658  */
 659 static void
 660 recv_reply(int sock)
 661 {
 662         struct nsm_host *hp;
 663         struct sockaddr *sap;
 664         char msgbuf[NSM_MAXMSGSIZE];
 665         uint32_t        xid;
 666         ssize_t         msglen;
 667         XDR             xdr;
 668
 669         memset(msgbuf, 0 , sizeof(msgbuf));
 670         msglen = recv(sock, msgbuf, sizeof(msgbuf), 0);
 671         if (msglen < 0)
 672                 return;
 673
 674         xlog(D_GENERAL, "Received packet...");
 675
 676         memset(&xdr, 0, sizeof(xdr));
 677         xdrmem_create(&xdr, msgbuf, (unsigned int)msglen, XDR_DECODE);
 678         xid = nsm_parse_reply(&xdr);
 679         if (xid == 0)
 680                 goto out;
 681
 682         /* Before we look at the data, find the host struct for
 683            this reply */
 684         if ((hp = find_host(xid)) == NULL)
 685                 goto out;
 686
 687         sap = hp->ai->ai_addr;
 688         if (nfs_get_port(sap) == 0)
 689                 recv_rpcbind_reply(sap, hp, &xdr);
 690         else
 691                 recv_notify_reply(hp);
 692
 693 out:
 694         xdr_destroy(&xdr);
 695 }
 696
 697 /*
 698  * Insert host into sorted list
 699  */
 700 static void
 701 insert_host(struct nsm_host *host)
 702 {
 703         struct nsm_host **where, *p;
 704
 705         where = &hosts;
 706         while ((p = *where) != 0) {
 707                 /* Sort in ascending order of timeout */
 708                 if (host->send_next < p->send_next)
 709                         break;
 710                 /* If we have the same timeout, put the
 711                  * most recently used host first.
 712                  * This makes sure that "recent" hosts
 713                  * get notified first.
 714                  */
 715                 if (host->send_next == p->send_next
 716                  && host->last_used > p->last_used)
 717                         break;
 718                 where = &p->next;
 719         }
 720
 721         host->next = *where;
 722         *where = host;
 723 }
 724
 725 /*
 726  * Find host given the XID
 727  */
 728 static struct nsm_host *
 729 find_host(uint32_t xid)
 730 {
 731         struct nsm_host **where, *p;
 732
 733         where = &hosts;
 734         while ((p = *where) != 0) {
 735                 if (p->xid == xid) {
 736                         *where = p->next;
 737                         return p;
 738                 }
 739                 where = &p->next;
 740         }
 741         return NULL;
 742 }
 743
 744 /*
 745  * Record pid in /var/run/sm-notify.pid
 746  * This file should remain until a reboot, even if the
 747  * program exits.
 748  * If file already exists, fail.
 749  */
 750 static int record_pid(void)
 751 {
 752         char pid[20];
 753         ssize_t len;
 754         int fd;
 755
 756         (void)snprintf(pid, sizeof(pid), "%d\n", (int)getpid());
 757         fd = open("/var/run/sm-notify.pid", O_CREAT|O_EXCL|O_WRONLY, 0600);
 758         if (fd < 0)
 759                 return 0;
 760
 761         len = write(fd, pid, strlen(pid));
 762         if ((len < 0) || ((size_t)len != strlen(pid))) {
 763                 xlog_warn("Writing to pid file failed: errno %d (%m)",
 764                                 errno);
 765         }
 766
 767         (void)close(fd);
 768         return 1;
 769 }