/* -*- linux-c -*-

 *

 * Copyright (C) 2007-2008, Hewlett-Packard Development Company, LLP

 * (C) Copyright IBM Corp. 2007

 * (C) Copyright Ulrich Kleber 2011

 *

 * 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.  This

 * file and program are licensed under a BSD style license.  See

 * the Copying file included with the OpenHPI distribution for

 * full licensing terms.

 *

 * Author(s):

 *      Shuah Khan <shuah.khan@hp.com>

 *	Renier Morales <renier@openhpi.org>

 *      Ulrich Kleber <ulikleber@users.sourceforge.net>

 *

 * Changes:

 *    20/01/2011  ulikleber  Refactoring to use glib for option parsing and

 *                           introduce common options for all clients

 *

 */

#include "oh_clients.h"

static gint     optdid                           = SAHPI_UNSPECIFIED_DOMAIN_ID;

static gboolean optdebug                         = FALSE;

static gboolean optverbose                       = FALSE;

static gchar    *optep        = NULL;

static gchar    *optdaemon    = NULL;    

static gchar    *optcfgfile   = NULL;    

static GOptionEntry domain_option[] =

{

  { "domain",       'D', 0, G_OPTION_ARG_INT,    &optdid,     "Select domain id nn",         "nn" },

  { NULL }

};

static GOptionEntry debug_option[] =

{

  { "debug",        'X', 0, G_OPTION_ARG_NONE,   &optdebug,   "Display debug messages",      NULL },

  { NULL }

};

static GOptionEntry verbose_option[] =

{

  { "verbose",      'V', 0, G_OPTION_ARG_NONE,   &optverbose, "Verbose mode",                NULL },

  { NULL }

};

static GOptionEntry entity_path_option[] =

{

  { "entity-path",  'E', 0, G_OPTION_ARG_STRING, &optep,      "Use entity path epath",       "\"epath\"" },

  { NULL }

};

static GOptionEntry host_option[] =

{

  { "host",         'N', 0, G_OPTION_ARG_STRING, &optdaemon,  "Open session to the domain served by the daemon\n"

"                               at the specified URL (host:port)\n"

"                               This option overrides the OPENHPI_DAEMON_HOST and\n"

"                               OPENHPI_DAEMON_PORT environment variables.",                 "\"host<:port>\"" },

  { NULL }

};

static GOptionEntry clientconf_option[] =

{

  { "cfgfile",      'C', 0, G_OPTION_ARG_FILENAME, &optcfgfile, "Use passed file as client configuration file\n"

"                               This option overrides the OPENHPICLIENT_CONF\n"

"                               environment variable.",                                      "\"file\"" },

  { NULL }

};

#ifdef _WIN32

/*--------------------------------------------------------------------*/

/* Function: setenv                                                   */

/*--------------------------------------------------------------------*/

static int setenv(const char * var, const char * val, int overwrite)

{

    static const size_t BUFSIZE = 1024;

    char buf[BUFSIZE];

    snprintf(buf, BUFSIZE, "%s=%s", var, val);

    return _putenv(buf);

}

#endif /* _WIN32 */

/*--------------------------------------------------------------------*/

/* ohc_domain_add_by_options                                          */

/*--------------------------------------------------------------------*/

static SaErrorT ohc_domain_add_by_options(oHpiCommonOptionsT *opt)

{

   SaErrorT rv = SA_OK;

   SaHpiDomainIdT did_N = SAHPI_UNSPECIFIED_DOMAIN_ID;

   SaHpiEntityPathT entity_root;

   const char *envhoststr, *envportstr;

   unsigned short envport;

   SaHpiTextBufferT envhost;

   SaHpiDomainIdT did_env = SAHPI_UNSPECIFIED_DOMAIN_ID;

   oh_init_ep(&entity_root);

   // Add a domain for the -N option

   if (opt->withdaemonhost) {// add a domain for that host

      if (opt->domainid == SAHPI_UNSPECIFIED_DOMAIN_ID) { // add with generated did  

         rv = oHpiDomainAdd ( &opt->daemonhost, opt->daemonport, &entity_root, &did_N );

         if (rv != SA_OK) {

            CRIT("Domain could not be created for given daemonhost");

            return rv;

         }

         if (opt->debug) DBG("Added domain %u for daemonhost", did_N);

         // use this did (thus -N option will override environment variables)

         opt->domainid = did_N;

      }

      else { // add with given domain id

         rv = oHpiDomainAddById ( opt->domainid, &opt->daemonhost, opt->daemonport, &entity_root );

         if (rv != SA_OK) {

            CRIT("Domain %u could not be created for given daemonhost", opt->domainid);

            return rv;

         }

         if (opt->debug) DBG("Added domain %u for daemonhost", opt->domainid);

      }

   }

   // check always for the environment variables.

   envhoststr = getenv("OPENHPI_DAEMON_HOST");

   if (envhoststr != NULL) { // add a domain for this host

      oh_init_textbuffer(&envhost);

      rv = oh_append_textbuffer(&envhost, envhoststr);

      envportstr = getenv("OPENHPI_DAEMON_PORT");

      if (envportstr == NULL) envport = OPENHPI_DEFAULT_DAEMON_PORT;

      else envport = atoi(envportstr);

      if (opt->withdaemonhost) { // we will add the domain with a new did, but

                                 // we will not use it now.

         rv = oHpiDomainAdd ( &envhost, envport, &entity_root, &did_env );

         if (rv != SA_OK) {

            CRIT("Domain could not be created for OPENHPI_DAEMON_HOST %s:%u",

                 envhoststr, envport);

            return rv;

         }

         if (opt->debug) DBG("Added domain %u for OPENHPI_DAEMON_HOST %s:%u", 

                             did_env, envhoststr, envport);

      } 

      else if (opt->domainid == SAHPI_UNSPECIFIED_DOMAIN_ID) { 

         // add with generated did  (here we don't have -N or -D options)

         rv = oHpiDomainAdd ( &envhost, envport, &entity_root, &did_env );

         if (rv != SA_OK) {

            CRIT("Domain could not be created for OPENHPI_DAEMON_HOST %s:%u",

                 envhoststr, envport);

            return rv;

         }

         if (opt->debug) DBG("Added domain %u for OPENHPI_DAEMON_HOST %s:%u", 

                             did_env, envhoststr, envport);

         opt->domainid = did_env;

      }

      else { // use the given did for OPENHPI_DAEMON_HOST

         rv = oHpiDomainAddById ( opt->domainid, &envhost, envport, &entity_root );

         if (rv != SA_OK) {

            CRIT("Domain %u could not be created for OPENHPI_DAEMON_HOST %s:%u", 

                 opt->domainid, envhoststr, envport);

            return rv;

         }

         if (opt->debug) DBG("Added domain %u for OPENHPI_DAEMON_HOST %s:%u", 

                 opt->domainid, envhoststr, envport);

      }

   }

   return SA_OK;

}

/*--------------------------------------------------------------------*/

/* oh_prog_version                                                    */

/*--------------------------------------------------------------------*/

void oh_prog_version(const char *prog_name)

{

	SaHpiUint32T ohpi_major = oHpiVersionGet() >> 48;

        SaHpiUint32T ohpi_minor = (oHpiVersionGet() << 16) >> 48;

        SaHpiUint32T ohpi_patch = (oHpiVersionGet() << 32) >> 48;

        SaHpiVersionT hpiver;

        printf("%s - This program came with OpenHPI %u.%u.%u\n",

               prog_name, ohpi_major, ohpi_minor, ohpi_patch);

        hpiver = saHpiVersionGet();

        printf("SAF HPI Version %c.0%d.0%d\n\n",

               (hpiver >> 16) + ('A' - 1),

               (hpiver & 0x0000FF00) >> 8,

               hpiver & 0x000000FF);

}

/*--------------------------------------------------------------------*/

/* ohc_option_parse                                                   */

/*--------------------------------------------------------------------*/

gboolean ohc_option_parse(int *argc, char *argv[],  

                         GOptionContext     *context,

                         oHpiCommonOptionsT *common_options,

                         SaHpiUint8T        optionmask )

{

   GError *error = NULL;

   SaErrorT rv = SA_OK;

   if (!argc || !argv || !context || !common_options) {

      CRIT ("Internal error. Terminating.");

      return FALSE;

   }

   if (optionmask & OHC_DOMAIN_OPTION)

      g_option_context_add_main_entries (context, domain_option, NULL);

   if (optionmask & OHC_DEBUG_OPTION)

      g_option_context_add_main_entries (context, debug_option, NULL);

   if (optionmask & OHC_VERBOSE_OPTION)

      g_option_context_add_main_entries (context, verbose_option, NULL);

   if (optionmask & OHC_ENTITY_PATH_OPTION)

      g_option_context_add_main_entries (context, entity_path_option, NULL);

   if (optionmask & OHC_HOST_OPTION)

      g_option_context_add_main_entries (context, host_option, NULL);

   if (optionmask & OHC_CLIENTCONF_OPTION)

      g_option_context_add_main_entries (context, clientconf_option, NULL);

   if (!g_option_context_parse (context, argc, &argv, &error)) {

           CRIT ("option parsing failed: %s\n",error->message);

           // CRIT ("\n%s", g_option_context_get_help (context, FALSE, NULL)); 

           // Needs glib-2.14 

           return FALSE;

   }

   common_options->withentitypath = (optep != NULL);

   common_options->withdaemonhost = (optdaemon != NULL);

   if (optdebug && optverbose) {

      DBG("Parsing of options completed. Common options:\n --debug --verbose");

      if (optdid >= 0)                    DBG(" --domain=%u ",optdid);

      if (common_options->withentitypath) DBG(" --entity-path=%s ",optep);

      if (common_options->withdaemonhost) DBG(" --daemon=%s ",optdaemon);

   }

   /* prepare output */

   common_options->debug      = optdebug;

   common_options->verbose    = optverbose;

   common_options->domainid   = optdid;

   oh_init_ep(&common_options->entitypath); 

   if (common_options->withentitypath) {

      rv = oh_encode_entitypath(optep, &common_options->entitypath);

      if (optdebug) DBG("oh_encode_entitypath returned %s", oh_lookup_error(rv));

      if (rv) {

         CRIT ("oh_encode_entitypath() returned %s", oh_lookup_error(rv));

         CRIT ("Invalid entity path: %s", optep);

         return FALSE;

      }

      if (optdebug && optverbose) {

         DBG("Entity Path encoded successfully: ");

         oh_print_ep(&common_options->entitypath, 0);

      }

   }

   oh_init_textbuffer(&common_options->daemonhost);

   if (common_options->withdaemonhost) {

      char * hostbegin = NULL;

      char * hostend = NULL;

      char * portbegin = NULL;

      if ( *optdaemon == '[' ) {

         hostbegin = optdaemon + 1;

         hostend = strchr(hostbegin, ']');

         if (hostend==NULL) {

            CRIT("Ill-formed host: %s", optdaemon);

            return FALSE;

         }

      } else {

         hostbegin = optdaemon;

         hostend = strchr(hostbegin, ':');

      }

      if (hostend) {

         portbegin = strchr(hostend, ':' );

         if (portbegin) {

            ++portbegin;

         }

         *hostend = '\0';

      }

      rv = oh_append_textbuffer(&common_options->daemonhost, hostbegin);

      if (portbegin) {

         common_options->daemonport = atoi(portbegin);

      } else {

         common_options->daemonport = OPENHPI_DEFAULT_DAEMON_PORT;

      }

      if (optdebug && optverbose) {

         DBG("Daemon host:port scanned successfully: host=%s", hostbegin);

         DBG("Daemon host:port scanned successfully: port=%u", common_options->daemonport);

      }

   }

   oh_init_textbuffer(&common_options->clientconf);

   if (optcfgfile) {

      rv = oh_append_textbuffer(&common_options->clientconf, optcfgfile);

      setenv("OPENHPICLIENT_CONF", optcfgfile, 1);  // -C option overrides environment var

   }

   g_free (optep);

   g_free (optdaemon);

   g_free (optcfgfile);

   // add domains for -N option and environment variables

   ohc_domain_add_by_options ( common_options );

   return TRUE;

}

/*--------------------------------------------------------------------*/

/* ohc_session_open_by_option                                         */

/*--------------------------------------------------------------------*/

SaErrorT ohc_session_open_by_option (

                      oHpiCommonOptionsT *opt,

                      SaHpiSessionIdT    *sessionid)

{

   SaErrorT rv = SA_OK;

   if (opt->debug) {

      if (opt->domainid==SAHPI_UNSPECIFIED_DOMAIN_ID) DBG("saHpiSessionOpen");

      else DBG("saHpiSessionOpen to domain %u",opt->domainid);

   }

   rv = saHpiSessionOpen(opt->domainid, sessionid, NULL);

   if (rv != SA_OK) {

      CRIT("saHpiSessionOpen returns %s",oh_lookup_error(rv));

      return rv;

   }

   if (opt->debug)

      DBG("saHpiSessionOpen returns with SessionId %u", *sessionid);

   return SA_OK;

}

 /* end clients.c */