Return to pid_output.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / lib

Annotation of embedaddon/quagga/lib/pid_output.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * Process id output.
                      3:  * Copyright (C) 1998, 1999 Kunihiro Ishiguro
                      4:  *
                      5:  * This file is part of GNU Zebra.
                      6:  *
                      7:  * GNU Zebra is free software; you can redistribute it and/or modify it
                      8:  * under the terms of the GNU General Public License as published by the
                      9:  * Free Software Foundation; either version 2, or (at your option) any
                     10:  * later version.
                     11:  *
                     12:  * GNU Zebra is distributed in the hope that it will be useful, but
                     13:  * WITHOUT ANY WARRANTY; without even the implied warranty of
                     14:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
                     15:  * General Public License for more details.
                     16:  *
                     17:  * You should have received a copy of the GNU General Public License
                     18:  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
                     19:  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
                     20:  * 02111-1307, USA.  
                     21:  */
                     22: 
                     23: #include <zebra.h>
                     24: #include <fcntl.h>
                     25: #include <log.h>
                     26: #include "version.h"
                     27: 
                     28: #define PIDFILE_MASK 0644
                     29: #ifndef HAVE_FCNTL
                     30: 
                     31: pid_t
                     32: pid_output (const char *path)
                     33: {
                     34:   FILE *fp;
                     35:   pid_t pid;
                     36:   mode_t oldumask;
                     37: 
                     38:   pid = getpid();
                     39: 
                     40:   oldumask = umask(0777 & ~PIDFILE_MASK);
                     41:   fp = fopen (path, "w");
                     42:   if (fp != NULL) 
                     43:     {
                     44:       fprintf (fp, "%d\n", (int) pid);
                     45:       fclose (fp);
                     46:       umask(oldumask);
                     47:       return pid;
                     48:     }
                     49:   /* XXX Why do we continue instead of exiting?  This seems incompatible
                     50:      with the behavior of the fcntl version below. */
                     51:   zlog_warn("Can't fopen pid lock file %s (%s), continuing",
                     52:            path, safe_strerror(errno));
                     53:   umask(oldumask);
                     54:   return -1;
                     55: }
                     56: 
                     57: #else /* HAVE_FCNTL */
                     58: 
                     59: pid_t
                     60: pid_output (const char *path)
                     61: {
                     62:   int tmp;
                     63:   int fd;
                     64:   pid_t pid;
                     65:   char buf[16];
                     66:   struct flock lock;  
                     67:   mode_t oldumask;
                     68: 
                     69:   pid = getpid ();
                     70: 
                     71:   oldumask = umask(0777 & ~PIDFILE_MASK);
                     72:   fd = open (path, O_RDWR | O_CREAT, PIDFILE_MASK);
                     73:   if (fd < 0)
                     74:     {
                     75:       zlog_err("Can't create pid lock file %s (%s), exiting",
                     76:               path, safe_strerror(errno));
                     77:       umask(oldumask);
                     78:       exit(1);
                     79:     }
                     80:   else
                     81:     {
                     82:       size_t pidsize;
                     83: 
                     84:       umask(oldumask);
                     85:       memset (&lock, 0, sizeof(lock));
                     86: 
                     87:       lock.l_type = F_WRLCK;
                     88:       lock.l_whence = SEEK_SET;
                     89: 
                     90:       if (fcntl(fd, F_SETLK, &lock) < 0)
                     91:         {
                     92:           zlog_err("Could not lock pid_file %s, exiting", path);
                     93:           exit(1);
                     94:         }
                     95: 
                     96:       sprintf (buf, "%d\n", (int) pid);
                     97:       pidsize = strlen(buf);
                     98:       if ((tmp = write (fd, buf, pidsize)) != (int)pidsize)
                     99:         zlog_err("Could not write pid %d to pid_file %s, rc was %d: %s",
                    100:                 (int)pid,path,tmp,safe_strerror(errno));
                    101:       else if (ftruncate(fd, pidsize) < 0)
                    102:         zlog_err("Could not truncate pid_file %s to %u bytes: %s",
                    103:                 path,(u_int)pidsize,safe_strerror(errno));
                    104:     }
                    105:   return pid;
                    106: }
                    107: 
                    108: #endif /* HAVE_FCNTL */