title: How do I ensure that only one copy of a daemon is running?
body: <p>My code to daemonize a process is:    </p>
  
  <pre><code>static int daemonize( const char *lockfile )
  {
      pid_t pid, sid, parent;
      int lfp = -1;
      char buf[16];
  
      /* already a daemon */
      if ( getppid() == 1 ) return 1;
  
      /* Each copy of the daemon will try to 
       * create a file and write its process ID 
       * in it. This will allow administrators 
       * to identify the process easily
       */ 
      /* Create the lock file as the current user */
      if ( lockfile &amp;&amp; lockfile[0] ) {
          lfp = open(lockfile,O_RDWR|O_CREAT,LOCKMODE); 
          if ( lfp &lt; 0 ) {
              syslog( LOG_ERR, "unable to create lock file %s, code=%d (%s)",
                      lockfile, errno, strerror(errno) );
              exit(EXIT_FAILURE);
          }
      }
  
      /* If the file is already locked, then to ensure that 
       * only one copy of record is running. The filelock function will fail 
       * with errno set to EACCESS or EAGAIN.
       */
      if (filelock(lfp) &lt; 0) {
          if (errno == EACCES || errno == EAGAIN) {
              close(lfp);
              //return(1);
              exit(EXIT_FAILURE);
          }
          syslog(LOG_ERR, "can't lock %s: %s", lockfile, strerror(errno));
          exit(EXIT_FAILURE);
      }
      ftruncate(lfp, 0);
      sprintf(buf, "%ld", (long)getpid());
      write(lfp, buf, strlen(buf)+1); 
  
      /* Drop user if there is one, and we were run as RUN_AS_USER */
      if ( getuid() == 0 || geteuid() == 0 ) {
          struct passwd *pw = getpwnam(RUN_AS_USER);
          if ( pw ) {
              syslog( LOG_NOTICE, "setting user to " RUN_AS_USER );
              setuid( pw-&gt;pw_uid );
          }
      }
  
      /* Trap signals that we expect to recieve */
      signal(SIGCHLD,child_handler);
      signal(SIGUSR1,child_handler);
      signal(SIGALRM,child_handler);
  
      /* Fork off the parent process */
      pid = fork();
      if (pid &lt; 0) {
          syslog( LOG_ERR, "unable to fork daemon, code=%d (%s)",
                  errno, strerror(errno) );
          exit(EXIT_FAILURE);
      }
      /* If we got a good PID, then we can exit the parent process. */
      if (pid &gt; 0) {
          /* Wait for confirmation from the child via SIGTERM or SIGCHLD, or
             for two seconds to elapse (SIGALRM).  pause() should not return. */
          alarm(2);
          pause();
  
          exit(EXIT_FAILURE);
      }
  
      /* At this point we are executing as the child process */
      parent = getppid();
  
      /* Cancel certain signals */
      signal(SIGCHLD,SIG_DFL); /* A child process dies */
      signal(SIGTSTP,SIG_IGN); /* Various TTY signals */
      signal(SIGTTOU,SIG_IGN);
      signal(SIGTTIN,SIG_IGN);
      signal(SIGHUP, SIG_IGN); /* Ignore hangup signal */
      signal(SIGTERM,SIG_DFL); /* Die on SIGTERM */
  
      /* Change the file mode mask */
      umask(0);
  
      /* Create a new SID for the child process */
      sid = setsid();
      if (sid &lt; 0) {
          syslog( LOG_ERR, "unable to create a new session, code %d (%s)",
                  errno, strerror(errno) );
          exit(EXIT_FAILURE);
      }
  
      /* Change the current working directory.  This prevents the current
         directory from being locked; hence not being able to remove it. */
      if ((chdir("/")) &lt; 0) {
          syslog( LOG_ERR, "unable to change directory to %s, code %d (%s)",
                  "/", errno, strerror(errno) );
          exit(EXIT_FAILURE);
      }
  
      /* Redirect standard files to /dev/null */
      freopen( "/dev/null", "r", stdin);
      freopen( "/dev/null", "w", stdout);
      freopen( "/dev/null", "w", stderr);
  
      /* Tell the parent process that we are A-okay */
      kill( parent, SIGUSR1 );
      return 0;
  }
  </code></pre>
  
  <p>I want to run only one instance of my program at a time when I start it using:</p>
  
  <pre><code>service [script] start
  </code></pre>
  
  <p>But whenever this command executes two or more times, it creates the same number of daemon processes in the running condition. I want to get rid of this behavior. Any suggestion will be highly appreciated.</p>