/* -*-C++-*-
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@

 *****************************************************************************
 *
 * File:         ComUser
 * Description:  Implements methods for user management
 *
 * Contains methods for classes:
 *   ComUser
 *   ComUserVerifyObj
 *   ComUserVerifyAuth
 *
 *****************************************************************************
 */

#define   SQLPARSERGLOBALS_FLAGS        // must precede all #include's
#define   SQLPARSERGLOBALS_NADEFAULTS

#include "ComUser.h"
#include "CmpSeabaseDDL.h"
#include "CmpDDLCatErrorCodes.h"

#include "sqlcli.h"
#include "SQLCLIdev.h"
#include "ExExeUtilCli.h"
#include "Context.h"

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class ComUser methods
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// ----------------------------------------------------------------------------
// Constructors
// ----------------------------------------------------------------------------
ComUser::ComUser()
{ }

// ----------------------------------------------------------------------------
// method:  getCurrentUser
//
// Returns currentUser from the Cli context
// ----------------------------------------------------------------------------
Int32 ComUser::getCurrentUser(void)
{
  Int32 dbUserID = 0;
  Int32 rc = 0;

  SQL_EXEC_ClearDiagnostics(NULL);

  rc = SQL_EXEC_GetSessionAttr(SESSION_DATABASE_USER_ID,
                               &dbUserID,
                               NULL, 0, NULL);

  assert(rc >= 0);
  assert(dbUserID >= SUPER_USER);

  return dbUserID;
  
}

// ----------------------------------------------------------------------------
// method:  getCurrentUsername
//
// Returns size of username
// ----------------------------------------------------------------------------
bool ComUser::getCurrentUsername(
   char * username,
   Int32 maxUsernameLength)
   
{

   SQL_EXEC_ClearDiagnostics(NULL);

Int32 usernameLength = 0;

Int32 rc = SQL_EXEC_GetSessionAttr(SESSION_DATABASE_USER_ID,NULL,
                                   username,maxUsernameLength,&usernameLength);

   assert(rc >= 0);

   if (usernameLength > maxUsernameLength)
      return false;
     
   return true;

}

// ----------------------------------------------------------------------------
// method:  getCurrentUsername
//
// Returns a pointer to the current database username
// ----------------------------------------------------------------------------
const char * ComUser::getCurrentUsername()
   
{

   return GetCliGlobals()->currContext()->getDatabaseUserName();
   
}

// ----------------------------------------------------------------------------
// method:  getSessionUser
//
// Returns sessionUser from the Cli context
// ----------------------------------------------------------------------------
Int32 ComUser::getSessionUser(void)
{
  Int32 dbUserID = 0;
  Int32 rc = 0;

  SQL_EXEC_ClearDiagnostics(NULL);

  rc = SQL_EXEC_GetSessionAttr(SESSION_DATABASE_USER_ID,
                               &dbUserID,
                               NULL, 0, NULL);

  assert(rc >= 0);
  assert(dbUserID >= SUPER_USER);

  return dbUserID;
}

// ----------------------------------------------------------------------------
// method:  isRootUserID
//
// Returns true if current userID is the root user
// ----------------------------------------------------------------------------
bool ComUser::isRootUserID()
{
  return isRootUserID(getCurrentUser());
}

// ----------------------------------------------------------------------------
// method:  isRootUserID
//
// Returns true if passed in userID is the root user
// ----------------------------------------------------------------------------
bool ComUser::isRootUserID(Int32 userID)
{
  return (userID == SUPER_USER) ? true : false;
}

// ----------------------------------------------------------------------------
// method: getAuthType
//
// returns the type of authorization ID given the passed in authID
// ----------------------------------------------------------------------------
char ComUser::getAuthType(Int32 authID)
{

   if (authID == PUBLIC_USER)
      return AUTH_PUBLIC;

   if (authID == SYSTEM_USER)
      return AUTH_SYSTEM;

   if (authID >= MIN_USERID && authID <= MAX_USERID)
      return AUTH_USER;

   if (authID >= MAX_USERID && authID <= MAX_ROLEID)
      return AUTH_ROLE;
   return AUTH_UNKNOWN;
}

// -----------------------------------------------------------------------
// getUserNameFromUserID
//
// Reads the USERS table to get the user name associated with the passed
// in userID
//
//   <userID>                        Int32                           In
//      is the numeric ID to be mapped to a name.
//
//   <userName>                      char *                          In
//      passes back the name that the numeric ID mapped to.  If the ID does
//      not map to a name, the ASCII equivalent of the ID is passed back.
//
//   <maxLen>                        Int32                           In
//      is the size of <authName>.
//
//   <actualLen>                     Int32 &                         Out
//      is the size of the auth name in the table.  If larger than <maxLen>,
//      caller needs to supply a larger buffer.
//
// Returns:
//   FEOK          -- Found. User name written to userName. Length
//                    returned in actualLen.
//   FENOTFOUND    -- Not found
//   FEBUFTOOSMALL -- Found but output buffer is too small. Required
//                    length returned in actualLen.
//   Other         -- Unexpected error
// -----------------------------------------------------------------------
Int16 ComUser::getUserNameFromUserID(Int32 userID,
                                     char *userName,
                                     Int32 maxLen,
                                     Int32 &actualLen)
{
  Int16 result = FEOK;
  actualLen = 0;

  Int16 retcode = SQL_EXEC_GetDatabaseUserName_Internal(userID,
                                                        userName,
                                                        maxLen,
                                                        &actualLen);

  if (retcode < 0)
  {
    if (actualLen > 0)
      result = FEBUFTOOSMALL;
    else
      result = FENOTFOUND;
  }

  if (retcode != 0)
    SQL_EXEC_ClearDiagnostics(NULL);

  // On success, CLI does not return the length of the string in
  // actualLen. This function however is supposed to return a value in
  // actualLen even when the mapping is successful. The value returned
  // should not account for a null terminator.
  if (result == FEOK)
    actualLen = strlen(userName);
  return result;
}

// ----------------------------------------------------------------------------
// method: getUserIDFromUserName
//
// Reads the AUTHS table to get the userID associated with the passed
// in user name
//
//  Returns:  FEOK -- found
//            FENOTFOUND -- user not defined
//            other -- unexpected error
// ----------------------------------------------------------------------------
Int16 ComUser::getUserIDFromUserName(const char *userName, Int32 &userID)
{
  Int16 result = FEOK;

  Int16 retcode = SQL_EXEC_GetDatabaseUserID_Internal((char *) userName,
                                                      &userID);

  if (retcode < 0)
    result = FENOTFOUND;

  if (retcode != 0)
    SQL_EXEC_ClearDiagnostics(NULL);

  return result;
}


// ----------------------------------------------------------------------------
// method: getAuthIDFromAuthName
//
// Reads the AUTHS table to get the authID associated with the passed
// in authorization name
//
//  Returns:  FEOK -- found
//            FENOTFOUND -- auth name not defined
//            other -- unexpected error
// ----------------------------------------------------------------------------
Int16 ComUser::getAuthIDFromAuthName(const char *authName, Int32 &authID)
{
  Int16 result = FEOK;

  Int16 retcode = SQL_EXEC_GetAuthID(authName,authID);

  if (retcode < 0)
    result = FENOTFOUND;

  if (retcode != 0)
    SQL_EXEC_ClearDiagnostics(NULL);

  return result;
}


// ----------------------------------------------------------------------------
//  method:      getAuthNameFromAuthID
//
//  Maps an integer authentication ID to a name.  If the number cannot be
//  mapped to a name, the numeric ID is converted to a string.
//
//   <authID>                        Int32                           In
//      is the numeric ID to be mapped to a name.
//
//   <authName>                      char *                          In
//      passes back the name that the numeric ID mapped to.  If the ID does
//      not map to a name, the ASCII equivalent of the ID is passed back.
//
//   <maxLen>                        Int32                           In
//      is the size of <authName>.
//
//   <actualLen>                     Int32 &                         Out
//      is the size of the auth name in the table.  If larger than <maxLen>,
//      caller needs to supply a larger buffer.
//
//   Returns: Int16
//
//     FEOK          -- Found. User name written to userName. Length
//                      returned in actualLen.
//     FENOTFOUND    -- Not found
//     FEBUFTOOSMALL -- Found but output buffer is too small. Required
//                      length returned in actualLen.
//     Other         -- Unexpected error
// ----------------------------------------------------------------------------
Int16 ComUser::getAuthNameFromAuthID(Int32   authID,
                                     char  * authName,
                                     Int32   maxLen,
                                     Int32 & actualLen)

{
  actualLen = 0;
  int retcode = SQL_EXEC_GetAuthName_Internal(authID,authName,maxLen,actualLen);

  if (retcode < 0)  // ERROR == -1
  {
    if (actualLen > 0)
      return FEBUFTOOSMALL;

    return FENOTFOUND; //Should not happen
  }

  if (retcode != 0)
    SQL_EXEC_ClearDiagnostics(NULL);

  return FEOK;
}


// ----------------------------------------------------------------------------
// method: currentUserHasRole
//
// Searches the list of roles stored for the user to see if passed in role ID
// is found
//
//  Returns:  true - role found
//            false - role not found
// ----------------------------------------------------------------------------
bool ComUser::currentUserHasRole(Int32 roleID)
{
  Int32 numRoles = 0;
  Int32 *roleIDs = 0;
  if (SQL_EXEC_GetRoleList(numRoles, roleIDs) < 0)
    return false;

  for (Int32 i = 0; i < numRoles; i++)
  {
    Int32 userRole = roleIDs[i];
    if (userRole == roleID)
      return true;
  }
  return false;
}

void ComUser::getCurrentUserRoles(NAList <Int32> &roleList)
{
  Int32 numRoles = 0;
  Int32 *roleIDs = 0;
  Int32 retcode = SQL_EXEC_GetRoleList(numRoles, roleIDs);
  assert(retcode == 0);

  for (Int32 i = 0; i < numRoles; i++)
    roleList.insert (roleIDs[i]);
}


// ----------------------------------------------------------------------------
// method: getRoleList
//
// Returns the list of system roles
// Params:
//   (out) roleList - the list of roles, space is managed by the caller
//   (out) actualLen - the length of the returned role list
//   ( in) maxLen - the size of the roleList allocated by the caller
//   ( in) delimited - delimiter to use (defaults to single quote)
//   ( in) separator - specified what separator to use (defaults to comma)
//   ( in) includeSpecialAuths - includes the special auths (PUBLIC and _SYSTEM) 
//
//  Returns:  FEOK -- found
//            FEBUFTOOSMALL -- space allocated for role list is too small 
// ----------------------------------------------------------------------------
Int32 ComUser::getRoleList (char * roleList,
                            Int32 &actualLen,
                            const Int32 maxLen,
                            const char delimiter,
                            const char separator,
                            const bool includeSpecialAuths)
{
  Int32 numberRoles = sizeof(systemRoles)/sizeof(SystemAuthsStruct);
  Int32 roleListLen = (MAX_AUTHNAME_LEN*numberRoles)+(numberRoles * 4); // 4 = 2 del + 2 sep
  char generatedRoleList[roleListLen];
  char *pRoles = generatedRoleList;
  char roleName[MAX_AUTHNAME_LEN + 4];
  char currentSeparator = ' ';
  for (Int32 i = 0; i < numberRoles; i++)
  {
    const SystemAuthsStruct &roleDefinition = systemRoles[i];
    if (!includeSpecialAuths && roleDefinition.isSpecialAuth)
      continue;

    // str_sprintf does not support the %c format
    sprintf(roleName, "%c%c%s%c",
                currentSeparator, delimiter, roleDefinition.authName, delimiter);
    str_cpy_all(pRoles, roleName, sizeof(roleName)-1); // don't copy null terminator 
    currentSeparator = separator;
    pRoles = pRoles + strlen(roleName);
  }

  pRoles = '\0'; // null terminate string
  pRoles = generatedRoleList;
  actualLen = strlen(pRoles);
  if (actualLen > maxLen) 
    return FEBUFTOOSMALL;
 
  str_cpy_all(roleList, pRoles, strlen(pRoles));
  roleList[strlen(pRoles)] = 0; // null terminate string
  return FEOK;
}