/**********************************************************************
// @@@ 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 @@@
//
**********************************************************************/
/* -*-C++-*-
 *****************************************************************************
 *
 * File:         CatSQLShare.cpp
 * Description:  See CatSQLShare.h for details.
 *               
 *               
 * Created:      7/2/99
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */

#define unsigned_char unsigned char
#define int_16        short

#include "CatSQLShare.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <ctype.h>
#include <limits.h>
#include "PortProcessCalls.h"
#include <pthread.h>

#include "cextdecs/cextdecs.h"
#include "seabed/ms.h"
#include "seabed/fs.h"
#include "seabed/fserr.h"


// Generate a unique value. This is really the meat and bone of UIDs,
// packaged in a context where it can be used by all SQL components, including utilities.
//
// Unique values are composed as follows:
// ---------------------------------------------------------------------------------
// WINDOWS - just uses the rightmost 51 bits of the Julian timestamp
// Linux:                                                                               !
// !          |rightmost 14 bits of node number | 
// |          |             XOR                 |
// |          |right most 14 bits of Thread ID  ! rghtmost 49 bits of Julian timestamp  !
// ! sign bit |       (14 bits)                 !   (expect rollover every 17 years)    !
// ---------------------------------------------------------------------------------
//
// The "Julian timestamp" is constructed from the combination of the system coldload
// time and the time since coldload, to avoid potential duplicates if the system clock 
// is set back while the system is running.

// On LINUX, use 49 bits, for other platforms, use 51 bits
#define MASK 0x1ffffffffffffLL

SQLShareInt64 CATSQLSHARE_LIB_FUNC
generateUniqueValue (void)
{
  static THREAD_P SQLShareInt64 lastTime = -1;
  static          SQLShareInt64 systemColdLoadTime = -1;
  static THREAD_P SQLShareInt64 highOrderBits = -1;
  static          SQLShareInt64 lastGeneratedUID = -1;
  pthread_mutex_t               lastGeneratedUID_mutex = PTHREAD_MUTEX_INITIALIZER;

  SQLShareInt64 timeSinceColdLoad = 0;

  // Generate the highOrderBits for the UID.  They will not change for`
  // the life of the thread, so we only need to calculate them once
  // per thread

  if (highOrderBits == -1)
  {
    Int32  rtnCode = -1;
    char monProcessName[MS_MON_MAX_PROCESS_NAME+1];

    Int32  monNodeId = -1;
    Int32  monProcessId = -1;
    Int32  monProcessType = -1;
    Int32  monZoneId = -1;
    Int32  lnxOsPid = -1;
    ThreadId lnxOsTid = -1;
    
    rtnCode = msg_mon_get_my_info(&monNodeId,              // int * mon node-id
                                  &monProcessId,           // int * mon process-id
                                  monProcessName,          // char * mon process-name
                                  MS_MON_MAX_PROCESS_NAME, // int mon process-name-max-len
                                  &monProcessType,         // int * mon process-type
                                  &monZoneId,              // int * mon zone-id
                                  &lnxOsPid,               // int * linux os process-id
                                  &lnxOsTid);              // long * linux os thread-id

    // should we return an error instead?
    if (rtnCode != XZFIL_ERR_OK)
    {
      monNodeId = 255;
      lnxOsTid = 1; 
    }

    highOrderBits = (monNodeId & 0x3fff) ^ (lnxOsTid & 0x3fff);

    // Shift over to make room for the Juliantimestamp
    highOrderBits = highOrderBits << 49;

    systemColdLoadTime = JULIANTIMESTAMP (1,OMIT,OMIT,OMIT);
    lastTime = JULIANTIMESTAMP (3,OMIT,OMIT,OMIT);

  }

  while (timeSinceColdLoad <= lastTime)
  {
    // cater for the situation where we run faster than the clock :-)
    timeSinceColdLoad = JULIANTIMESTAMP(3,OMIT,OMIT,OMIT);
  }

  // calculate the rightmost bits of JulianTimeStamp
  lastTime = timeSinceColdLoad;
  SQLShareInt64 tempValue = timeSinceColdLoad + systemColdLoadTime;
  tempValue = tempValue & MASK;

  // If highOrderBits + tempValue equals lastGeneratedUID then we generated the
  // same value as previous, add one to make it unique.
  // if hightOrderBits + tempValue is less than lastGeneratedUID, then we may have
  // generated the same value more than once, adjust.

  // Lock the mutex on lastGeneratedUID -- to ensure uniqueness.
  (void) pthread_mutex_lock(&lastGeneratedUID_mutex);

  if (lastGeneratedUID <= (highOrderBits + tempValue))
    lastGeneratedUID = highOrderBits + tempValue + 1;
  else
    lastGeneratedUID = highOrderBits + tempValue;

  SQLShareInt64 tempLastGeneratedUID = lastGeneratedUID;

  // Unlock the mutex
  (void) pthread_mutex_unlock(&lastGeneratedUID_mutex);

  return tempLastGeneratedUID;
}

//similar to generateUniqueValue
//except that it is faster since it does not use 
//time since coldload logic. Used for syskey generation in Trafodion.
#define MASK1 0x1ffffffffffffLL
Int64
generateUniqueValueFast ()
{
  static THREAD_P Int64 lastTime = -1;
  static THREAD_P Int64 highOrderBits = -1;
  Int64 uniqueValue = -1;
  Int64 currentTime = -1;
  struct timespec ts;
  ts.tv_sec = 0;
  ts.tv_nsec = 1000;  //1 microsecond
            
  // Generate the highOrderBits for the UID.  They will not change for`
  // the life of the thread, so we only need to calculate them once

  if (highOrderBits == -1)
  {
    
    Int32  rtnCode = -1;
    char monProcessName[MS_MON_MAX_PROCESS_NAME+1];

    Int32  monNodeId = -1;
    Int32  monProcessId = -1;
    Int32  monProcessType = -1;
    Int32  monZoneId = -1;
    Int32  lnxOsPid = -1;
    ThreadId lnxOsTid = -1;
    
    rtnCode = msg_mon_get_my_info(&monNodeId,              // int * mon node-id
                                  &monProcessId,           // int * mon process-id
                                  monProcessName,          // char * mon process-name
                                  MS_MON_MAX_PROCESS_NAME, // int mon process-name-max-len
                                  &monProcessType,         // int * mon process-type
                                  &monZoneId,              // int * mon zone-id
                                  &lnxOsPid,               // int * linux os process-id
                                  &lnxOsTid);              // long * linux os thread-id

    // should we return an error instead?
    if (rtnCode != XZFIL_ERR_OK)
    {
      monNodeId = 255;
      lnxOsTid = 1;
    }

    highOrderBits = (monNodeId & 0x3fff) ^ (lnxOsTid & 0x3fff);

    // Shift over to make room for the Juliantimestamp
    highOrderBits = highOrderBits << 49;

    currentTime = JULIANTIMESTAMP ();
  }
  else 
  {
    currentTime = JULIANTIMESTAMP ();
    while (currentTime <= lastTime)
    {
      //now sleep
      nanosleep(&ts, NULL);
      // cater for the situation where we run faster than the clock :-)
      currentTime = JULIANTIMESTAMP ();
    }
  }

  lastTime = currentTime ;
  // calculate the rightmost bits of JulianTimeStamp
  currentTime = currentTime & MASK1;
  uniqueValue = highOrderBits + currentTime ;

  return uniqueValue; 
}

//------------------------------------------------------------------------
// Generate a name, of specified format, based upon a generated unique value 
// (see above). Currently, we can generate 4 formats: 
//  - Funny filenames of the form axxxxx00
//  - Funny SMD subvol names of the form ZSDnxxxx
//  - Funny user subvol names of the form ZSDaxxxx
//  - Implicit ANSI name suffixes of the form 
//    <Truncated ANSI identifier>_nnnnnnnn_nnnn
// where x is an alphanum char, a is an alpha char and n is a digit,
// from the set of permitted characters below 
//
// generateFunnyName will return the desired name part, including decorations
//------------------------------------------------------------------------
//

// The layouts of the various forms of generated names
//
const char * NameFormatTemplates [] = 
{ "ZSDnxxxx",
  "ZSDaxxxx",
  "axxxxx00",
  "_nnnnnnnnn_nnnn"
};

//
// Permitted characters: No vowels, no zero digit
//
const char alphaNumCharacters [] = "BCDFGHJKLMNPQRSTVWXZ123456789";
const char * numericCharacters = &alphaNumCharacters[20];

// ----------------------------------------------------------------
// void generateFunnyName (const FunnyNameFormat nameFormat, char * generatedName);
//
// This function produces a new, hopefully unique "funny-name".  
// The Guardian name of a SQL partition has the form:
//      \system.$volume.ZSDxxxxx.axxxxx00
// where:
//    each "x" is a alphanumeric
//    the "a" is an alphabetic (numeric not allowed there by Guardian)
//    the last two chars of the file name are always zero ('0')
//
//
// The algorithm for generating the name has some features which
// are important to the way the name will be used.
// 1) First, a filename always is 8 chars long and ends
//    with "00".  This is needed on NT where the file system
//    & DP2 store multiple streams in the file (e.g., data
//    & resource fork) and use these last two chars internally
//    to identify which stream is being addressed
// 
// 2) Two unique values picked sequentially in the same process are likely 
//    to differ only by one. If we generated two funnynames from 
//    these by a standard right-to-left conversion into 
//    pseudo-base-36, the funny names would likely be alphabetically 
//    next to each other. This would cause an inefficiency for DP2
//    as the secondary labels of the two files would be intermixed.
//    So, when we convert the unique value into the funny name, we extract
//    the pseudo-base-36 right-to-left, but insert them left-to-right,
//    in order to keep the internal labels next to
//    their external counterparts.
// 
// ----------------------------------------------------------------


void CATSQLSHARE_LIB_FUNC
generateFunnyName (const FunnyNameFormat nameFormat, char * generatedName)
{

  const char * nameFormatTemplate = NameFormatTemplates[nameFormat];
  char * outputPointer = generatedName;

  SQLShareInt64 uniqueValue = generateUniqueValue ();

  const char * nextTemplateChar = nameFormatTemplate;

  while (*nextTemplateChar)
  {
    Int32 divisor;
    const char * base;

    switch (*nextTemplateChar)
    {
    case 'x': // Generate an alphanumeric character
      base = alphaNumCharacters;
      divisor = 29;
      break;

    case 'a': // Generate an alpha character
      base = alphaNumCharacters;
      divisor = 20;
      break;

    case 'n': // Generate a numeric character
      base = numericCharacters;
      divisor = 9;
      break;

    default:  // A decoration, simply move the character
      base = NULL;
      divisor = 0;
      break;
    }

    if (divisor)
    {
      *outputPointer = base [uniqueValue % divisor];
      uniqueValue /= divisor;
    }
    else
    {
      *outputPointer = *nextTemplateChar;
    }

    outputPointer++;
    nextTemplateChar++;
  }

  *outputPointer = 0;

}


//  CatDeriveRandomName
//
//  Generate a name from input simple object name by truncating to 20 chars
//  and appending 9-byte timestamp.
//  Caller must allocate and pass a 30 char array for output generatedName.
//  This array will be overwritten with a null-terminated string.
//  Both inputName and generatedName are treated as external formatted
//  names, but delimitted names are stripped of their delimitting quotes
//
//  The algorithm in this routine only works well when the inputName
//  contains characters in a character set like ISO88591; i.e., single-
//  byte characters.  The algorithm might run into problem when the
//  inputName contains multibyte characters; e.g., UTF-8 characters.

void CATSQLSHARE_LIB_FUNC 
  CatDeriveRandomName (const char* inputName, char* generatedName)
{
   generatedName[0] = '\0';
   UInt32 len = strlen(inputName);

   // Copy up to 20 chars of incoming name.
   if ( inputName[0] == '"' )
     // Identifier is delimited.  Strip the leading quote.
   {
     len = len - 1;
     if ( len > 20 )
       len = 20;
     strncpy( generatedName, &inputName[1], len);
   }
   else
   {
     if ( len > 20 )
       len = 20;
     strncpy ( generatedName, inputName, len );
   }
   generatedName[len] = '\0';

   // Strip trailing quotes from the (possibly truncated) name.
   for ( ; generatedName[len - 1] == '"' && len > 0; len-- );

   // Append the funny name suffix for uniqueness
   generateFunnyName (UID_GENERATED_ANSI_NAME, &generatedName[len]);

}


Int32 CATSQLSHARE_LIB_FUNC
SqlShareLnxGetMyProcessIdString (char   *processIdStrOutBuf,        // out
                                 size_t  processIdStrOutBufMaxLen,  // in
                                 size_t *pProcessIdStrLen)          // out
//
// Generates the process id string for my running process.
// The format of this process id string is:
// $mon-p-name:mon-node-id:mon-p-id:mon-p-type:mon-zone-id:linux-os-p-id:linux-os-thread-id
// where mon- stands for monitor- and -p- stands for -process-
// The generated process id string is stored in the DDL_LOCKS.PROCESS_ID
// metadata column by several utilities for later use by the RECOVER
// utility.
//
// Returns XZFIL_ERR_OK if successful.
// Returns XZFIL_ERR_BOUNDSERR if processIdStrOutBuf bufer is too small;
//                             *pProcessIdStrLen is set to the actual
//                             length of the generated string and
//                             processIdStrOutBuf is set to an empty string.
// Return the error code returned by the msg_mon_get_my_info() call and sets
//                             *pProcessIdStrLen to zero to tell the caller
//                             that this function is unable to compute the
//                             process id string
{
  Int32  rtnCode = -1;
  Int32  monNodeId = -1;
  Int32  monProcessId = -1;
  char monProcessName[MS_MON_MAX_PROCESS_NAME+1];
  Int32  monProcessType = -1;
  Int32  monZoneId = -1;
  Int32  lnxOsPid = -1;
  ThreadId lnxOsTid = -1;
  char buf[2016]; // plenty of room to avoide overflow condition
  char *p = NULL;

  // monProcessName[0] = '\0';
  rtnCode = msg_mon_get_my_info(&monNodeId,              // int * mon node-id
                                &monProcessId,           // int * mon process-id
                                monProcessName,          // char * mon process-name
                                MS_MON_MAX_PROCESS_NAME, // int mon process-name-max-len
                                &monProcessType,         // int * mon process-type
                                &monZoneId,              // int * mon zone-id
                                &lnxOsPid,               // int * linux os process-id
                                &lnxOsTid);              // long * linux os thread-id
  if (rtnCode != XZFIL_ERR_OK)
  {
    // set the actual length to zero to tell the caller
    // that we are unable to compute the process id string
    *pProcessIdStrLen = 0;
    processIdStrOutBuf[0] = '\0';
    return rtnCode;
  }

  // monProcessName[MS_MON_MAX_PROCESS_NAME] = '\0';
  memcpy(buf, monProcessName, strlen(monProcessName));
  p = &buf[strlen(monProcessName)];
  *p = '\0';

  sprintf(p,
          ":%-u:%-u:%-u:%-u:%-u:%-ld",
          monNodeId,
          monProcessId,
          monProcessType,
          monZoneId,
          lnxOsPid,
          lnxOsTid);

  if (strlen(buf) > processIdStrOutBufMaxLen)
  {
    // return the actual length just in case the caller
    // wants to allocate more space for the output buffer
    // and then tries again.
    *pProcessIdStrLen = strlen(buf);
    processIdStrOutBuf[0] = '\0';
    return XZFIL_ERR_BOUNDSERR;
  }

  *pProcessIdStrLen = strlen(buf);
  memcpy(processIdStrOutBuf, buf, *pProcessIdStrLen);
  if (*pProcessIdStrLen < processIdStrOutBufMaxLen)
    processIdStrOutBuf[*pProcessIdStrLen] = '\0';
  return XZFIL_ERR_OK;

}