Merge git.joyent.com:illumos-joyent20120517

1 files changed, 0 insertions, 2307 deletions

diff --git a/usr/src/lib/libkmsagent/common/SYSCommon.c b/usr/src/lib/libkmsagent/common/SYSCommon.c
deleted file mode 100644
index dd418fec4b..0000000000
--- a/usr/src/lib/libkmsagent/common/SYSCommon.c
+++ /dev/null
@@ -1,2307 +0,0 @@
-/*
- * CDDL HEADER START
- *
- * The contents of this file are subject to the terms of the
- * Common Development and Distribution License (the "License").
- * You may not use this file except in compliance with the License.
- *
- * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
- * or http://www.opensolaris.org/os/licensing.
- * See the License for the specific language governing permissions
- * and limitations under the License.
- *
- * When distributing Covered Code, include this CDDL HEADER in each
- * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
- * If applicable, add the following below this CDDL HEADER, with the
- * fields enclosed by brackets "[]" replaced with your own identifying
- * information: Portions Copyright [yyyy] [name of copyright owner]
- *
- * CDDL HEADER END
- */
-
-/*
- * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
- */
-
-/*---------------------------------------------------------------------------
- * Module:            SYSCommon.c
- *-------------------------------------------------------------------------*/
-
-#include <stdio.h>
-#include "SYSCommon.h"
-#include <time.h>
-#include <errno.h>
-#include <sys/stat.h> 
-#include <sys/types.h>
-#include <signal.h>
-
-#ifndef WIN32
-#include <unistd.h>
-#endif
-
-#ifdef WIN32
-#include <io.h>
-#include <stdlib.h>   /* for malloc, calloc, and free */
-#elif defined K_LINUX_PLATFORM
-#include <unistd.h>   /* it includes usleep(us) */
-#include <sys/time.h>
-#include <fts.h>
-#else
-/*
- * Directory traversal code is not yet available for Solaris.
- * If such code will need to be written, then it will probably use ftw.h.
- */
-#endif
-
-#ifdef K_SOLARIS_PLATFORM
-/* For K_AdjustLocalClock */
-#include <unistd.h>
-/* For K_SetRootPassword */
-#define    __EXTENSIONS__    /* to expose flockfile and friends in stdio.h */ 
-#include <errno.h>
-#include <libgen.h>
-#include <malloc.h>
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <strings.h>
-#include <stropts.h>
-#include <unistd.h>
-#include <termio.h>
-#include <security/pam_appl.h>
-#include <widec.h>
-#endif
-
-#ifdef K_LINUX_PLATFORM
-extern int pthread_mutexattr_settype __P ((pthread_mutexattr_t *__attr,
-                       int __kind));
-#endif
-
-#ifdef K_HPUX_PLATFORM
-int64 atoll(const char *str)
-{
-    int64 tmp = 0;
-    sscanf(str, "%lld", &tmp);
-    return tmp;
-}
-
-#endif
-
-
-/*---------------------------------------------------------------------------
- * Function: K_CreateThread
- *
- * Description:
- *  Thread creation function "CreateThread" takes a thread function
- *  and its parameter to create a thread. It also has a Boolean
- *  parameter to indicate if the thread is detached or joinable.
- *  A new thread's handle is returned through the output parameter.
- *
- * Input
- * -----
- *    i_pFunc         Function pointer of the thread function
- *    i_pvData        The point of the parameter passed to the thread function
- *    i_bIsDetached   The thread is detached or not
- *                    (Note: It is not supported on Win32)
- *
- * Output
- * ------
- *    o_pNewThread    The Thread handle
- *
- * Return value       Error code
- *
- *--------------------------------------------------------------------------*/
-
-int K_CreateThread(K_ThreadFunc i_pFunc,
-                  void *i_pvData,
-                  int i_bIsDetached,
-                  K_THREAD_HANDLE *o_pNewThread)
-{
-    int iOK = K_SYS_OK;
-    int iReturn = 0;
-
-#ifdef WIN32
-
-    {
-       unsigned id;
-
-        *o_pNewThread = (HANDLE)_beginthreadex(NULL,
-                                        0,
-                                        (int (_stdcall *) (void *vpData))i_pFunc,
-                                        i_pvData,
-                                        0,
-                                        &id);
-
-
-        if(*o_pNewThread == 0)
-        {
-#ifdef SYS_DEBUG
-            printf(" (%s, %d): error creating pthread, error = %d\n",
-                __FILE__, __LINE__, iReturn);
-#endif
-            return K_SYS_ERR_CREATE_THREAD;
-        }
-
-        return K_SYS_OK;
-    }
-
-#else
-    pthread_attr_t attr;
-    
-    iReturn = pthread_attr_init(&attr);
-
-    if ( iReturn == 0 )
-    {
-        iReturn = pthread_attr_setdetachstate(&attr, (i_bIsDetached) ?
-                    PTHREAD_CREATE_DETACHED :
-                    PTHREAD_CREATE_JOINABLE);
-    }
-    
-#ifdef UNIX
-    if ( iReturn == 0 )
-    {
-        iReturn = pthread_attr_setstacksize(&attr, 1024*1024);
-    }
-#endif
-
-    if ( iReturn == 0 )
-    {
-        iReturn = pthread_create(o_pNewThread, &attr, (void *(*)(void *)) i_pFunc, i_pvData);
-    }
-
-    if ( iReturn == 0 )
-    {
-        iReturn = pthread_attr_destroy(&attr);
-    }
-
-    // TODO: Log error?
-    if ( iReturn )
-    {
-#ifdef SYS_DEBUG
-        printf(" (%s, %d): error creating pthread, error = %d\n",
-                __FILE__, __LINE__, iReturn);
-#endif
-
-        iOK = K_SYS_ERR_CREATE_THREAD;
-    }
-
-    return iOK;
-#endif
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_JoinThread
- *
- * Description:
- *  Thread joining function is called when the current thread
- *  waits another thread to terminate.
- *
- * Input
- * -----
- *    i_hThread        The thread handle of the to-be-joined thread
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        Error code
- *
- *--------------------------------------------------------------------------*/
-
-int  K_JoinThread(K_THREAD_HANDLE i_hThread)
-{
-    int iOK = K_SYS_OK;
-#ifdef WIN32
-
-    WaitForSingleObject(i_hThread, INFINITE);
-
-#else
-    {
-        int iReturn;
-        iReturn = pthread_join(i_hThread, NULL);
-
-        if ( iReturn )
-        {
-
-#ifdef SYS_DEBUG
-            printf(" (%s, %d): error creating pthread, error = %d\n",
-                    __FILE__, __LINE__, iReturn);
-#endif
-            iOK = K_SYS_ERR_JOIN_THREAD;
-        }
-    }
-
-#endif
-    return iOK;
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_GetCurrentThreadId
- *
- * Description:
- *  Returns the thread ID of the current thread.
- *
- * Input
- * -----
- *    (none)
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        The thread ID
- *
- *--------------------------------------------------------------------------*/
-
-int K_GetCurrentThreadId()
-{
-#ifdef WIN32
-    return GetCurrentThreadId();
-#else
-    return pthread_self();
-#endif
-
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_CreateMutex
- *
- * Description:
- *  The mutex creation function creates a mutex according to the given
- *  mutex type, and returns the mutex handle to the output parameter.
- *
- * Input
- * -----
- *    i_bIsRecursive   Indication whether the mutex can be entered recursively
- *
- * Output
- * ------
- *    o_phandle        the handle pointer to the mutex
- *
- * Return value        Error Code
- *
- *--------------------------------------------------------------------------*/
-
-int K_CreateMutex( K_MUTEX_HANDLE *o_phandle )
-{
-    int iOK = K_SYS_OK;
-    BOOL bIsRecursive = 1;  // this used to be an input -- but why do we want this to be optional?
-
-#ifdef WIN32
-    {
-        *o_phandle = (WIN32Mutex *)malloc(sizeof(WIN32Mutex));
-        if(*o_phandle == NULL)
-        {
-            return K_SYS_ERR_NO_MEMORY;
-        }
-        (*o_phandle)->m_bIsRecursive = bIsRecursive;
-        if(bIsRecursive)
-        {
-                InitializeCriticalSection(&((*o_phandle)->m_stCriticalSection));
-        }
-        else
-        {
-            (*o_phandle)->m_handle = CreateMutex(NULL, FALSE, NULL);
-        }
-
-    }
-#else
-    {
-        int iType;
-        pthread_mutexattr_t attr;
-        
-        if ( pthread_mutexattr_init(&attr) )
-        {
-            return K_SYS_ERR_COND;
-        }
-
-        if(bIsRecursive)
-        {
-            iType =
-#ifdef K_LINUX_PLATFORM
-            PTHREAD_MUTEX_RECURSIVE_NP;
-#else
-            PTHREAD_MUTEX_RECURSIVE;
-#endif
-            
-            if ( pthread_mutexattr_settype(&attr, iType) )
-            {
-                return K_SYS_ERR_COND;
-            }
-        }
-        
-        *o_phandle = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
-        if(*o_phandle == NULL)
-        {
-            return K_SYS_ERR_NO_MEMORY;
-        }
-        
-        if ( pthread_mutex_init(*o_phandle, &attr) )
-        {
-            return K_SYS_ERR_COND;
-        }
-
-        if ( pthread_mutexattr_destroy(&attr) )
-        {
-            return K_SYS_ERR_COND;
-        }
-    }
-#endif
-
-    return iOK;
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_LockMutex
- *
- * Description:
- *  K_LockMutex is used to lock the mutex, and K_UnlockMutex is
- *  used to unlock it.
- *
- * Input
- * -----
- *    i_handle        the mutex handle
- *
- * Output
- * ------
- *    (none)
- *
- * Return value       Error Code
- *
- *--------------------------------------------------------------------------*/
-
-int K_LockMutex(K_MUTEX_HANDLE i_handle)
-{
-    int iOK = K_SYS_OK;
-#ifdef WIN32
-    
-    if(i_handle->m_bIsRecursive)
-    {
-        EnterCriticalSection(&(i_handle->m_stCriticalSection));
-    }
-    else
-    {
-        WaitForSingleObject(i_handle->m_handle, INFINITE);
-    }
-
-#else
-
-    if ( pthread_mutex_lock(i_handle) )
-    {
-        return K_SYS_ERR_COND;
-    }
-
-#endif
-    return iOK; // TODO: better error handling
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_UnlockMutex
- *
- * Description:
- *  K_UnlockMutex is used to unlock the lock.
- *
- * Input
- * -----
- *    i_handle        the mutex handle
- *
- * Output
- * ------
- *    (none)
- *
- * Return value       Error Code
- *
- *--------------------------------------------------------------------------*/
-
-int K_UnlockMutex(K_MUTEX_HANDLE i_handle)
-{
-    int iOK = K_SYS_OK;
-
-#ifdef WIN32
-    if(i_handle->m_bIsRecursive)
-    {
-        LeaveCriticalSection(&(i_handle->m_stCriticalSection));
-    }
-    else
-    {
-        ReleaseMutex(i_handle->m_handle);
-    }
-
-#else
-
-    if ( pthread_mutex_unlock(i_handle) )
-    {
-        return K_SYS_ERR_COND;
-    }
-#endif
-
-    return iOK; // TODO: better error handling
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_DestroyMutex
- *
- * Description:
- *  When a mutex is no longer needed, K_DestroyMutex must be called
- *  to destroy it.
- *
- * Input
- * -----
- *    i_handle        the mutex handle
- * Output
- * ------
- *    (none)
- *
- * Return value       Error Code
- *
- *--------------------------------------------------------------------------*/
-
-int K_DestroyMutex(K_MUTEX_HANDLE i_handle)
-{
-
-    int iOK = K_SYS_OK;
-
-#ifdef WIN32
-
-    if(i_handle->m_bIsRecursive)
-    {
-        DeleteCriticalSection(&(i_handle->m_stCriticalSection));
-    }
-    else
-    {
-        CloseHandle(i_handle->m_handle);
-    }
-    free(i_handle);
-
-#else
-    pthread_mutex_destroy(i_handle);
-    free(i_handle);
-#endif
-    return iOK; // TODO: better error handling
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_InitConditionalVariable
- *
- * Description:
- *  This function initializes a conditional variable.  Upon successful
- *  completion, the new condition variable is returned via the condition
- *  parameter, and 0 is returned.  Otherwise, an error code is returned.
- *
- * Input
- * -----
- *    i_pCond         the pointer to the conditional variable which is to be
- *                    initialized
- *
- * Output
- * ------
- *    (none)
- *
- * Return value       Error Code
- *
- *--------------------------------------------------------------------------*/
-
-int K_InitConditionalVariable (K_ConditionalVariable * i_pCond)
-{
-    int iOK = K_SYS_OK;
-#ifdef WIN32
-
-    i_pCond->m_hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
-    i_pCond->m_hMutex = CreateMutex(NULL, FALSE, NULL);
-    i_pCond->m_iSignalAll = 0;
-    i_pCond->m_iNumWaiting = 0;    
-
-#else
-    
-    if ( pthread_cond_init(i_pCond, NULL) )
-    {
-        return K_SYS_ERR_COND;
-    }
-    
-#endif
-
-    return iOK;
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_DestroyConditionalVariable
- *
- * Description:
- *  This function destroys a conditional variable.  Upon successful
- *  completion, the condition variable is destroyed, and 0 is returned.
- *  Otherwise, an error code is returned.
- *  After deletion of the condition variable, the condition parameter
- *  is not valid until it is initialized again by a call to the
- *  K_InitConditionalVariable subroutine.
- *
- * Input
- * -----
- *    i_pCond        the pointer to the conditional variable which is to be
- *                   destroyed
- * Output
- * ------
- *    (none)
- *
- * Return value      Error Code
- *
- *--------------------------------------------------------------------------*/
-
-int K_DestroyConditionalVariable(K_ConditionalVariable * i_pCond)
-{
-    int iOK = K_SYS_OK;
-#ifdef WIN32
-    CloseHandle(i_pCond->m_hMutex);
-    CloseHandle(i_pCond->m_hEvent);
-#else
-    
-    if ( pthread_cond_destroy(i_pCond) )
-    {
-        return K_SYS_ERR_COND;
-    }
-
-#endif
-    return iOK;
-
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_WaitConditionalVariable
- *
- * Description:
- *  This function is used to block on a condition variable.
- *  They are called with mutex locked by the calling thread or undefined
- *  behaviour will result.
- *
- * Input
- * -----
- *    i_pCond        the pointer to the conditional variable
- *    i_handle       the companion mutex handle
- *
- * Output
- * ------
- *    (none)
- *
- * Return value      Error Code
- *
- *--------------------------------------------------------------------------*/
-
-int  K_WaitConditionalVariable(K_ConditionalVariable * i_pCond,
-                               K_MUTEX_HANDLE i_handle)
-{
-
-    int iOK = K_SYS_OK;
-#ifdef WIN32
-    DWORD res;
-
-    while (1) 
-    {
-        iOK = WaitForSingleObject(i_pCond->m_hMutex, INFINITE);
-        if (iOK != WAIT_OBJECT_0) 
-        {
-            return K_SYS_ERR_COND;
-        }
-        i_pCond->m_iNumWaiting++;
-        ReleaseMutex(i_pCond->m_hMutex);
-
-        K_UnlockMutex(i_handle);
-        res = WaitForSingleObject(i_pCond->m_hEvent, INFINITE);
-        i_pCond->m_iNumWaiting--;
-        
-        if (res != WAIT_OBJECT_0) 
-        {
-            ReleaseMutex(i_pCond->m_hMutex);
-            return K_SYS_ERR_COND;
-        }
-        
-        if (i_pCond->m_iSignalAll) 
-        {
-            if (i_pCond->m_iNumWaiting == 0) 
-            {
-                ResetEvent(i_pCond->m_hEvent);
-            }
-            break;
-        }
-        
-        if (i_pCond->m_iSignalled) 
-        {
-            i_pCond->m_iSignalled = 0;
-            ResetEvent(i_pCond->m_hEvent);
-            break;
-        }
-        ReleaseMutex(i_pCond->m_hMutex);
-    }
-
-    K_LockMutex(i_handle);
-
-    return K_SYS_OK;
-#else
-    
-    if ( pthread_cond_wait(i_pCond, i_handle) )
-    {
-        return K_SYS_ERR_COND;
-    }
-
-#endif
-    return iOK; // TODO: better error handling
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_SignalConditionalVariable
- *
- * Description:
- *  This function is used to restart one of the threads that are waiting on
- *  the condition variable.  If no threads are waiting on it, nothing happens.
- *  If several threads are waiting on it, exactly one is restarted.
- *
- * Input
- * -----
- *    i_pCond        the pointer to the conditional variable
- *
- * Output
- * ------
- *    (none)
- *
- * Return value      Error Code
- *
- *--------------------------------------------------------------------------*/
-
-int K_SignalConditionalVariable(K_ConditionalVariable * i_pCond)
-{
-    int iOK = K_SYS_OK;
-#ifdef WIN32
-
-    int iReturn;
-
-    iReturn = WaitForSingleObject(i_pCond->m_hMutex, INFINITE);
-    if (iReturn != WAIT_OBJECT_0) 
-    {
-        return K_SYS_ERR_COND;
-    }
-
-    i_pCond->m_iSignalled = 1;
-
-    iReturn = SetEvent(i_pCond->m_hEvent);
-    if (iReturn == 0) 
-    {
-        iOK = K_SYS_ERR_COND;
-    }
-    ReleaseMutex(i_pCond->m_hMutex);
-
-    return iOK;
-#else
-    
-    if ( pthread_cond_signal(i_pCond) )
-    {
-        return K_SYS_ERR_COND;
-    }
-
-#endif
-    return iOK; 
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_BroadcastConditionalVariable
- *
- * Description:
- *  This function is used to restart all threads that are waiting on
- *  the condition variable.
- *
- * Input
- * -----
- *    i_pCond        the pointer to the conditional variable
- *
- * Output
- * ------
- *    (none)
- *
- * Return value      Error Code
- *
- *--------------------------------------------------------------------------*/
-
-int K_BroadcastConditionalVariable(K_ConditionalVariable * i_pCond)
-{
-
-    int iOK = K_SYS_OK;
-
-#ifdef WIN32
-
-    int iReturn;
-
-    iReturn = WaitForSingleObject(i_pCond->m_hMutex, INFINITE);
-    if (iReturn != WAIT_OBJECT_0) 
-    {
-        return K_SYS_ERR_COND;
-    }
-    i_pCond->m_iSignalled = 1;
-    i_pCond->m_iSignalAll = 1;
-
-    iReturn = SetEvent(i_pCond->m_hEvent);
-
-    if (iReturn == 0) 
-    {
-        iOK = K_SYS_ERR_COND;
-    }
-
-    ReleaseMutex(i_pCond->m_hMutex);
-
-    return iOK;
-
-#else
-    
-    if ( pthread_cond_broadcast(i_pCond) )
-    {
-        return K_SYS_ERR_COND;
-    }
-
-#endif
-    return iOK; 
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_Sleep
- *
- * Description:
- *  Sleep for a given period in given milliseconds.
- *
- * Input
- * -----
- *    i_ms        milliseconds
- *
- * Output
- * ------
- *    (none)
- *
- * Return value   (none)
- *
- *--------------------------------------------------------------------------*/
-
-void K_Sleep(int i_ms)
-{
-#ifdef WIN32
-    Sleep(i_ms);
-#else
-    usleep(i_ms * 1000);
-#endif
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_GetTickCount
- *
- * Description:
- *  The K_GetTickCount function retrieves the number of
- *  milliseconds that have elapsed since the system was started.
- *
- * Input
- * -----
- *    (none)
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        the elasped milliseconds since the system was started
- *
- *--------------------------------------------------------------------------*/
-
-unsigned int K_GetTickCount()
-{
-#ifdef WIN32
-    return (unsigned int)GetTickCount();
-#else
-    {
-        struct timeval tv;
-        gettimeofday( &tv, NULL );
-        /* this will rollover ~ every 49.7 days
-           dont surprise when it returns negative values, since we are only interested
-          in using  sth like "tickCount2 - tickCount1" to get the time interval
-        */
-        return ( tv.tv_sec * 1000 ) + ( tv.tv_usec / 1000 );
-    }
-#endif
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_AdjustClock
- *
- * Description:
- *  The K_AdjustClock function immediately adjusts the system clock by
- *  the given number of seconds.  A positive number adjusts the system
- *  clock forward; a negative number adjusts the system clock backward.
- *
- * Input
- * -----
- *    i_iAdjustmentInSeconds   Number of seconds by which to adjust the
- *                             system clock
- * Output
- * ------
- *    (none)
- *
- * Return value        1 if successful, 0 on error
- *
- *--------------------------------------------------------------------------*/
-
-int K_AdjustClock( long i_iAdjustmentInSeconds )
-{
-#ifndef WIN32
-    struct timeval stDateTime;
-    if ( 0 != gettimeofday(&stDateTime, NULL) )
-    {
-        return FALSE;
-    }
-
-    stDateTime.tv_sec += i_iAdjustmentInSeconds;
-
-    if ( 0 != settimeofday(&stDateTime, NULL) )
-    {
-        return FALSE;
-    }
-#else
-    // TODO: implement for Windows
-    return FALSE;
-#endif
-
-    return TRUE;
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_IsLittleEndian
- *
- * Description:
- *  Checks to see whether this platform uses little endian integer
- *  representation.
- *
- * Input
- * -----
- *    (none)
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        1 for little endian
- *
- *--------------------------------------------------------------------------*/
-
-int K_IsLittleEndian()
-{
-    short iWord = 0x4321;
-    return ((*(unsigned char*)&iWord) == 0x21);
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_FileLength32
- *
- * Description:
- *  Gets the size in bytes of the file associated with the given FILE pointer.
- *
- * Input
- * -----
- *    i_fpFile         File handle
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        File size in bytes, or -1L on error
- *
- *--------------------------------------------------------------------------*/
-
-long K_FileLength32( FILE* i_fpFile )
-{
-#ifdef WIN32
-    int iFileDescriptor = _fileno( i_fpFile );
-    struct _stat stStat;
-    
-    if ( _fstat(iFileDescriptor, &stStat) != 0)
-    {
-        // error
-        return -1L;
-    }
-
-#else
-    int iFileDescriptor = fileno( i_fpFile );
-    struct stat stStat;
-    
-    if ( fstat(iFileDescriptor, &stStat) != 0)
-    {
-        // error
-        return -1L;
-    }
-
-#endif
-
-    return stStat.st_size;
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_StringCompareNoCase
- *
- * Description:
- *  Compares the two given strings insensitive to case.
- *
- * Input
- * -----
- *    i_sString1       First string
- *    i_sString2       Second string
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        0 if identical, -1 if first string is less than second
- *                     string, or 1 if first string is greater than second
- *
- *--------------------------------------------------------------------------*/
-
-int K_StringCompareNoCase( const char* i_sString1, const char* i_sString2 )
-{
-#ifdef WIN32
-    return _stricmp( i_sString1, i_sString2 );
-#else
-    return strcasecmp( i_sString1, i_sString2 );
-#endif
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_StringCompareNoCaseWide
- *
- * Description:
- *  Compares the two given wide strings insensitive to case.
- *
- * Input
- * -----
- *    i_wsString1      First wide string
- *    i_wsString2      Second wide string
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        0 if identical, -1 if first string is less than second
- *                     string, or 1 if first string is greater than second
- *
- *--------------------------------------------------------------------------*/
-
-int K_StringCompareNoCaseWide( const wchar_t* i_wsString1, const wchar_t* i_wsString2 )
-{
-#ifdef WIN32
-    return _wcsicmp( i_wsString1, i_wsString2 );
-#elif defined K_SOLARIS_PLATFORM
-    return wscasecmp( i_wsString1, i_wsString2 );
-#else
-    return wcscasecmp( i_wsString1, i_wsString2 );
-#endif
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_CreateDirectory
- *
- * Description:
- *  Creates a directory with the given path name.
- *
- * Input
- * -----
- *    i_sDirectoryName  Directory name
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        0 on success, -1 on failure
- *
- *--------------------------------------------------------------------------*/
-
-int K_CreateDirectory( const char* i_sDirectoryName )
-{
-    // TODO: make this build all parent directories as well.
-
-#ifdef WIN32
-    if ( CreateDirectoryA( i_sDirectoryName, NULL ) )
-    {
-        return 0;
-    }
-    else
-    {
-        DWORD dwError = GetLastError();
-        return ( dwError == ERROR_ALREADY_EXISTS ) ? 0 : (dwError ? dwError : -1);
-    }
-#else
-    if ( mkdir( i_sDirectoryName, S_IRWXU ) == 0 )
-    {
-        return 0;
-    }
-    else
-    {
-        return ( errno == EEXIST ) ? 0 : (errno ? errno : -1);
-    }
-#endif
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_DeleteFile
- *
- * Description:
- *  Deletes the given file.
- *
- * Input
- * -----
- *    i_sFilename      Name of file to delete
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        0 on success, errno on failure
- *
- *--------------------------------------------------------------------------*/
-
-int K_DeleteFile( const char* i_sFilename )
-{
-    int bSuccess = 0;
-
-    bSuccess = 
-#ifdef WIN32
-        _unlink( 
-#else
-        unlink( 
-#endif
-            i_sFilename ) == 0;
-
-    return bSuccess ? 0 : errno;
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_ReadFile
- *
- * Description:
- *  Reads from the given file and passes the bytes read back to the output
- *  parameter.  The caller must deallocate o_ppFileData using free().
- *
- * Input
- * -----
- *    i_sFilename      Name of file from which to read
- *
- * Output
- * ------
- *    o_ppFileData     Pointer to bytes read
- *
- * Return value        Number of bytes read on success, -1 on failure
- *
- *--------------------------------------------------------------------------*/
-
-int K_ReadFile( const char* i_sFilename, unsigned char** o_ppFileData )
-{
-    FILE* pFile = 0;
-    long iFileSize = 0;
-
-    if ( !i_sFilename || (strlen(i_sFilename) <= 0) || !o_ppFileData )
-    {
-        return -1;
-    }
-
-    *o_ppFileData = 0;
-
-    // Open the file
-
-    pFile = fopen( i_sFilename, "rb" );
-    if ( !pFile )
-    {
-        return -1;
-    }
-
-    // Determine the file size
-
-    if ( fseek( pFile, 0, SEEK_END ) )
-    {
-        (void) fclose( pFile );
-        return -1;
-    }
-
-    iFileSize = ftell( pFile );
-    if ( iFileSize < 0 )
-    {
-        (void) fclose( pFile );
-        return -1;
-    }
-    else if ( iFileSize == 0 )
-    {
-        (void) fclose( pFile );
-        return 0;
-    }
-
-    if ( fseek( pFile, 0, SEEK_SET ) )
-    {
-        (void) fclose( pFile );
-        return -1;
-    }
-
-    *o_ppFileData = (unsigned char*)malloc( iFileSize );
-    if ( !*o_ppFileData )
-    {
-        // Out of memory.
-        (void) fclose( pFile );
-        return -1;
-    }
-
-    if ( iFileSize != (long)fread( *o_ppFileData, 1, iFileSize, pFile ) )
-    {
-        free( *o_ppFileData );
-        *o_ppFileData = 0;
-        (void) fclose( pFile );
-        return -1;
-    }
-
-    (void) fclose( pFile );
-
-    return iFileSize;
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_ReadFileString
- *
- * Description:
- *  Reads from the given file and passes the bytes read back to the output
- *  parameter, appending these bytes with a null terminator.  There is no
- *  guarantee that there are no non-text characters in the returned "string".
- *  The caller must deallocate o_ppFileData using free().
- *
- * Input
- * -----
- *    i_sFilename      Name of file from which to read
- *
- * Output
- * ------
- *    o_psFileDataString     Pointer to bytes read
- *
- * Return value        Number of bytes read (including null terminator) on
- *                     success (0 if file is empty), -1 on failure
- *
- *--------------------------------------------------------------------------*/
-
-int K_ReadFileString( const char* i_sFilename, char** o_psFileDataString )
-{
-    unsigned char* pFileData = 0;
-    int iFileSize = 0;
-
-    *o_psFileDataString = 0;
-
-    iFileSize = K_ReadFile( i_sFilename, &pFileData );
-
-    if ( iFileSize <= 0 )
-    {
-        return iFileSize;
-    }    
-
-    *o_psFileDataString = (char*)malloc( iFileSize+1 );
-
-    if ( !*o_psFileDataString )
-    {
-        // Out of memory.
-        if ( pFileData )
-        {
-            free( pFileData );
-        }
-        return -1;
-    }
-
-    memcpy( *o_psFileDataString, pFileData, iFileSize );
-
-    (*o_psFileDataString)[iFileSize] = '\0';
-
-    if ( pFileData )
-    {
-        free( pFileData );
-    }
-
-    return iFileSize+1;
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_WriteFile
- *
- * Description:
- *  Writes the given bytes to the given file.
- *
- * Input
- * -----
- *    i_sFilename      Name of file to which to write
- *    i_pFileData      Bytes to write
- *    i_iFileDataSize  Number of bytes to write
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        0 on success, errno or -1 (generic error) on failure
- *
- *--------------------------------------------------------------------------*/
-
-int K_WriteFile( const char* i_sFilename, const unsigned char* i_pFileData, int i_iFileDataSize )
-{
-    FILE* pFile = 0;
-
-    if ( !i_sFilename || (strlen(i_sFilename) <= 0) || (!i_pFileData && (i_iFileDataSize > 0)) || (i_iFileDataSize < 0) )
-    {
-        return -1;
-    }
-
-    pFile = fopen( i_sFilename, "wb" );
-    if ( !pFile )
-    {
-        int iError = errno;
-        return (iError != 0) ? iError : -1;
-    }
-
-    if ( i_iFileDataSize > 0 )
-    {
-        if ( i_iFileDataSize != (int)fwrite( i_pFileData, 1, i_iFileDataSize, pFile ) )
-        {
-            int iError = ferror( pFile );
-            (void) fclose( pFile );
-            return (iError != 0) ? iError : -1;
-        }
-    }
-
-    (void) fclose( pFile );
-
-    return 0;
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_WriteFileString
- *
- * Description:
- *  Writes the given null-terminated bytes to the given file.  The null
- *  terminator itself is not written to the file.
- *
- * Input
- * -----
- *    i_sFilename      Name of file to which to write
- *    i_sFileData      Bytes to write
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        0 on success, errno or -1 (generic error) on failure
- *
- *--------------------------------------------------------------------------*/
-
-int K_WriteFileString( const char* i_sFilename, const char* i_sFileData )
-{
-    if ( !i_sFilename || (strlen(i_sFilename) <= 0) || !i_sFileData || (strlen(i_sFileData) <= 0) )
-    {
-        return -1;
-    }
-
-    return K_WriteFile( i_sFilename, (const unsigned char*)i_sFileData, strlen(i_sFileData) );
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_FileExists
- *
- * Description:
- *  Checks to see whehter the given file exists.
- *
- * Input
- * -----
- *    i_sFilename      Name of file to check
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        1 if file exists, 0 if not, -1 on failure
- *
- *--------------------------------------------------------------------------*/
-
-int K_FileExists( const char* i_sFilename )
-{
-    FILE* pFile = 0;
-
-    if ( !i_sFilename || (strlen(i_sFilename) <= 0) )
-    {
-        return -1;
-    }
-
-    pFile = fopen( i_sFilename, "r+" );
-
-    if ( !pFile )
-    {
-        if ( errno == ENOENT )
-        {
-            return 0;
-        }
-
-        return -1;
-    }
-
-    (void) fclose( pFile );
-
-    return 1;
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_CopyFile
- *
- * Description:
- *  Reads from the given source file and writes these bytes to the given
- *  destination file.
- *
- * Input
- * -----
- *    i_sSrcFilename   Name of file from which to read
- *    i_sDestFilename  Name of file to which to write
- *
- * Output
- * ------
- *    o_pbFileExists   Non-zero if the destination file already exists
- *
- * Return value        0 on success, errno or -1 (generic error) on failure
- *
- *--------------------------------------------------------------------------*/
-
-int K_CopyFile( const char* i_sSrcFilename, const char* i_sDestFilename, int* o_pbFileExists )
-{
-    unsigned char* pFileData = 0;
-    int iFileSize = 0;
-    int iError, iFileExists;
-
-    if ( !i_sSrcFilename || (strlen(i_sSrcFilename) <= 0) 
-         || !i_sDestFilename || (strlen(i_sDestFilename) <= 0) 
-         || !o_pbFileExists )
-    {
-        return -1;
-    }
-
-    *o_pbFileExists = 0;
-
-    iFileExists = K_FileExists( i_sDestFilename );
-
-    if ( iFileExists < 0 )
-    {
-        iError = errno;
-        return (iError == 0) ? -1 : iError;
-    }
-    else if ( iFileExists > 0 )
-    {
-        *o_pbFileExists = 1;
-        return -1;
-    }
-
-    iFileSize = K_ReadFile( i_sSrcFilename, &pFileData );
-    if ( iFileSize < 0 )
-    {
-        iError = errno;
-        return (iError == 0) ? -1 : iError;
-    }
-
-    iError = K_WriteFile( i_sDestFilename, pFileData, iFileSize );
-
-    if ( pFileData )
-    {
-        free( pFileData );
-    }
-
-    return iError;
-}
-
-
-#ifdef K_LINUX_PLATFORM
-static int fts_compare( const FTSENT** i_ppF1, const FTSENT** i_ppF2 )
-{
-    return strcmp( (*i_ppF1)->fts_name, (*i_ppF2)->fts_name );
-}
-#else
-/*
- * Directory traversal code is not yet available for Solaris.
- * If such code will need to be written, then it will probably use ftw.h.
- */
-#endif
-
-
-/*
- *  TODO:  Set up functions for platform-specific find-file operations to
- *  help clean up the code below.
- */
-
-typedef struct K_FindInfo
-{
-#ifdef WIN32
-    struct _finddata_t m_stFindData;
-    long m_hFile;
-#elif defined K_LINUX_PLATFORM
-    FTS* m_pFTS;
-    FTSENT* m_pFTSENT;
-#else
-/*
- * Directory traversal code is not yet available for Solaris.
- * If such code will need to be written, then it will probably use ftw.h.
- */
-    int unused;
-#endif
-} K_FindInfo;
-
-// Memory for filename is held in i_pFindInfo.
-const char* K_GetFilenameFromInfo( const K_FindInfo* i_pFindInfo )
-{
-    if( !i_pFindInfo )
-    {
-        return 0;
-    }
-
-#ifdef WIN32
-    return i_pFindInfo->m_stFindData.name;
-#elif defined K_LINUX_PLATFORM
-    return i_pFindInfo->m_pFTSENT->fts_name;
-#else
-/*
- * Directory traversal code is not yet available for Solaris.
- * If such code will need to be written, then it will probably use ftw.h.
- */
-    FATAL_ASSERT( 0 );
-    return 0;
-#endif
-}
-
-// Forward declarations
-int K_FindFileNext( K_FindInfo* io_pFindInfo );
-void K_FindFileClose( K_FindInfo* io_pFindInfo );
-
-// Returns 0 if successful, 1 if not found, -1 if error.
-// If not error, K_FindFileClose must be called.
-// o_pFindInfo must not be null.
-int K_FindFileFirst( const char* i_sDirectoryName, K_FindInfo* o_pFindInfo )
-{
-#ifdef WIN32
-    char* sSearchString = 0;
-    int iSearchStringIndex = 0;
-#endif
-
-    if ( !i_sDirectoryName || (strlen(i_sDirectoryName) <= 0) || !o_pFindInfo )
-    {
-        return -1;
-    }
-
-#ifdef WIN32
-    memset( o_pFindInfo, 0, sizeof(K_FindInfo) );
-
-    iSearchStringIndex = strlen(i_sDirectoryName);
-    if ( i_sDirectoryName[iSearchStringIndex-1] == PATH_SEPARATOR )
-    {
-        iSearchStringIndex += 2;
-    }
-    else
-    {
-        iSearchStringIndex += 3;
-    }
-
-    sSearchString = (char*)calloc( iSearchStringIndex, 1 );
-    if ( !sSearchString )
-    {
-        return -1;
-    }
-
-    strcpy( sSearchString, i_sDirectoryName );
-    iSearchStringIndex--;
-    sSearchString[iSearchStringIndex] = '\0';
-    iSearchStringIndex--;
-    sSearchString[iSearchStringIndex] = '*';
-    iSearchStringIndex--;
-    sSearchString[iSearchStringIndex] = PATH_SEPARATOR;
-
-    o_pFindInfo->m_hFile = _findfirst( sSearchString, &o_pFindInfo->m_stFindData );
-    free( sSearchString );
-    if ( o_pFindInfo->m_hFile == -1 )
-    {
-        if ( errno == ENOENT )
-        {
-            return 1;
-        }
-        else
-        {
-            return -1;
-        }
-    }
-#elif defined K_LINUX_PLATFORM
-    memset( o_pFindInfo, 0, sizeof(K_FindInfo) );
-
-    o_pFindInfo->m_pFTS = fts_open( aPath, FTS_PHYSICAL | FTS_NOSTAT, fts_compare );
-    if ( !o_pFindInfo->m_pFTS )
-    {
-        return -1;
-    }
-
-    o_pFindInfo->m_pFTSENT = fts_read( o_pFindInfo->m_pFTS );
-    if ( !o_pFindInfo->m_pFTSENT )
-    {
-        if ( errno == 0 )
-        {
-            return 1;
-        }
-        else
-        {
-            fts_close( o_pFindInfo->m_pFTS );
-            return -1;
-        }
-    }
-#else
-/*
- * Directory traversal code is not yet available for Solaris.
- * If such code will need to be written, then it will probably use ftw.h.
- */
-#endif
-
-    // If what we found is not actually a file, get the next hit.
-#ifdef WIN32
-    if ( (o_pFindInfo->m_stFindData.attrib & _A_SUBDIR) )
-#elif defined K_LINUX_PLATFORM
-    if ( !(o_pFindInfo->m_pFTSENT->fts_info & FTS_F) )
-#else
-/*
- * Directory traversal code is not yet available for Solaris.
- * If such code will need to be written, then it will probably use ftw.h.
- */
-#endif
-    {
-        int iNextReturn = K_FindFileNext( o_pFindInfo );
-        if ( iNextReturn < 0 )
-        {
-            K_FindFileClose( o_pFindInfo );
-            return -1;
-        }
-        else
-        {
-            return iNextReturn;
-        }
-    }
-
-#if defined(WIN32) || defined(K_LINUX_PLATFORM)
-    return 0;
-#endif
-}
-
-// Returns 0 if successful, 1 if not found, -1 if error.
-int K_FindFileNext( K_FindInfo* io_pFindInfo )
-{
-    if ( !io_pFindInfo )
-    {
-        return -1;
-    }
-
-#ifdef WIN32
-    if ( _findnext( io_pFindInfo->m_hFile, &io_pFindInfo->m_stFindData ) != 0 )
-    {
-        return (errno == ENOENT) ? 1 : -1;
-    }
-#elif defined K_LINUX_PLATFORM
-    io_pFindInfo->m_pFTSENT = fts_read( io_pFindInfo->m_pFTS );
-    if ( !io_pFindInfo->m_pFTSENT )
-    {
-        return (errno == 0) ? 1 : -1;
-    }
-#else
-/*
- * Directory traversal code is not yet available for Solaris.
- * If such code will need to be written, then it will probably use ftw.h.
- */
-#endif
-
-    // If what we found is not actually a file, get the next hit.
-#ifdef WIN32
-    if ( (io_pFindInfo->m_stFindData.attrib & _A_SUBDIR) )
-#elif defined K_LINUX_PLATFORM
-    if ( !(io_pFindInfo->m_pFTSENT->fts_info & FTS_F) )
-#else
-/*
- * Directory traversal code is not yet available for Solaris.
- * If such code will need to be written, then it will probably use ftw.h.
- */
-#endif
-    {
-        return K_FindFileNext( io_pFindInfo );
-    }
-
-#if defined(WIN32) || defined(K_LINUX_PLATFORM)
-    return 0;
-#endif
-}
-
-void K_FindFileClose( K_FindInfo* io_pFindInfo )
-{
-    if ( !io_pFindInfo )
-    {
-        return;
-    }
-
-#ifdef WIN32
-    _findclose( io_pFindInfo->m_hFile );
-#elif defined K_LINUX_PLATFORM
-    fts_close( io_pFindInfo->m_pFTS );
-#else
-/*
- * Directory traversal code is not yet available for Solaris.
- * If such code will need to be written, then it will probably use ftw.h.
- */
-#endif
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_GetFilenamesInDirectoryCount
- *
- * Description:
- *  Reads the given directory and returns the number of files that it contains.
- *
- * Input
- * -----
- *    i_sDirectoryName  Name of directory
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        Number of files on success, -1 on failure
- *
- *--------------------------------------------------------------------------*/
-
-int K_GetFilenamesInDirectoryCount( const char* i_sDirectoryName )
-{
-    K_FindInfo stFindInfo;
-    int iCurrentFile = 0;
-    int iError = 0;
-
-    if ( !i_sDirectoryName || (strlen(i_sDirectoryName) <= 0) )
-    {
-        return -1;
-    }
-
-    iError = K_FindFileFirst( i_sDirectoryName, &stFindInfo );
-    if ( iError < 0 )
-    {
-        // error
-        return -1;
-    }
-    else if ( iError > 0 )
-    {
-        // no files found
-        K_FindFileClose( &stFindInfo );
-        return 0;
-    }
-
-    while ( 1 )
-    {
-        iCurrentFile++;
-
-        iError = K_FindFileNext( &stFindInfo );
-        if ( iError < 0 )
-        {
-            // error
-            K_FindFileClose( &stFindInfo );
-            return -1;
-        }
-        else if ( iError > 0 )
-        {
-            // no more files found
-            break;
-        }
-    }
-
-    K_FindFileClose( &stFindInfo );
-
-    return iCurrentFile;
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_GetFilenamesInDirectory
- *
- * Description:
- *  Reads the given directory and returns an array of names of files that it
- *  contains.  A null pointer appears at the last item in the array.  The
- *  caller must deallocate o_pasFilenames by using K_FreeFilenames or by
- *  calling free() for each file name and then calling free() on the array
- *  itself.
- *
- * Input
- * -----
- *    i_sDirectoryName  Name of directory
- *
- * Output
- * ------
- *    o_pasFilenames   Array of names of files found in this directory
- *
- * Return value        Number of files on success, -1 on failure
- *
- *--------------------------------------------------------------------------*/
-
-int K_GetFilenamesInDirectory( 
-        const char* i_sDirectoryName,
-        char*** o_pasFilenames )
-{
-    // Note that we iterate through the filenames twice -- once to get the count
-    // (K_GetFilenamesInDirectoryCount) and then once to get all the names. But 
-    // it may happen that the count changes between these calls.  So we'll retrieve
-    // at most the number of files that's returned in the first pass.
-
-    K_FindInfo stFindInfo;
-    int iFilenameCount = 0, iCurrentFile = 0;
-    int iError = 0;
-
-    if ( !i_sDirectoryName || (strlen(i_sDirectoryName) <= 0) || !o_pasFilenames )
-    {
-        return -1;
-    }
-
-    *o_pasFilenames = 0;
-
-    iFilenameCount = K_GetFilenamesInDirectoryCount( i_sDirectoryName );
-
-    if ( iFilenameCount < 0 )
-    {
-        return -1;
-    }
-
-    iError = K_FindFileFirst( i_sDirectoryName, &stFindInfo );
-    if ( iError < 0 )
-    {
-        // error
-        return -1;
-    }
-    else if ( iError > 0 )
-    {
-        // No files found
-        K_FindFileClose( &stFindInfo );
-        return 0;
-    }
-
-    *o_pasFilenames = (char**)calloc( (iFilenameCount+1), sizeof(char*) );    // +1 for the null last one
-    if ( !*o_pasFilenames )
-    {
-        // Out of memory
-        K_FindFileClose( &stFindInfo );
-        return -1;
-    }
-
-    while ( 1 )
-    {
-        const char* sFilename = K_GetFilenameFromInfo( &stFindInfo );
-
-        size_t iFilenameLength = sFilename ? strlen( sFilename ) : 0;
-
-        if ( iFilenameLength <= 0 )
-        {
-            K_FreeFilenames( *o_pasFilenames );
-            K_FindFileClose( &stFindInfo );
-            return -1;
-        }
-
-        (*o_pasFilenames)[iCurrentFile] = (char*)calloc( (iFilenameLength+1), sizeof(char) );
-        if ( !(*o_pasFilenames)[iCurrentFile] )
-        {
-            K_FreeFilenames( *o_pasFilenames );
-            K_FindFileClose( &stFindInfo );
-            return -1;
-        }
-
-        strncpy( (*o_pasFilenames)[iCurrentFile], sFilename, iFilenameLength );
-        (*o_pasFilenames)[iCurrentFile][iFilenameLength] = '\0';
-
-        iCurrentFile++;
-
-        if ( iCurrentFile >= iFilenameCount )
-        {
-            break;
-        }
-
-        iError = K_FindFileNext( &stFindInfo );
-        if ( iError < 0 )
-        {
-            // error
-            K_FindFileClose( &stFindInfo );
-            return -1;
-        }
-        else if ( iError > 0 )
-        {
-            // no more files found
-            break;
-        }
-    }
-
-    K_FindFileClose( &stFindInfo );
-
-    return iCurrentFile;
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_FreeFilenames
- *
- * Description:
- *  Deallocates the memory allocated in a successful call to
- *  K_GetFilenamesInDirectory.
- *
- * Input
- * -----
- *    i_asFilenames    Array of names of files
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        (none)
- *
- *--------------------------------------------------------------------------*/
-
-void K_FreeFilenames( char** i_asFilenames )
-{
-    int i;
-
-    if ( !i_asFilenames )
-    {
-        return;
-    }
-
-    for ( i = 0; (i_asFilenames[i] != 0); i++ )
-    {
-        free( i_asFilenames[i] );
-        i_asFilenames[i] = 0;
-    }
-
-    free( i_asFilenames );
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_AdjustLocalClock
- *
- * Description:
- *  The K_AdjustLocalClock function gradually adjusts the system clock by
- *  the given number of seconds.  A positive number adjusts the system
- *  clock forward; a negative number adjusts the system clock backward.
- *
- * Input
- * -----
- *    i_iAdjustmentInSeconds   Number of seconds by which to adjust the
- *                             system clock
- * Output
- * ------
- *    (none)
- *
- * Return value        1 if successful, 0 on error
- *
- *--------------------------------------------------------------------------*/
-
-int K_AdjustLocalClock( int i_iNumberOfSeconds )
-{
-    struct timeval delta, lastchange;
-
-#ifndef K_SOLARIS_PLATFORM
-    /* Only supported/tested on Solaris at the moment */
-
-    return -1;
-#else
-    /* WARNING: uses standard C time functions with Year 2038 limitations */
-    time_t now;
-
-    if ( (now = time(NULL)) == ((time_t)-1) )
-    {
-        return -1;
-    }
-
-    delta.tv_sec = i_iNumberOfSeconds;
-    delta.tv_usec = 0;
-
-    return adjtime(&delta, &lastchange);
-#endif
-}
-
-
-#ifdef K_SOLARIS_PLATFORM
-static int pam_tty_conv(
-    int num_msg,
-    struct pam_message** mess,
-    struct pam_response** resp,
-    void* my_data)
-{
-    // Following code implements a console-based PAM "conversation" function
-    // (based sample code from Solaris 10 Software Developer Collection >>
-    // Solaris Security for Developers Guide >>
-    // 3.  Writing PAM Applications and Services)
-
-    struct pam_message* m = *mess;
-    struct pam_response* r;
-    int i, j;
-    const char* sPassword = (const char*)my_data;
-    int error = PAM_CONV_ERR;
-
-    if (num_msg <= 0 || num_msg >= PAM_MAX_NUM_MSG)
-    {
-        (void) fprintf(stderr, "PAM error: bad number of messages");
-        *resp = NULL;
-        return (PAM_CONV_ERR);
-    }
-
-    if ((*resp = r = calloc(num_msg, sizeof (struct pam_response))) == NULL)
-    {
-        return (PAM_BUF_ERR);
-    }
-
-    // Loop through messages
-    for (i = 0; i < num_msg; i++) {
-
-        // bad message from service module
-        if (m->msg == NULL)
-        {
-            (void) fprintf(stderr, "PAM error: bad message");
-            goto err;
-        }
-
-        // fix up final newline: removed for prompts, added back for messages
-        if (m->msg[strlen(m->msg)] == '\n')
-        {
-            m->msg[strlen(m->msg)] = '\0';
-        }
-
-        // Since the KMA has its own password prompts and enforces its own rule checks, we already have the
-        // new password in memory.  So instead of displaying PAM prompts and collecting user responses, we
-        // "automate" by assuming that the prompts correspond to the standard sequence of "New password:"
-        // followed by "Confirm password:" and so in each case we immediately return the password we already
-        // have in memory.  This violates the PAM "conversation" function instructions (which say, basically,
-        // not to assume any particular sequence of prompts since there could be any number of underlying
-        // password managers), but since the KMA is running on an appliance with a fixed password manager,
-        // our assumptions should hold.
-
-        r->resp = NULL;
-        r->resp_retcode = 0;
-        switch (m->msg_style)
-        {
-        case PAM_PROMPT_ECHO_OFF:
-        case PAM_PROMPT_ECHO_ON:
-            // Assume the prompt asked for New/Confirm password, so return password.
-            if ( (r->resp = strdup(sPassword)) == NULL )
-            {
-                error = PAM_BUF_ERR;
-                goto err;
-            }
-            break;
-
-        case PAM_ERROR_MSG:
-            // Assuming the system is configured properly and the KMA password prompts enforce password strength rules,
-            // there should not be errors because of weak passwords, etc.  Still, print errors so users/support can
-            // diagnose problems.
-            (void) fputs(m->msg, stderr);
-            (void) fputc('\n', stderr);
-            break;
-
-        case PAM_TEXT_INFO:
-            // Supress prompts (again, making assumptions).
-            break;
-
-        default:
-            (void) fprintf(stderr, "PAM error: unknown message");
-            goto err;
-        }
-        if (errno == EINTR)
-        {
-            goto err;
-        }
-
-        // next message/response
-        m++;
-        r++;
-    }
-    return (PAM_SUCCESS);
-
-err:
-    // Service modules do not clean up responses if an error is returned.
-    // Free responses here.
-    for (j = 0; j < i; j++, r++)
-    {
-        if (r->resp)
-        {
-            // clear before freeing -- may be a password
-            bzero(r->resp, strlen(r->resp));
-            free(r->resp);
-            r->resp = NULL;
-        }
-    }
-    free(r);
-    *resp = NULL;
-    return error;
-}
-#endif
-
-
-/*---------------------------------------------------------------------------
- * Function: K_SetRootPassword
- *
- * Description:
- *  The K_SetRootPassword function sets the password for the root user via
- *  Pluggable Authentication Module (PAM).  This function is interactive.
- *
- * Input
- * -----
- *    i_sPassword      Password to set
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        0 if successful, -1 on error
- *
- *--------------------------------------------------------------------------*/
-
-int K_SetRootPassword( const char* i_sPassword )
-{
-    // Only supported/tested on Solaris at the moment
-#ifndef K_SOLARIS_PLATFORM
-    return -1;
-#else
-    // Based on sample code from Solaris 10 Software Developer Collection >>
-    // Solaris Security for Developers Guide >>
-    // 3. Writing PAM Applications and Services
-
-    // TODO: Return PAM error codes (to be logged) instead of emitting
-    // messages to screen?
-
-    struct pam_conv conv;
-    pam_handle_t *pamh;
-    int err;
-
-    conv.conv = pam_tty_conv;
-    conv.appdata_ptr = (void*)i_sPassword;
-
-    // Initialize PAM framework
-    err = pam_start("KeyMgr", "root", &conv, &pamh);
-    if (err != PAM_SUCCESS)
-    {
-        fprintf(stderr, "PAM error: %s\n", pam_strerror(pamh, err));
-        return -1;
-    }
-
-    // Change password
-    err = pam_chauthtok(pamh, 0);
-    if (err != PAM_SUCCESS)
-    {
-        fprintf(stderr, "PAM error: %s\n", pam_strerror(pamh, err));
-        // fall through to cleanup
-    }
-
-    // Cleanup session
-    pam_end(pamh, 0);
-
-    return (err == PAM_SUCCESS) ? 0 : -1;
-#endif
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_Alarm
- *
- * Description:
- *  Calls alarm(2) on Unix in order to cause the operating system to generate
- *  a SIGALRM signal for this process after the given number of real-time
- *  seconds.  Does nothing on Windows.
- *
- * Input
- * -----
- *    i_iSeconds       Number of seconds after which to generate a SIGALRM
- *                     signal
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        If a previous alarm request is pending, then it returns
- *                     the number of seconds until this previous request would
- *                     have generated a SIGALRM signal.  Otherwise, returns 0.
- *
- *--------------------------------------------------------------------------*/
-
-unsigned int K_Alarm( unsigned int i_iSeconds )
-{
-#ifndef WIN32
-    return alarm( i_iSeconds );
-#else
-    return 0;
-#endif
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_GetExtendedVersionFromBase
- *
- * Description:
- *  This KMS-specific function prepends the timestamp value to the specified
- *  base replication schema version and returns this value as an extended
- *  replication schema version.
- *
- * Input
- * -----
- *    i_iBaseSchemaVersion  Base replication schema version
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        Extended replication schema version
- *
- *--------------------------------------------------------------------------*/
-
-unsigned int K_GetExtendedVersionFromBase( unsigned int i_iBaseSchemaVersion )
-{
-    // seconds since 1970, force to 32-bit
-#ifdef WIN32
-    INT32 iTimeStamp = (INT32) time(NULL);
-#else
-    int32_t iTimeStamp = (int32_t) time(NULL);
-#endif
-    // minutes since 1970
-    iTimeStamp = iTimeStamp / 60;
-    // minutes since 2000 (approximately)
-    iTimeStamp -= (30*365*24*60);
-    // shift 8 bits to clear out room for schema version #
-    iTimeStamp = iTimeStamp << 8;
-    // add schema version # to lower end
-    iTimeStamp |= i_iBaseSchemaVersion;
-
-    return (unsigned int) iTimeStamp;
-
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_ParseTimestampFromExtendedVersion
- *
- * Description:
- *  This KMS-specific function parses the timestamp value from the given
- *  extended replication schema version and returns this timestamp value.
- *
- * Input
- * -----
- *    i_iExtendedSchemaVersion  Extended replication schema version
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        Timestamp value
- *
- *--------------------------------------------------------------------------*/
-
-unsigned int K_ParseTimestampFromExtendedVersion(
-    unsigned int i_iExtendedSchemaVersion )
-{
-    unsigned int iTimeStamp = i_iExtendedSchemaVersion >> 8;
-
-    return iTimeStamp;
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_ParseBaseFromExtendedVersion
- *
- * Description:
- *  This KMS-specific function parses the base replication schema value from
- *  the given extended replication schema version and returns this base value.
- *
- * Input
- * -----
- *    i_iExtendedSchemaVersion  Extended replication schema version
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        Base replication schema value
- *
- *--------------------------------------------------------------------------*/
-
-unsigned int K_ParseBaseFromExtendedVersion(
-    unsigned int i_iExtendedSchemaVersion )
-{
-    unsigned int iBaseSchemaVersion = i_iExtendedSchemaVersion & 0x000000FF;
-
-    return iBaseSchemaVersion;
-}
-
-
-/*---------------------------------------------------------------------------
- * Function: K_System
- *
- * Description:
- *  This function is a thread-safe replacement for the unsafe system(3C) call.
- *  See the popen(3C) man page for more information.
- *
- * Input
- * -----
- *    i_sCmd           Command to execute
- *
- * Output
- * ------
- *    (none)
- *
- * Return value        Termination status of the command language interpreter
- *                     if successful, -1 on failure
- *
- *--------------------------------------------------------------------------*/
-
-int K_System( const char *i_sCmd )
-{
-#ifndef WIN32
-        FILE *p;
-        int rc;
-        struct sigaction sOldAction;
-
-        // Save signal handler
-        sigaction( SIGCHLD, NULL, &sOldAction );
-
-        // Use default child signal handler
-        sigset( SIGCHLD, SIG_DFL );
-
-        p = popen( i_sCmd, "w" );
-        if ( p == NULL )
-        {
-            rc = -1;
-        }
-        else
-        {
-            rc = pclose( p );
-        }
-
-        // Reset signal handler
-        sigset( SIGCHLD, sOldAction.sa_handler );
-
-        return rc;
-#else
-        return system( i_sCmd );
-#endif
-}
-