cu_func.i

<?php

require_once dirname(__FILE__). '/hcuCommon.i';
// require_once dirname(__FILE__). '/hcuEnv.i';

$chk_key="SayChee3e";
// Constants for URL related encryption
define("URL_ENCDEC_CIPHER_MODE", "aes-256-ecb");
// allowed values: sha1, sha256
define("URL_ENCDEC_AUTH_HASH_ALGO", "sha256");

/**
 * check if mcrypt library exists
 */
function check_mcrypt_exists_cufunc() {
    if (!function_exists("mdecrypt_generic") && !function_exists("mcrypt_generic"))
        throw new exception("MCRYPT library does not exist.");
}

function hcu_encrypturl_mcrypt($str, $key) {
    check_mcrypt_exists_cufunc();
    $key_size = mcrypt_get_key_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB);
    // ** IF the key does not fit the proper length be sure to fill in the remaining spaces with null bytes
    $key = substr($key . str_repeat(chr(0), $key_size), 0, $key_size);
    $blocksize = mcrypt_get_block_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB);

    # implements PKCS7 padding
    $len = strlen($str);
    $pad = $blocksize - ($len % $blocksize);
    $str .= str_repeat(chr($pad), $pad);

    return bin2hex(mcrypt_encrypt(MCRYPT_RIJNDAEL_256, $key, $str, MCRYPT_MODE_ECB));
}

function hcu_encrypturl($str, $key, $cipher_method=URL_ENCDEC_CIPHER_MODE) {
    try {
        $enc_resp_url = hcuOpenSSLEncrypt($str,
                                          $key,
                                          $method=$cipher_method,
                                          $auth_hash_algo=URL_ENCDEC_AUTH_HASH_ALGO);
        $ciphertext = $enc_resp_url["message"];
        $hash_hmac = $enc_resp_url["hash"];
        return bin2hex($hash_hmac.$ciphertext);

        // return bin2hex($enc_resp_url["message"]);
    } catch (Exception $ex) {
        throw $ex;
    }

}

function hcu_decrypturl_mcrypt($str, $key) {
    check_mcrypt_exists_cufunc();
    $key_size = mcrypt_get_key_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB);
    $key = substr($key . str_repeat(chr(0), $key_size), 0, $key_size);

    // ** ctype_xdigit - Checks the string to look for Hex Characters only -- pack throws error if non-hex is found
    if (ctype_xdigit($str)) {
      $str = mcrypt_decrypt(MCRYPT_RIJNDAEL_256, $key, pack("H*",$str), MCRYPT_MODE_ECB);
    } else {
      // ** Return empty string, the remaining code fails if an empty string
      $str = '';
    }

    if ($str !== '') {
      # strip PKCS7 padding
      $slast = ord(substr($str, -1));
      // ** As explained in RFC 5652 6.3 Content-Encryption Process
      // ** All input is padded, so the ordinal value of the last character will always
      // ** represent the number of characters to strip.
      $str = substr($str, 0, -$slast);
    }
    return $str;
}

function hcu_decrypturl_openssl($str, $key, $cipher_method) {
    try {
        if (ctype_xdigit($str)) {

            $cipher_all = hex2bin($str);

            if(URL_ENCDEC_AUTH_HASH_ALGO == "sha256") {
                $auth_hash_len = 32; // bytes
            }
            // PARMENCDEC_AUTH_HASH_ALGO == "sha1"
            else {
                $auth_hash_len = 16; //bytes
            }

            $encrypted_hash = substr($cipher_all, 0, $auth_hash_len);
            $ciphertext = substr($cipher_all, $auth_hash_len);

            return hcuOpenSSLDecrypt($ciphertext,
                                     $encrypted_hash,
                                     $key,
                                     $method=$cipher_method,
                                     $auth_hash_algo=URL_ENCDEC_AUTH_HASH_ALGO);
        } else  {
            return '';
        }
    } catch (Exception $ex) {
        return False;
    }
}

function hcu_decrypturl($str, $key, $cipher_method=URL_ENCDEC_CIPHER_MODE) {
    try {
        $openssl_result = hcu_decrypturl_openssl($str, $key, $cipher_method);
        if ($openssl_result == False) {
            $mcrypt_result = hcu_decrypturl_mcrypt($str, $key);
            return $mcrypt_result;
         } else {
             return $openssl_result;
        }
    } catch (Exception $ex) {
        throw $ex;
    }
}

function hcu_checkOffline($dbh,$HB_ENV) {
# returns boolean - does status allow current script to continue?
$Cu=$HB_ENV['Cu'];
$live=$HB_ENV['live'];
$offline=$HB_ENV['offline'];
$allowReadonly=$HB_ENV['allowReadonly'];

switch ("$offline") {
    case "Y":  # yes, offline
    case "U":  # offline but "up-able"
        $CheckStatus=false;
        break;
    case "N":  # no, not offline
        $CheckStatus=true;
        break;
    case "R":  # readonly
        if ($allowReadonly && !($live)) {
            $CheckStatus=true;
        } else {
            $CheckStatus=false;
        }
        break;
    default:
        $CheckStatus=true;
    }

return $CheckStatus;
}

/**
 * hcu_checkService
 *
 * Requirements: cutrusted.i, must ALREADY be included for this function to work
 *
 * This function will look up a HOMECU service.
 * The HOMECU service status are stored in the parms field of cutrusteddetail
 *    WHERE cu = HOMECU and trustedid = HOMECUSERVICE
 *
 * At this time, I will hard cord these value in this function, possibly later
 *   we may want to make this a global option
 *
 *
 *
 * @param integer $p_dbh - Current database handle
 * @param string  $pRequestedService - this is the HOMECU SERVICE (ie IPAY, ENSENTA)
 *
 *                  that is being checked for online status
 *
 * @return boolean This function will return {true/false}
 *                  true - The Status for the requested Service is ACTIVE/ENABLED
 *                  false - The Status of the requested Service is OFFLINE --
 *                            The calling script should try and avoid using the
 *                              service if false is returned
 *
 *
 * RULES *
 * Assume TRUE - ONLY SET TO FALSE for explicit value in the field,
 *                I am thinking this because we have a big system and don't want
 *                failure UNLESS expressed
 *
 */
function hcu_checkService ($p_dbh, $pRequestedService) {
  $bolRet = true;

  // * SETUP THE cutrusted information to use to retrieve the service statuses
  $homecuTrustCU = 'HOMECU';
  $homecuTrustID = 'HOMECUSERVICE';

  $trustParms = Array("Cu" => $homecuTrustCU, "trustedid" => $homecuTrustID);
  $trustItems = cutd_read($p_dbh, $trustParms);

  if ($trustItems['status']['Response'] == 'true') {
    if ($trustItems['data']["{$homecuTrustCU}|{$homecuTrustID}"]) {
      if (is_array($trustItems['data']["{$homecuTrustCU}|{$homecuTrustID}"])) {
        $homecuServices = $trustItems['data']["{$homecuTrustCU}|{$homecuTrustID}"];
        // ** Now have an ARRAY of services
        foreach ($homecuServices as $itemService => $itemValue) {
          // * MATCH the requested service
          if (strtoupper($pRequestedService) == strtoupper($itemService)) {
            // IF FOUND --
              // return - true if value is N
              // return - false if value is {Y/U}
            $bolRet = ($itemValue == 'N' ? true : false);
            break;
          }
        }
      }
    }
  }

  return $bolRet;
}
function hcu_checkServiceMsg ($p_dbh, $pRequestedService) {

  // * SETUP THE cutrusted information to use to retrieve the service statuses
  $homecuTrustCU = 'HOMECU';
  $homecuTrustID = 'HOMECUSERVICE';

  $trustParms = Array("Cu" => $homecuTrustCU, "trustedid" => $homecuTrustID);
  $trustItems = cutd_read($p_dbh, $trustParms);
  if ($trustItems['status']['Response'] == 'true') {
    if ($trustItems['data']["{$homecuTrustCU}|{$homecuTrustID}"]) {
      if (is_array($trustItems['data']["{$homecuTrustCU}|{$homecuTrustID}"])) {
        $homecuServices = $trustItems['data']["{$homecuTrustCU}|{$homecuTrustID}"];
        $pRequestedService=strtoupper($pRequestedService);
        $strMsg = $homecuServices["{$pRequestedService}_MSG"];
      }
    }
  }
 $strMsg = (trim($strMsg) == '' ? "Service temporarily unavailable. Please try again later" : $strMsg);
  return $strMsg;
}
function getcurl($cmd){
    $response='';
    $fd=popen("$cmd", "r");
      if ($fd)  {
            do {
                $data = @fread($fd, 8192);
                if (strlen($data) == 0) {
                    break;
                }
                $response .= $data;
            } while(true);

        pclose($fd);
            }
    return $response;
}

  // This function will examine a string for a 2-byte UTF-8 value and convert it to an HTML entity.
  // NOTE: UTF-8 2-byte format: 110xxxxx 10xxxxxx where x's make up the encoded number
  //  (so C4 84 -> 11000100 10000100 -> 001 00000100 -> 0x0104 -> 260 -> &#260)
  function ConvertFromUTF8( $stringIn ) {
    $stringOut = "";

    $len = strlen( $stringIn );
    for( $i = 0; $i < $len; $i++ ) {
      $c = ord( $stringIn[$i] );

      if ( $c >= 223 ) return $stringIn;
      elseif ( $c >= 192 ) {
        $bytes = 2;
        if ( ( $i + $bytes ) > $len ) return $stringIn;


        $firstByte = $c;
        $i++;
        $secondByte = ord( $stringIn[$i] );

        // mask off the first byte
        $firstByteMasked = $firstByte & 0x1F;

        // mask off the 2nd byte
        $secondByteMasked = $secondByte & 0x3F;

        // put low two bits from 1st byte into high two bits of 2nd byte
        $lowTwo = $firstByteMasked & 0x03;
        $lowTwo = $lowTwo << 6;
        $newSecond = $secondByteMasked | $lowTwo;

        // shift off low two bits of 1st byte
        $newFirst = $firstByteMasked >> 2;

        // now take the first nibble * 16^2 + 2nd nibble * 16 + 3rd nibble
        $final = $newFirst * 256 + ($newSecond >> 4) * 16 + ($newSecond & 0x0F);
        $encodedBytes = sprintf( "&#%d;", $final );

        $stringOut .= $encodedBytes;
      } else {
        // add to the output
        $stringOut .= chr( $c );
      }
    }
    return $stringOut;
  } // end ConvertFromUTF8

/**
 * This will return the FIRST directory from the parameter string
 *
 *  ie
 *    /hcubin7/m/script
 *      returns hcubin7
 *    /hcubin7/script
 *      returns hcubin7
 *
 * @param type $pUrl
 * @return type
 */
function returnBaseDirectory($pUrl){
    //get public directory structure eg "/top/second/third"
    $public_directory = dirname($pUrl);
    //place each directory into array
    $directory_array = explode('/', $public_directory);
    //get highest or top level in array of directory strings

    // * Return the first non-blank value..
      // * If a / is the first charactre of the directory then the first element is blank.
    $public_base = ($directory_array[0] != '' ? $directory_array[0] : $directory_array[1]);

    return $public_base;
}

/**
 * Convert Microsoft "smart quotes" and other characters to be a kind that doesn't make JSON or htmlentities barf.
 */
function convertMicrosoftCharacters( $inputStr ) {
  $search = array(chr(145),
                  chr(146),
                  chr(147),
                  chr(148),
                  chr(151),
                  chr(150),
                  chr(133),
                  "\342\200\234",
                  "\342\200\235"
                );

  $replace = array("'",
                   "'",
                   '"',
                   '"',
                   '-',
                   '-',
                   '&#8230;',
                   '"',
                   '"'
                 );

  return str_replace($search, $replace, $inputStr);
} // end convertMicrosoftChars