AWLUtilities.php

<?php
if ( !function_exists('dbg_error_log') ) {
  function dbg_error_log() {
    global $c, $session;
    $args = func_get_args();
    $type = "DBG";
    $component = array_shift($args);
    if ( substr( $component, 0, 3) == "LOG" ) {
      // Special escape case for stuff that always gets logged.
      $type = 'LOG';
      $component = substr($component,4);
    }
    else if ( $component == "ERROR" ) {
      $type = "***";
    }
    else if ( isset($c->dbg["ALL"]) ) {
      $type = "ALL";
    }
    else if ( !isset($c->dbg[strtolower($component)]) ) return;
 
    /* ignore noisy components by setting $c->dbg['foo'] = 0; */
    if ( isset($c->dbg[strtolower($component)]) && $c->dbg[strtolower($component)] === 0 ) return;
 
    /* filter by remote IP or logged-in user */
    if ( isset($c->dbg_filter["remoteIP"]) && !in_array($_SERVER['REMOTE_ADDR'], $c->dbg_filter["remoteIP"]) ) return;
    if ( isset($c->dbg_filter["authenticatedUser"]) ) {
        if ( !isset($session->username) ) return;
        if ( !in_array($session->username, $c->dbg_filter["authenticatedUser"]) ) return;
    }
 
    $argc = func_num_args();
    if ( 2 <= $argc ) {
      $format = array_shift($args);
    }
    else {
      $format = "%s";
    }
    @error_log( $c->sysabbr.": $type: $component:". vsprintf( $format, $args ) );
  }
}
 
 
if ( !function_exists('fatal') ) {
  function fatal() {
    global $c;
    $args = func_get_args();
    $argc = func_num_args();
    if ( 2 <= $argc ) {
      $format = array_shift($args);
    }
    else {
      $format = "%s";
    }
    @error_log( $c->sysabbr.": FATAL: $component:". vsprintf( $format, $args ) );
 
    @error_log( "================= Stack Trace ===================" );
 
    $trace = array_reverse(debug_backtrace());
    array_pop($trace);
    foreach( $trace AS $k => $v ) {
      @error_log( sprintf(" ===>  %s[%d] calls %s%s%s()",
                    $v['file'],
                    $v['line'],
                    (isset($v['class'])?$v['class']:''),
                    (isset($v['type'])?$v['type']:''),
                    (isset($v['function'])?$v['function']:'')
      ));
    }
    echo "Fatal Error";
    exit();
  }
}
 
 
if ( !function_exists('trace_bug') ) {
  function trace_bug() {
    global $c;
    $args = func_get_args();
    $argc = func_num_args();
    if ( 2 <= $argc ) {
      $format = array_shift($args);
    }
    else {
      $format = "%s";
    }
    @error_log( $c->sysabbr.": BUG: $component:". vsprintf( $format, $args ) );
 
    @error_log( "================= Stack Trace ===================" );
 
    $trace = array_reverse(debug_backtrace());
    array_pop($trace);
    foreach( $trace AS $k => $v ) {
      @error_log( sprintf(" ===>  %s[%d] calls %s%s%s()",
                    $v['file'],
                    $v['line'],
                    (isset($v['class'])?$v['class']:''),
                    (isset($v['type'])?$v['type']:''),
                    (isset($v['function'])?$v['function']:'')
      ));
    }
  }
}
 
 
if ( !function_exists('apache_request_headers') ) {
  eval('
    function apache_request_headers() {
        foreach($_SERVER as $key=>$value) {
            if (substr($key,0,5)=="HTTP_") {
                $key=str_replace(" ","-",ucwords(strtolower(str_replace("_"," ",substr($key,5)))));
                $out[$key]=$value;
            }
        }
        return $out;
    }
  ');
}
 
 
 
if ( !function_exists('dbg_log_array') ) {
  function dbg_log_array( $component, $name, $arr, $recursive = false ) {
    if ( !isset($arr) || (gettype($arr) != 'array' && gettype($arr) != 'object') ) {
      dbg_error_log( $component, "%s: array is not set, or is not an array!", $name);
      return;
    }
    foreach ($arr as $key => $value) {
      dbg_error_log( $component, "%s: >>%s<< = >>%s<<", $name, $key,
                      (gettype($value) == 'array' || gettype($value) == 'object' ? gettype($value) : $value) );
      if ( $recursive && (gettype($value) == 'array' || (gettype($value) == 'object' && "$key" != 'self' && "$key" != 'parent') ) ) {
        dbg_log_array( $component, "$name"."[$key]", $value, $recursive );
      }
    }
  }
}
 
 
 
if ( !function_exists("session_simple_md5") ) {
  function session_simple_md5( $instr ) {
    global $c;
    if ( isset($c->dbg['password']) ) dbg_error_log( "Login", "Making plain MD5: instr=$instr, md5($instr)=".md5($instr) );
    return ( '*MD5*'. md5($instr) );
  }
}
 
 
 
if ( !function_exists("session_salted_md5") ) {
  function session_salted_md5( $instr, $salt = "" ) {
    if ( $salt == "" ) $salt = substr( md5(rand(100000,999999)), 2, 8);
    global $c;
    if ( isset($c->dbg['password']) ) dbg_error_log( "Login", "Making salted MD5: salt=$salt, instr=$instr, md5($salt$instr)=".md5($salt . $instr) );
    return ( sprintf("*%s*%s", $salt, md5($salt . $instr) ) );
  }
}
 
 
 
if ( !function_exists("session_salted_sha1") ) {
  function session_salted_sha1( $instr, $salt = "" ) {
    if ( $salt == "" ) $salt = substr( str_replace('*','',base64_encode(sha1(rand(100000,9999999),true))), 2, 9);
    global $c;
    if ( isset($c->dbg['password']) ) dbg_error_log( "Login", "Making salted SHA1: salt=$salt, instr=$instr, encoded($instr$salt)=".base64_encode(sha1($instr . $salt, true).$salt) );
    return ( sprintf("*%s*{SSHA}%s", $salt, base64_encode(sha1($instr.$salt, true) . $salt ) ) );
  }
}
 
 
if ( !function_exists("session_validate_password") ) {
 
  function session_validate_password( $they_sent, $we_have ) {
    global $c;
    if ( preg_match('/^\*\*.+$/', $we_have ) ) {
      //  The "forced" style of "**plaintext" to allow easier admin setting
      return ( "**$they_sent" == $we_have );
    }
 
    if ( isset($c->wp_includes) && substring($we_have,0,1) == '$' ) {
      // Include Wordpress password handling, if it's in the path.
      @require_once($c->wp_includes .'/class-phpass.php');
 
      if ( class_exists('PasswordHash') ) {
        $wp_hasher = new PasswordHash(8, true);
        return $wp_hasher->CheckPassword($password, $hash);
      }
    }
 
    if ( preg_match('/^\*(.+)\*{[A-Z]+}.+$/', $we_have, $regs ) ) {
      if ( function_exists("session_salted_sha1") ) {
        // A nicely salted sha1sum like "*<salt>*{SSHA}<salted_sha1>"
        $salt = $regs[1];
        $sha1_sent = session_salted_sha1( $they_sent, $salt ) ;
        return ( $sha1_sent == $we_have );
      }
      else {
        dbg_error_log( "ERROR", "Password is salted SHA-1 but you are using PHP4!" );
        echo <<<EOERRMSG
<html>
<head>
<title>Salted SHA1 Password format not supported with PHP4</title>
</head>
<body>
<h1>Salted SHA1 Password format not supported with PHP4</h1>
<p>At some point you have used PHP5 to set the password for this user and now you are
   using PHP4.  You will need to assign a new password to this user using PHP4, or ensure
   you use PHP5 everywhere (recommended).</p>
<p>AWL has now switched to using salted SHA-1 passwords by preference in a format
   compatible with OpenLDAP.</p>
</body>
</html>
EOERRMSG;
        exit;
      }
    }
 
    if ( preg_match('/^\*MD5\*.+$/', $we_have, $regs ) ) {
      // A crappy unsalted md5sum like "*MD5*<md5>"
      $md5_sent = session_simple_md5( $they_sent ) ;
      return ( $md5_sent == $we_have );
    }
    else if ( preg_match('/^\*(.+)\*.+$/', $we_have, $regs ) ) {
      // A nicely salted md5sum like "*<salt>*<salted_md5>"
      $salt = $regs[1];
      $md5_sent = session_salted_md5( $they_sent, $salt ) ;
      return ( $md5_sent == $we_have );
    }
 
    // Anything else is bad
    return false;
 
  }
}
 
 
 
if ( !function_exists("replace_uri_params") ) {
  function replace_uri_params( $uri, $replacements ) {
    $replaced = $uri;
    foreach( $replacements AS $param => $new_value ) {
      $rxp = preg_replace( '/([\[\]])/', '\\\\$1', $param );  // Some parameters may be arrays.
      $regex = "/([&?])($rxp)=([^&]+)/";
      dbg_error_log("core", "Looking for [%s] to replace with [%s] regex is %s and searching [%s]", $param, $new_value, $regex, $replaced );
      if ( preg_match( $regex, $replaced ) )
        $replaced = preg_replace( $regex, "\$1$param=$new_value", $replaced);
      else
        $replaced .= "&$param=$new_value";
    }
    if ( ! preg_match( '/\?/', $replaced  ) ) {
      $replaced = preg_replace("/&(.+)$/", "?\$1", $replaced);
    }
    $replaced = str_replace("&amp;", "--AmPeRsAnD--", $replaced);
    $replaced = str_replace("&", "&amp;", $replaced);
    $replaced = str_replace("--AmPeRsAnD--", "&amp;", $replaced);
    dbg_error_log("core", "URI <<$uri>> morphed to <<$replaced>>");
    return $replaced;
  }
}
 
 
if ( !function_exists("uuid") ) {
  function uuid() {
 
    // The field names refer to RFC 4122 section 4.1.2
 
    return sprintf('%04x%04x-%04x-%03x4-%04x-%04x%04x%04x',
        mt_rand(0, 65535), mt_rand(0, 65535), // 32 bits for "time_low"
        mt_rand(0, 65535), // 16 bits for "time_mid"
        mt_rand(0, 4095),  // 12 bits before the 0100 of (version) 4 for "time_hi_and_version"
        bindec(substr_replace(sprintf('%016b', mt_rand(0, 65535)), '01', 6, 2)),
            // 8 bits, the last two of which (positions 6 and 7) are 01, for "clk_seq_hi_res"
            // (hence, the 2nd hex digit after the 3rd hyphen can only be 1, 5, 9 or d)
            // 8 bits for "clk_seq_low"
        mt_rand(0, 65535), mt_rand(0, 65535), mt_rand(0, 65535) // 48 bits for "node"
    );
  }
}
 
if ( !function_exists("translate") ) {
  require("Translation.php");
}
 
 if ( !function_exists("clone") && version_compare(phpversion(), '5.0') < 0) {
  eval( 'function clone($object) { return $object; }' );
}
 
if ( !function_exists("quoted_printable_encode") ) {
  function quoted_printable_encode($string) {
    return preg_replace('/[^\r\n]{73}[^=\r\n]{2}/', "$0=\r\n", str_replace("%","=",str_replace("%20"," ",rawurlencode($string))));
  }
}
 
 
if ( !function_exists("check_by_regex") ) {
  function check_by_regex( $val, $regex ) {
    if ( is_null($val) ) return null;
    switch( $regex ) {
      case 'int':     $regex = '#^\d+$#';     break;
    }
    if ( is_array($val) ) {
      foreach( $val AS $k => $v ) {
        $val[$k] = check_by_regex($v,$regex);
      }
    }
    else if ( ! is_object($val) ) {
      if ( preg_match( $regex, $val, $matches) ) {
        $val = $matches[0];
      }
      else {
        $val = '';
      }
    }
    return $val;
  }
}
 
 
if ( !function_exists("param_to_global") ) {
  function param_to_global( ) {
    $args = func_get_args();
 
    $varname = array_shift($args);
    $GLOBALS[$varname] = null;
 
    $match_regex = null;
    $argc = func_num_args();
    if ( $argc > 1 ) {
      $match_regex = array_shift($args);
    }
 
    $args[] = $varname;
    foreach( $args AS $k => $name ) {
      if ( isset($_POST[$name]) ) {
        $result = $_POST[$name];
        break;
      }
      else if ( isset($_GET[$name]) ) {
        $result = $_GET[$name];
        break;
      }
    }
    if ( !isset($result) ) return null;
 
    if ( isset($match_regex) ) {
      $result = check_by_regex( $result, $match_regex );
    }
 
    $GLOBALS[$varname] = $result;
    return $result;
  }
}
 
 
if ( !function_exists("awl_get_fields") ) {
  $_AWL_field_cache = array();
 
  function awl_get_fields( $tablename ) {
    global $_AWL_field_cache;
 
    if ( !isset($_AWL_field_cache[$tablename]) ) {
      dbg_error_log( "core", ":awl_get_fields: Loading fields for table '$tablename'" );
      $qry = new AwlQuery();
      $db = $qry->GetConnection();
      $qry->SetSQL($db->GetFields($tablename));
      $qry->Exec("core");
      $fields = array();
      while( $row = $qry->Fetch() ) {
        $fields[$row->fieldname] = $row->typename . ($row->precision >= 0 ? sprintf('(%d)',$row->precision) : '');
      }
      $_AWL_field_cache[$tablename] = $fields;
    }
    return $_AWL_field_cache[$tablename];
  }
}
 
 
if ( !function_exists("force_utf8") ) {
  function define_byte_mappings() {
    global $byte_map, $nibble_good_chars;
 
    # Needed for using Grant McLean's byte mappings code
    $ascii_char = '[\x00-\x7F]';
    $cont_byte  = '[\x80-\xBF]';
 
    $utf8_2     = '[\xC0-\xDF]' . $cont_byte;
    $utf8_3     = '[\xE0-\xEF]' . $cont_byte . '{2}';
    $utf8_4     = '[\xF0-\xF7]' . $cont_byte . '{3}';
    $utf8_5     = '[\xF8-\xFB]' . $cont_byte . '{4}';
 
    $nibble_good_chars = "/^($ascii_char+|$utf8_2|$utf8_3|$utf8_4|$utf8_5)(.*)$/s";
 
    # From http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1252.TXT
    $byte_map = array(
        "\x80" => "\xE2\x82\xAC",  # EURO SIGN
        "\x82" => "\xE2\x80\x9A",  # SINGLE LOW-9 QUOTATION MARK
        "\x83" => "\xC6\x92",      # LATIN SMALL LETTER F WITH HOOK
        "\x84" => "\xE2\x80\x9E",  # DOUBLE LOW-9 QUOTATION MARK
        "\x85" => "\xE2\x80\xA6",  # HORIZONTAL ELLIPSIS
        "\x86" => "\xE2\x80\xA0",  # DAGGER
        "\x87" => "\xE2\x80\xA1",  # DOUBLE DAGGER
        "\x88" => "\xCB\x86",      # MODIFIER LETTER CIRCUMFLEX ACCENT
        "\x89" => "\xE2\x80\xB0",  # PER MILLE SIGN
        "\x8A" => "\xC5\xA0",      # LATIN CAPITAL LETTER S WITH CARON
        "\x8B" => "\xE2\x80\xB9",  # SINGLE LEFT-POINTING ANGLE QUOTATION MARK
        "\x8C" => "\xC5\x92",      # LATIN CAPITAL LIGATURE OE
        "\x8E" => "\xC5\xBD",      # LATIN CAPITAL LETTER Z WITH CARON
        "\x91" => "\xE2\x80\x98",  # LEFT SINGLE QUOTATION MARK
        "\x92" => "\xE2\x80\x99",  # RIGHT SINGLE QUOTATION MARK
        "\x93" => "\xE2\x80\x9C",  # LEFT DOUBLE QUOTATION MARK
        "\x94" => "\xE2\x80\x9D",  # RIGHT DOUBLE QUOTATION MARK
        "\x95" => "\xE2\x80\xA2",  # BULLET
        "\x96" => "\xE2\x80\x93",  # EN DASH
        "\x97" => "\xE2\x80\x94",  # EM DASH
        "\x98" => "\xCB\x9C",      # SMALL TILDE
        "\x99" => "\xE2\x84\xA2",  # TRADE MARK SIGN
        "\x9A" => "\xC5\xA1",      # LATIN SMALL LETTER S WITH CARON
        "\x9B" => "\xE2\x80\xBA",  # SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
        "\x9C" => "\xC5\x93",      # LATIN SMALL LIGATURE OE
        "\x9E" => "\xC5\xBE",      # LATIN SMALL LETTER Z WITH CARON
        "\x9F" => "\xC5\xB8",      # LATIN CAPITAL LETTER Y WITH DIAERESIS
    );
 
    for( $i=160; $i < 256; $i++ ) {
      $ch = chr($i);
      $byte_map[$ch] = iconv('ISO-8859-1', 'UTF-8', $ch);
    }
  }
  define_byte_mappings();
 
  function force_utf8( $input ) {
    global $byte_map, $nibble_good_chars;
 
    $output = '';
    $char   = '';
    $rest   = '';
    while( $input != '' ) {
      if ( preg_match( $nibble_good_chars, $input, $matches ) ) {
        $output .= $matches[1];
        $rest = $matches[2];
      }
      else {
        preg_match( '/^(.)(.*)$/s', $input, $matches );
        $char = $matches[1];
        $rest = $matches[2];
        if ( isset($byte_map[$char]) ) {
          $output .= $byte_map[$char];
        }
        else {
          # Must be valid UTF8 already
          $output .= $char;
        }
      }
      $input = $rest;
    }
    return $output;
  }
 
}
 
 
$timezone_identifiers_list_cache = timezone_identifiers_list();
 
function olson_from_tzstring( $tzstring ) {
  global $c, $timezone_identifiers_list_cache;
 
  if ( in_array($tzstring,$timezone_identifiers_list_cache) ) return $tzstring;
  if ( preg_match( '{((Antarctica|America|Africa|Atlantic|Asia|Australia|Indian|Europe|Pacific)/(([^/]+)/)?[^/]+)$}', $tzstring, $matches ) ) {
//    dbg_error_log( 'INFO', 'Found timezone "%s" from string "%s"', $matches[1], $tzstring );
    return $matches[1];
  }
  switch( $tzstring ) {
    case 'New Zealand Standard Time': case 'New Zealand Daylight Time':
         return 'Pacific/Auckland';
         break;
    case 'Central Standard Time':     case 'Central Daylight Time':     case 'US/Central':
         return 'America/Chicago';
         break;
    case 'Eastern Standard Time':     case 'Eastern Daylight Time':     case 'US/Eastern':
    case '(UTC-05:00) Eastern Time (US & Canada)':
         return 'America/New_York';
         break;
    case 'Pacific Standard Time':     case 'Pacific Daylight Time':     case 'US/Pacific':
         return 'America/Los_Angeles';
         break;
    case 'Mountain Standard Time':    case 'Mountain Daylight Time':    case 'US/Mountain':    case 'Mountain Time':
         return 'America/Denver';
         // The US 'Mountain Time' can in fact be America/(Denver|Boise|Phoenix|Shiprock) which
         // all vary to some extent due to differing DST rules.
         break;
    case '(GMT-07.00) Arizona':
         return 'America/Phoenix';
         break;
    default:
         if ( isset($c->timezone_translations) && is_array($c->timezone_translations)
                      && !empty($c->timezone_translations[$tzstring]) )
           return $c->timezone_translations[$tzstring];
  }
  return null;
}
 
if ( !function_exists("deprecated") ) {
  function deprecated( $method ) {
    global $c;
    if ( isset($c->dbg['ALL']) || isset($c->dbg['deprecated']) ) {
      $stack = debug_backtrace();
      array_shift($stack);
      if ( preg_match( '{/inc/iCalendar.php$}', $stack[0]['file'] ) && $stack[0]['line'] > __LINE__ ) return;
      @error_log( sprintf( $c->sysabbr.':DEPRECATED: Call to deprecated method "%s"', $method));
      foreach( $stack AS $k => $v ) {
        @error_log( sprintf( $c->sysabbr.':  ==>  called from line %4d of %s', $v['line'], $v['file']));
      }
    }
  }
}
 
 
if ( !function_exists("gzdecode") ) {
  function gzdecode( $instring ) {
    global $c;
    if ( !isset($c->use_pipe_gunzip) || $c->use_pipe_gunzip ) {
      $descriptorspec = array(
         0 => array("pipe", "r"),  // stdin is a pipe that the child will read from
         1 => array("pipe", "w"),  // stdout is a pipe that the child will write to
         2 => array("file", "/dev/null", "a") // stderr is discarded
      );
      $process = proc_open('gunzip',$descriptorspec, $pipes);
      if ( is_resource($process) ) {
        fwrite($pipes[0],$instring);
        fclose($pipes[0]);
 
        $outstring = stream_get_contents($pipes[1]);
        fclose($pipes[1]);
 
        proc_close($process);
        return $outstring;
      }
      return '';
    }
    else {
      $g=tempnam('./','gz');
      file_put_contents($g,$instring);
      ob_start();
      readgzfile($g);
      $d=ob_get_clean();
      unlink($g);
      return $d;
    }
  }
}
 
function awl_version() {
  global $c;
$c->awl_library_version = 0.61;
  return $c->awl_library_version;
}