---

main.c

/*
 *  main.c : main() of the server (flcdd)
 *           This file is part of the FreeLCD package.
 *  $Id: main_8c-source.html,v 1.1 2003/02/16 22:50:41 unicorn Exp $
 *
 *  This program 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 of the License, or (at your
 *  option) any later version.
 * 
 *  This program 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *  MA  02111-1307  USA
 *
 *  Copyright (c) 2002, 2003, Jeroen van den Berg <unicorn@hippie.nu>
 */

#define GNU_PREFIX ""   /* "GNU " */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#ifdef HAVE_UNISTD_H
# include <unistd.h>
#else
# ifdef HAVE_SYS_UNISTD_H
#  include <sys/unistd.h>
# endif
#endif

#ifdef HAVE_LOCALE_H
# include <locale.h>
#endif

#ifdef HAVE_SYSLOG_H
# include <syslog.h>
#else
# define syslog(FOO)
#endif

#ifdef HAVE_TYPES_H
# include <types.h>
#else 
# ifdef HAVE_SYS_TYPES_H
#  include <sys/types.h>
# endif
#endif

#ifdef HAVE_STRING_H
# include <string.h>
#else
# ifdef HAVE_STRINGS_H
#  include <strings.h>
# endif
#endif

#include <pwd.h>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>

#ifdef HAVE_GETOPT_LONG
# include <getopt.h>
#endif

#ifdef HAVE_SOCKET_H
# include <socket.h>
#else
# ifdef HAVE_SYS_SOCKET_H
#  include <sys/socket.h>
# endif
#endif

#include "common/socket.h"

#include "renderers/charrenderer.h"
#include "renderers/charcanvas.h"

#include "connections.h"
#include "drivers.h"
#include "xmlconfig.h"

/* gettext helper macro */
#if ENABLE_NLS
# include <libintl.h>
# define _(foo) gettext (foo)
#else
# define bindtextdomain(X,Y)
# define textdomain(Domain)
# define _(foo) foo
#endif /* enable_nls */

#ifdef HAVE_GETOPT_LONG
/* Options definition */
static struct option longopts[] = {
  {"port", required_argument, 0, 'p'},
#ifdef HAVE_FORK
  {"foreground", no_argument, 0, 'f'},
#endif
  {"help", no_argument, 0, 'h'},
  {"version", no_argument, 0, 'V'},
  {0, 0, 0, 0}
};
#endif /* have getopt_long */



/*----------------------------------------------------- sighup_handler --*/
void
sighup_handler ()
{
  syslog (LOG_INFO, _("received SIGHUP"));
}

/*---------------------------------------------------- sigterm_handler --*/
void
sigterm_handler ()
{
  syslog (LOG_INFO, _("received SIGTERM, exiting"));
  exit (EXIT_SUCCESS);
}

/*------------------------------------------------------- exit_program --*/
void
exit_program ()
{
  syslog (LOG_INFO, _("exiting"));
  closelog ();
  exit (EXIT_FAILURE);
}

/*------------------------------------------------------------ sys_err --*/
void
sys_err (const char *errstr)
{
  syslog (LOG_ERR, errstr);
  exit_program ();
}

/*---------------------------------------------------------- show_help --*/
void
show_help (const char *app_name)
{
  printf (_("Usage: %s [options] ...\nOptions:\n"), app_name);
#ifdef HAVE_GETOPT_LONG
  printf (_(" \
--port, -p <portnr> Let the server listen on another port number\n"));
  printf (_(" --foreground, -f    Run the server in the foreground\n"));
  printf (_(" --help, -h          Program usage\n"));
  printf (_(" --version, -V       Show program version and exit\n"));
#else
  printf (_(" -p <portnr>  Let the server listen on another port number\n"));
  printf (_(" -b           Run the server in the foreground\n"));
  printf (_(" -h           Program usage\n"));
  printf (_(" -V           Show program version and exit\n"));
#endif
  printf (_("\nReport bugs to <%s>\n"), PACKAGE_BUGREPORT);
}

/*------------------------------------------------------- show_version --*/
void
show_version (const char *app_name)
{
  printf ("%s - %s%s\n", app_name, GNU_PREFIX, PACKAGE_STRING);
  printf (_("Copyright (C) %s %s\n"), "2002, 2003", "Jeroen van den Berg");
  printf (_("\
This program is free software; you may redistribute it under the terms of\n\
the GNU General Public License.  This program comes with absolutely NO\n\
WARRANTY. For more information about these matters, see the file named\n\
COPYING.\n"));
}

/*------------------------------------------------ drop_root_privilege --*/
void
drop_root_privilege (const char *user)
{
  struct passwd *pw_ent;

  /*  If we have root privs, try to set our uid to something safer.
   *  First try a specified username, then try "nobody" (which is a
   *  reasonable fallback on most systems).
   */
  if (getuid () == 0 || geteuid () == 0)
    {
      pw_ent = getpwnam (user);
      if (! pw_ent)
        {
          syslog (LOG_WARNING,
                  _("user %s is not a valid user, fallback to 'nobody'\n"),
                  user);
          pw_ent = getpwnam ("nobody");
          if (! pw_ent)
            {
              sys_err (_("cannot drop root privileges, aborting"));
              exit (EXIT_FAILURE);
            }
        }

      if (setuid (pw_ent->pw_uid) < 0)
        sys_err ("setuid");
    }
}


/*--------------------------------------------------------------- main --*/
int
main (int argc, char **argv)
{
  char         c;
  int          run_in_foreground = 0; /* (--foreground) */
  unsigned int port = 8800; /* (--port) */
  const char   *app_name;
  pid_t        child; 
  long         tmp;
  socket_t     sock;
  fd_set       fdset;
  xml_node     *xconf;
  xml_node     *output_config;
  void         *driver;
  xml_node *fooxy;
  cl_layout *foox;
  cc_canvas *canvas;
  unsigned int i;
  
  /* Set up gettext internationalisation */
  setlocale (LC_ALL, "");
  bindtextdomain (PACKAGE, "/usr/share/locale");        /* LOCALEDIR ); */
  textdomain (PACKAGE);

  /* Find out name of executable */
  app_name = *argv + strlen (*argv) - 1;
  while (app_name > *argv && *(app_name - 1) != '/')
    --app_name;

  /* Parse command line options */
#ifdef HAVE_GETOPT_LONG
  while ((c = getopt_long (argc, argv, "p:bhV", longopts, 0)) > 0)
#else
  while ((c = getopt (argc, argv, "p:bhV")) > 0)
#endif
    {
      switch (c)
        {
        case 'p':               /* --port, -p */
          tmp = strtol (optarg, 0, 10);
          if (errno == ERANGE || tmp < 1 || tmp > 65536)
            {
              fprintf (stderr,
                       _("Port number must be between 1 and 65536\n"));
              exit (EXIT_FAILURE);
            }
          port = tmp;
          break;

        case 'f':               /* --foreground, -f */
          run_in_foreground = 1;
          break;
          
        case 'h':               /* --help, -h */
          show_help (app_name);
          exit (EXIT_SUCCESS);
          break;

        case 'V':               /* --version, -V */
          show_version (app_name);
          exit (EXIT_SUCCESS);
          break;

        case '?':               /* Invalid option */
          show_help (app_name);
          exit (EXIT_FAILURE);
          break;

        default:
          /* In an ideal world, this shouldn't happen. */
          exit (EXIT_FAILURE);
        }
    }

  if (optind < argc)
    {
      perror (_("too many arguments"));
      exit (EXIT_FAILURE);
    }

  /* Fork into the background */
#ifdef HAVE_FORK
  if (!run_in_foreground)
    {
      child = fork();
      if( child < 0 )
        sys_err( "fork" );
            
      if( child != 0 )
        exit( EXIT_SUCCESS );

      /* Create a new session */
      if( setsid() < 0 )
        sys_err( "setsid" );
    }
#endif

  /* Configure system logging */
  openlog (app_name, LOG_CONS | LOG_PID | LOG_PERROR, LOG_DAEMON);

  /* Take some precautions */
  /*
  if( chdir( "/" ) < 0 )
    sys_err( "chdir" );
  */
  umask (0);
  if (!run_in_foreground)
    {
      close( STDOUT_FILENO );
      close( STDERR_FILENO );
    }
  close( STDIN_FILENO );

  /* Open server socket */
  sock = socket_create_server (port, &fdset);
  if (sock < 0)
    {
      switch (sock)
        {
        case -1:
          sys_err ("socket()");
          break;
        case -2:
          sys_err ("setsockopt()");
          break;
        case -3:
          sys_err ("bind()");
          break;
        case -4:
          sys_err ("listen()");
          break;
        default:
          sys_err (_("cannot open server socket"));
          break;
        }
      exit (EXIT_FAILURE);
    }

  /* We do not need "dangerous" privileges anymore, drop them before
   * messing with potential dangers like plug-ins. 
   */
  drop_root_privilege (app_name);

  /* Parse rc file */
  xconf = xc_parse_config_file ("flcdd.xml");
  if (! xconf)
    {
      sys_err (_("Failed to parse inifile"));
      exit (EXIT_FAILURE);
    }

  /* FIXME */
  fooxy = xc_parse_config_file ("../renderers/testlayout.xml");
  foox = cl_make_layout (fooxy);

  canvas = cc_create_canvas (20, 4);
  for (i = 0; i < foox->layout_data_size; ++i)
    {
      unsigned int x = foox->layout_data[i].x;
      unsigned int y = foox->layout_data[i].y;
      unsigned int j;

      for (j = 0; j < foox->layout_data[i].width; ++j)
        cc_put_char (canvas, x + j, y, foox->layout_data[i].utf8_data[j]);
    }

  /* Load driver modules */
  drivers_init ();
  output_config = 0;
  while ((output_config = xmlt_find (xconf, output_config, OUTPUT)) != 0)
    {
      const char* output_id_s = xmlt_get_attrib (output_config, ID);
      int output_id = 1;

      if (output_id_s)
          output_id = atoi (output_id_s);

      driver = drivers_create_output (output_config);

      if (!driver)
        puts ("drivers_create_output failed");
    }

  drivers_process_canvas (driver, canvas);
  xmlt_free_document (xconf);

  signal (SIGHUP, sighup_handler);
  signal (SIGTERM, sigterm_handler);

  /* Enter event loop */
  /* syslog (LOG_INFO, _("running")); */
  while (1)
    {
      /*  Poll the sockets from our file descriptor set, and call
       *  one of the conn_* functions whenever something interesting
       *  happens.
       */
      socket_poll (sock, &fdset, conn_open, conn_data, conn_close);
    }

  closelog ();
  return EXIT_SUCCESS;
}

---