path: root/src/daemon.c

/*
     This file is part of GNUnet.
     (C) 2005 Christian Grothoff (and other contributing authors)

     GNUnet is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published
     by the Free Software Foundation; either version 2, or (at your
     option) any later version.

     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with GNUnet; see the file COPYING.  If not, write to the
     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
*/

/**
 * @file src/daemon.c
 * @brief code for gnunet-gtk gnunetd interaction
 * @author Christian Grothoff
 */

#include "platform.h"

#include "daemon.h"
#include "main.h"
#include "helper.h"
#ifndef MINGW
 #include <sys/wait.h>
#endif
#include <GNUnet/gnunet_util.h>
#include <GNUnet/gnunet_protocols.h>

/** 
 * Checks if gnunetd is running
 * 
 * NOTE: Uses CS_PROTO_CLIENT_COUNT query to determine if 
 * gnunetd is running
 */
static int checkDaemonRunning(void) {
  GNUNET_TCP_SOCKET * sock;
  CS_HEADER csHdr;
  int ret;

  sock = getClientSocket();
  if(sock == NULL) {
    BREAK();
    return SYSERR;  
  }    

  csHdr.size
    = htons(sizeof(CS_HEADER));
  csHdr.type
    = htons(CS_PROTO_CLIENT_COUNT);
  if (SYSERR == writeToSocket(sock,
                              &csHdr)) {
    LOG(LOG_DEBUG, 
	_("gnunetd is NOT running.\n"));
    releaseClientSocket(sock);
    return SYSERR;
  } 
  if (SYSERR == readTCPResult(sock, 
  			      &ret)) {
    releaseClientSocket(sock);
    return SYSERR;
  }
  releaseClientSocket(sock);
  
  return OK;
}



#if LINUX || OSX || SOLARIS || SOMEBSD
static int launchWithExec() {
  pid_t pid;

  pid = fork();
  if (pid == 0) {
    char * args[4];
    char * path;
    char * cp;

    path = NULL;
    cp = getConfigurationString("MAIN", 
				"ARGV[0]");
    if (cp != NULL) {
      int i = strlen(cp);
      while ( (i >= 0) && 
	      (cp[i] != DIR_SEPARATOR) )
	i--;
      if ( i != -1 ) {
	cp[i+1] = '\0';
	path = MALLOC(i+1+strlen("gnunetd"));
	strcpy(path, cp);
	strcat(path, "gnunetd");      
	args[0] = path;
	FREE(cp);
      } else {
	args[0] = "gnunetd";
      }
    }
    cp = getConfigurationString("GNUNET-GTK",
				"GNUNETD-CONFIG");
    if (cp != NULL) {
      args[1] = "-c";
      args[2] = cp;
    } else {
      args[1] = NULL;
    }
    args[3] = NULL;
    errno = 0;
    nice(10); /* return value is not well-defined */
    if (errno != 0) 
      LOG_STRERROR(LOG_WARNING, "nice");    
    if (path != NULL)
      execv(path,
	    args);
    else
      execvp("gnunetd",
	     args);
    LOG_STRERROR(LOG_FAILURE, "exec");
    LOG(LOG_FAILURE,
	_("Attempted path to '%s' was '%s'.\n"),
	"gnunetd",
	(path == NULL) ? "gnunetd" : path);
    FREENONNULL(path); /* yeah, right, like we're likely to get
			  here... */
    FREENONNULL(args[1]);
    _exit(-1);
  } else {
    pid_t ret;
    int status;

    ret = waitpid(pid, &status, 0);
    if (ret == -1) {
      LOG_STRERROR(LOG_ERROR, "waitpid");
      return SYSERR;
    }
    if ( (WIFEXITED(status) &&
	  (0 != WEXITSTATUS(status)) ) ) {
      guiMessage(_("Starting gnunetd failed, error code: %d"),
		 WEXITSTATUS(status));
      return SYSERR;
    }
#ifdef WCOREDUMP
    if (WCOREDUMP(status)) {
      guiMessage(_("Starting gnunetd failed (core dumped)."));
      return SYSERR;
    }
#endif
    if (WIFSIGNALED(status) ||
	WTERMSIG(status) ) {
      guiMessage(_("Starting gnunetd failed (aborted by signal)."));
      return SYSERR;
    }
    return OK;
  }
}
#endif

static int doLaunch() {
  
#if LINUX || OSX || SOLARIS || SOMEBSD
  return launchWithExec();
#elif MINGW
  char szCall[_MAX_PATH + 1], szWd[_MAX_PATH + 1], szCWd[_MAX_PATH + 1];
  char *args[1];

  plibc_conv_to_win_path("/bin/gnunetd.exe", szCall);
  plibc_conv_to_win_path("/bin", szWd);
  _getcwd(szCWd, _MAX_PATH);

  chdir(szWd);
  args[0] = NULL;
  spawnvp(_P_NOWAIT, szCall, (const char *const *) args);
  chdir(szCWd);
  
  return OK;
#else
  /* any system out there that does not support THIS!? */
  system("gnunetd"); /* we may not have nice,
			so let's be minimalistic here. */
  return OK;
#endif  
}

/** 
 * Launch gnunetd w/ checks
 */
void on_startDaemon_clicked(GtkWidget * widget,
			    gpointer data) {
  GtkWidget * launchEntry = NULL;
  launchEntry
    = glade_xml_get_widget(mainXML,
			   "startDaemon");
  gtk_widget_set_sensitive(launchEntry, FALSE);
  if (OK == checkDaemonRunning() ) {
    cronCheckDaemon(NULL);
    return;
  } else {	
    addLogEntry(_("Launching gnunetd..."));
    doLaunch();    
  }
}

/** 
 * Kill gnunetd
 */
void on_stopDaemon_clicked(GtkWidget * widget,
			   gpointer data) {
  GtkWidget * killEntry = NULL;
  killEntry
    = glade_xml_get_widget(mainXML,
			   "stopDaemon");
  gtk_widget_set_sensitive(killEntry, FALSE);
  
  if (OK == checkDaemonRunning() ) {
    GNUNET_TCP_SOCKET * sock;
    CS_HEADER csHdr;
    int ret;

    sock = getClientSocket();
    if (sock == NULL) {
      cronCheckDaemon(NULL);
      /* well, probably already dead */
      return;
    }
    csHdr.size 
      = htons(sizeof(CS_HEADER));
    csHdr.type
      = htons(CS_PROTO_SHUTDOWN_REQUEST);
    if (SYSERR == writeToSocket(sock,
    				&csHdr)) {
      guiMessage(_("Error sending shutdown request to gnunetd."));
      releaseClientSocket(sock);
      cronCheckDaemon(NULL);
      return;
    }
    if (SYSERR == readTCPResult(sock,
    				&ret)) {
      guiMessage(_("Error reading shutdown confirmation from gnunetd."));
      releaseClientSocket(sock);
      cronCheckDaemon(NULL);
      return;
    }
    if (ret == OK) {
      static GtkWidget * killEntry;
      killEntry
	= glade_xml_get_widget(mainXML,
			       "stopDaemon");
      gtk_widget_set_sensitive(killEntry, FALSE);
      addLogEntry(_("Terminating gnunetd..."));
    } else {
      guiMessage(_("gnunetd refused to shut down (error code '%d')."), 
                ret);
    }
    releaseClientSocket(sock);
  } 
  cronCheckDaemon(NULL);
}

static gint doUpdateMenus(SaveCall * call) {
  static GtkWidget * killEntry = NULL;
  static GtkWidget * launchEntry = NULL;
  static GtkWidget * statsEntryYes = NULL;
  static GtkWidget * statsEntryNo = NULL;
  static int once = 1;
  static int isLocal;
  char * host;
  int ret;

  ret = * (int*) call->args;
  if (once) {
    once = 0;
    killEntry
      = glade_xml_get_widget(mainXML,
			     "stopDaemon");
    launchEntry
      = glade_xml_get_widget(mainXML,
			     "startDaemon");
    statsEntryYes 
      = glade_xml_get_widget(mainXML,
			     "statusPixmapYes");
    statsEntryNo 
      = glade_xml_get_widget(mainXML,
			     "statusPixmapNo");
    host = getConfigurationString("NETWORK",
				  "HOST");
    if ( (host == NULL) ||
	 (strcmp(host, "localhost")==0) )
      isLocal = TRUE;
    else
      isLocal = FALSE;
    FREENONNULL(host);
  }
  if (ret == SYSERR) {
    gtk_widget_hide(statsEntryYes);
    gtk_widget_show_all(statsEntryNo);
    gtk_widget_set_sensitive(killEntry, FALSE);
    gtk_widget_set_sensitive(launchEntry, (TRUE & isLocal) );
  } else {
    gtk_widget_hide(statsEntryNo);
    gtk_widget_show_all(statsEntryYes);
    gtk_widget_set_sensitive(killEntry, TRUE);
    gtk_widget_set_sensitive(launchEntry, FALSE);
  }    
  gtkSaveCallDone(call->sem);
  return FALSE;
}

void cronCheckDaemon(void * dummy) {
  static int last = 42;
  int ret;
  
  ret = checkDaemonRunning();
  if (ret != last) {
    last = ret;    
    gtkSaveCall((GtkFunction) doUpdateMenus, &ret);
  }      
}

/* end of daemon.c */