safmgr.c

Go to the documentation of this file.

/****************************************************************************
 *
 *      Copyright (C) 2006-2007 Micro Focus (IP) Limited.
 *      All rights reserved.
 *
 * The software and information contained herein are proprietary to, and
 * comprise valuable trade secrets of, Micro Focus International Ltd., 
 * which intends to preserve as trade secrets such software and 
 * information. This software is an unpublished copyright of Micro Focus  
 * and may not be used, copied, transmitted, or stored in any manner.  
 * This software and information or any other copies thereof may not be
 * provided or otherwise made available to any other person.
 *
 *      Enterprise Server SAF (Security) Manager
 *      Manager Startup and Control
 *
 *      @(#)safmgr.c   $Revision: 1.2 $     
 *
 *      $Date: 2008/07/01 08:32:52 $
 *
 ****************************************************************************/

/* Copyright */
static const char *copyright =
   "Copyright (C) 2006-2007 Micro Focus (IP) Limited";
static const char *sccsid =
   "@(#)safmgr.c  $Revision: 1.2 $ built " __DATE__ " " __TIME__;

/* Start of source module safmgr.c */


/* System Headers */

/* ANSI/ISO standard headers */
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <ctype.h>

/* UNIX headers */
#if defined(UNIX)
#   include <unistd.h>
#   include <sys/time.h>
#endif

/* Win32 headers */
#if defined(WIN32)
#   include <windows.h>
#   include <sys/types.h>
#   include <sys/stat.h>
#endif


/* External Headers */
#if defined(UNIX)
#  include "gptypes.h"          /* RTS types, req. by CCI */
#elif defined(WIN32)
#  include "pc_rts.h"           /* ditto for Win32 */
#endif
#include "cci.h"                /* CCI API and types */
                                /* (required for mf_os_size typedef) */
#include "mdsa.h"               /* MDSA SAF and ESM configuration */


/* SAF Headers */
#include "safmgr.h"
#include "saf-env.h"
#include "saf-cache.h"
#include "saf-esm.h"
#include "saf-process.h"
#include "saf-audit.h"
#include "mfaudit.h"

#if defined(WIN32)
   /* Stub DLL initialization entry point for C RTS */
   BOOL APIENTRY DllMain(HANDLE Inst, DWORD Reason, LPVOID Reserved)
   {
      switch (Reason)
      {
         case DLL_PROCESS_ATTACH:
         case DLL_THREAD_ATTACH:
         case DLL_PROCESS_DETACH:
         case DLL_THREAD_DETACH:
            break;
      }
      return TRUE;
   }
#endif


static int EsmCmp(const void *EPtr1, const void *EPtr2);

/* SAF Manager state */
static enum
{
   SafUNINITIALIZED = 0
 , SafRUNNING       = 1
 , SafTERMINATED    = 2
} ManagerState = SafUNINITIALIZED;

/* SAF Manager Custom Configuration associative store */
static struct SafStore *CustCfg = NULL;



mf_uns32 safmgr(struct SafInit *Init)
{
   unsigned Esm;
   mf_uns32 Ret = SafINIT_OK;
   struct SafInit *NewSafInit = NULL, *CallerInit = NULL;
   struct cas_saf_config_internal *NewSafCfg;
   struct cas_esm_config_internal *NewEsmCfg;
   char *CfgVal = NULL;
   SafRet SRet;


   #if defined WIN32 && defined _DEBUG
      /***
      Auto-debug support: create a file named c:/tmp/debug-safmgr.  The
      first process to open this file in exclusive mode will call DebugBreak().
      ***/

      if
      (
         CreateFile
         (
            "c:/tmp/debug-safmgr"
          , FILE_READ_DATA
          , 0                         /* unsharable */
          , NULL
          , OPEN_EXISTING
          , 0
          , NULL
         ) != INVALID_HANDLE_VALUE
      )
      {
         #if 0
            DebugBreak();
         #elif 0
            extern void CBL_DEBUGBREAK(void);
            CBL_DEBUGBREAK();
         #else
            char DbgBuf[80];
            DWORD Pid = GetCurrentProcessId();
            sprintf(DbgBuf, "cmd /c \"start windbg -p %lu\"", Pid);
            system(DbgBuf);
            Sleep(15000);
            DebugBreak();
         #endif
      }
   #endif

   if (! Init)
   {
      Ret = SafINIT_NULL;
      goto done;
   }

   /***
   Try to heuristically distinguish between version skew and invalid
   input: assume that Version should be an integer in the range [0,10]
   for the foreseeable future.  Similarly, assume that we have garbage
   if ESMCnt is more than 10 times the current maximum.
   ***/

   if (Init->Version > 10 ||
       Init->ESMCnt > 10*SafESM_MAX)
   {
      Ret = SafINIT_BAD_CB;
      goto done;
   }

   /* Now check for "sensible" errors */
   if (Init->Version != SafMGR_API_VER)
   {
      Ret = SafINIT_VER;
      goto done;
   }
   if (! Init->Config)
   {
      Ret = SafINIT_CFG;
      goto done;
   }
   if (Init->ESMCnt > SafESM_MAX)
   {
      Ret = SafINIT_CNT;
      goto done;
   }

   /* Make sure all the ESMs have configuration blocks */
   for (Esm = 0; Esm < Init->ESMCnt; Esm++)
      if (! Init->ESMCfg[Esm])
      {
         Ret = SafINIT_ESMCFG;
         goto done;
      }


   /* Structure looks OK; reset error indicators */
   Init->Reason = Init->Detail = 0;
   
   /* Return now if we're already initialized */
   /* TODO: Handle reconfigure here */
   if (ManagerState == SafRUNNING)
   {
      Ret = SafINIT_OK;
      goto done;
   }

   /***
   Copy the configuration areas, convert integer values to native
   ordering, and change the init structure to point to the copies.  This
   is necessary because the structures are shared, and CAS expects the
   values to remain unchanged; and because we have no guarantee that
   callers won't discard the init structure.  (CAS doesn't, currently,
   but MFDS might, and it'd be a very dodgy thing to rely on.)
   ***/

   /* Copy SAF Init structure */
   NewSafInit = malloc(sizeof *NewSafInit);
   if (! NewSafInit)
   {
      Ret = SafINIT_RESRCE;
      goto done;
   }
   *NewSafInit = *Init;

   /* Replace Init with copy */
   CallerInit = Init;
   Init = NewSafInit;

   /* Copy SAF Manager config */
   NewSafCfg = malloc(sizeof *NewSafCfg);
   if (! NewSafCfg)
   {
      Ret = SafINIT_RESRCE;
      goto done;
   }

   NewSafCfg->version = SafNative32u(Init->Config->version);
   NewSafCfg->cache_TTL = SafNative32u(Init->Config->cache_TTL);
   NewSafCfg->cache_limit = SafNative32u(Init->Config->cache_limit);
   NewSafCfg->option_flags = SafNative32u(Init->Config->option_flags);

   /* TODO: Parse config so we don't have to save it */
   NewSafCfg->config = Init->Config->config;
   NewSafCfg->reserved = Init->Config->reserved;

   /* Replace SAF config with copy */
   Init->Config = NewSafCfg;

   /* Copy ESM configs */
   for (Esm = 0; Esm < Init->ESMCnt; Esm++)
   {
      NewEsmCfg = malloc(sizeof *NewEsmCfg);
      if (! NewEsmCfg)
      {
         Ret = SafINIT_RESRCE;
         goto done;
      }
      
      NewEsmCfg->version = SafNative32u(Init->ESMCfg[Esm]->version);
      NewEsmCfg->state = SafNative32u(Init->ESMCfg[Esm]->state);
      NewEsmCfg->priority = SafNative32u(Init->ESMCfg[Esm]->priority);
      NewEsmCfg->cache_TTL = SafNative32u(Init->ESMCfg[Esm]->cache_TTL);
      NewEsmCfg->cache_limit = SafNative32u(Init->ESMCfg[Esm]->cache_limit);

      strcpy(NewEsmCfg->name, Init->ESMCfg[Esm]->name);
      strcpy(NewEsmCfg->module, Init->ESMCfg[Esm]->module);
      strcpy(NewEsmCfg->psz_id, Init->ESMCfg[Esm]->psz_id);
      strcpy(NewEsmCfg->psz_pwd, Init->ESMCfg[Esm]->psz_pwd);
      strcpy(NewEsmCfg->psz_connection_path,
             Init->ESMCfg[Esm]->psz_connection_path);

      /* TODO: Save copy of config? (Not nec for CAS) */
      NewEsmCfg->config = Init->ESMCfg[Esm]->config;
      NewEsmCfg->reserved = Init->ESMCfg[Esm]->reserved;

      /* Replace ESM config with copy */
      Init->ESMCfg[Esm] = NewEsmCfg;
   }

   /* Sort the ESMs by priority */
   qsort(Init->ESMCfg, Init->ESMCnt, sizeof *Init->ESMCfg, EsmCmp);


   /* Initialize the environment */
   Ret = SafEnvInit(Init);

   /* Don't return an internal code */
   if (Ret >= SafINIT_BADENV || (Ret == SafINIT_FAIL && ! Init->Reason))
   {
      /***
      We can't log this - the environment module is required for logging,
      and it didn't initialize successfully.
      ***/

      Init->Reason = SafMGR_FAIL_ENV;
      Init->Detail = Ret;
      Ret = SafINIT_FAIL;
   }
   if (Ret) goto done;


   /***
   Load the manager's custom configuration information into an associative
   store for later querying.  We have to do this after environment
   initialization, because the Store functions use some environment
   functionality (eg serialization).
   ***/

   SRet = SafAllocStore(&CustCfg);
   if (SRet)
   {
      Init->Reason = SafMGR_FAIL_RESOURCE;
      Ret = SafINIT_FAIL;
      goto done;
   }

   if (Init->Config->config) SafStoreLoad(CustCfg, Init->Config->config);

   /***
   548616: Allow "ES_ESF_ALLOW_LIST" to set [Admin]/allow-list if the
   latter isn't set in the configuration. Undocumented; used only by
   Testing.
   ***/

   SRet = SafQueryCfg("Admin", "allow-list", &CfgVal);
   if (SRet || !CfgVal || !*CfgVal)
   {
      char *EnvVal = getenv("ES_ESF_ALLOW_LIST");
      if (EnvVal) SafStoreAdd(CustCfg, "Admin", "allow-list", EnvVal);
   }


   /* Initialize auditing */
   Ret = SafInitAuditing(Init);

   /* Don't return an internal code */
   if (Ret >= SafINIT_BADENV || (Ret == SafINIT_FAIL && ! Init->Reason))
   {
      Init->Reason = SafMGR_FAIL_ENV;
      Init->Detail = Ret;
      Ret = SafINIT_FAIL;
   }
   if (Ret)
   {
      /* TODO: Refactor this code for explaining return codes */
      const char *Reason = "unrecognized failure code";

      switch (Ret)
      {
         case SafINIT_EXTERNAL:
            Reason = "Could not connect to audit manager";
            break;
         case SafINIT_ENVFUNC:
            Reason = "Could not resolve audit functions";
            break;
      }

      SafLog
      (
         601
       , SafMsgCRIT
       , "Auditing subsystem startup failed: (%d) %s"
       , Ret
       , Reason
      );

      goto done;
   }
   
   /* AUDITEVENTCALL Subsystem Event: Initialization */
   Ret = SafRaiseAuditEvent
   (
      AUDIT_EVENT_SAFMGR_INITIALIZING
    , AUDIT_EVENT_CATEGORY_SYSTEM
    , 0
   );

   /* Don't return an internal code */
   if (Ret >= SafINIT_BADENV || (Ret == SafINIT_FAIL && ! Init->Reason))
   {
      /* TODO: Log this */
      Init->Reason = SafMGR_FAIL_ENV;
      Init->Detail = Ret;
      Ret = SafINIT_FAIL;
   }
   if (Ret) goto done;


   /* TODO: Initialize the cache */


   /* Initialize the ESM Modules */
   Ret = SafEsmInit(Init);
   if (Ret >= SafINIT_BADENV || (Ret == SafINIT_FAIL && ! Init->Reason))
   {
      if (! Init->Reason)
         Ret = SafINIT_OTHER;
      else
         Ret = SafINIT_FAIL;
   }

   if (Ret)
   {
      /* TODO: Shut down any ESMs that did start (note that Init->ESMCnt
         will have been updated) */
      goto done;
   }


   /* Initialize the request processor */
   Ret = SafProcInit(Init);
   if (Ret) goto done;


   /* Initialization succeeded */
   SafThrLock("manager-state", 1);
   ManagerState = SafRUNNING;
   SafThrUnlock("manager-state");

done:

   if (CallerInit)
   {
      /* Copy back return fields */
      CallerInit->Reason = Init->Reason;
      CallerInit->Detail = Init->Detail;
      CallerInit->ESMCnt = Init->ESMCnt;
   }

   switch (Ret)
   {
      case SafINIT_OK:
         /* AUDITEVENTCALL Subsystem Event: Initialized */
         SafRaiseAuditEvent
         (
            AUDIT_EVENT_SAFMGR_STARTED
          , AUDIT_EVENT_CATEGORY_SYSTEM
          , 0
         );
         break;

      case SafR_PARAM:
      case SafR_RESOURCE:
      case SafR_EXFAIL:
      case SafR_STATE:
      case SafR_INTERNAL:
      case SafR_NOTFOUND:
      case SafR_TRUNCATED:
      default:
         /* AUDITEVENTCALL Subsystem Event: Initialization Failure */
         /* RaiseAuditEvent(); */
         break;
   }

   return Ret;
}


mf_uns32 safterm(mf_uns32 What, void *Reserved)
{
   /***
   TODO: Call cache manager, call environment; in environment, if MFDS,
   should call cobtidy / cobthreadtidy (probably - check with Henry).
   In MFDS, need to end UOW/task or process locks, for thread or process
   exit respectively.  (In MFDS, we don't distinguish between UOWs and
   tasks.)
   ***/

   if (What == SafTERM_PROCESS)
   {
      /* Serialize */
      SafThrLock("manager-state", 1);

      if (ManagerState == SafRUNNING) 
      {
         /* Audit */
         SafRaiseAuditEvent
         (
            AUDIT_EVENT_SAFMGR_TERMINATING
          , AUDIT_EVENT_CATEGORY_SYSTEM
          , 0
         );

         /* Notify ESMs */
         SafEsmExit();

         /* Update manager state */
         ManagerState = SafTERMINATED;
      }

      SafThrUnlock("manager-state");
   }

   return 0;
}


int SafState(void)
{
   return (int)ManagerState;
}


SafRet SafQueryCfg(const char *Class, const char *Name, char **ValueP)
{
   return SafStoreFind(CustCfg, Class, Name, (void**)ValueP);
}



/* Helper function to convert network-order mf_uns32 values to native */
mf_uns32 SafNative32u(mf_uns32 NetValue)
{
   unsigned char *Bytes = (unsigned char *)&NetValue;
   return (Bytes[0] << 24) |
          (Bytes[1] << 16) |
          (Bytes[2] <<  8) |
          (Bytes[3] <<  0);
}


/* Helper function to compare two ESM configs by priority value */
static int EsmCmp(const void *EPtr1, const void *EPtr2)
{
   /***
   The following shouldn't require a cast, as far as I can tell.  void* is
   convertible into any object pointer type, and qualified-void* should be
   convertible into any object pointer type that's similarly qualified.
   But IBM's VAC++ (in C mode) complains.
   ***/

   const struct cas_esm_config_internal
      **EsmPtr1 = (const struct cas_esm_config_internal **)EPtr1,
      **EsmPtr2 = (const struct cas_esm_config_internal **)EPtr2;

   /***
   We want to sort by lowest-priority-first, so return a negative number
   if the first ESM has a lower priority than the second, and so on.
   Note we've already ensured there are no null pointers in array.
   ***/

   return (*EsmPtr1)->priority - (*EsmPtr2)->priority;
}


/* end of source module safmgr.c */