function strToHex($string)
{
    $hex='';
    for ($i=0; $i < strlen($string); $i++)
    {
        $hex .= dechex(ord($string[$i]));
    }
    return $hex;
}
 
function hexToStr($hex)
{
    $string='';
    for ($i=0; $i < strlen($hex)-1; $i+=2)
    {
        $string .= chr(hexdec($hex[$i].$hex[$i+1]));
    }
    return $string;
}
 
function ucs2ToStr($hex)
{
    $string='';
    for ($i=0; $i < strlen($hex)-1; $i+=2)
    {
   if ( $hex[$i].$hex[$i+1] == "00" ) { 
    $i+=2;
   }
   $string .= chr(hexdec($hex[$i].$hex[$i+1]));
    }
    return $string;
}
 
function hexbin($hex){
    $bin='';
    for($i=0;$i<strlen($hex);$i++)
        $bin.=str_pad(decbin(hexdec($hex{$i})),4,'0',STR_PAD_LEFT);
       return $bin;
} 
 
function binhex($bin){
    $hex='';
    for($i=strlen($bin)-4;$i>=0;$i-=4)
        $hex.=dechex(bindec(substr($bin,$i,4)));
   return strrev($hex);
}
 
function ucs2toutf8($str)
{
        for ($i=0;$i<strlen($str);$i+=4)
        {
                $substring1 = $str[$i].$str[$i+1];
                $substring2 = $str[$i+2].$str[$i+3];
 
                if ($substring1 == "00")
                {
                        $byte1 = "";
                        $byte2 = $substring2;
                }
                else
                {
                        $substring = $substring1.$substring2;
                        $byte1 = dechex(192+(hexdec($substring)/64));
                        $byte2 = dechex(128+(hexdec($substring)d));
                }
                $utf8 .= $byte1.$byte2;
        }
        return $utf8;
} 
 
 function ucs2html($str) {
    $str=trim($str); // if you are reading from file
    $len=strlen($str);
    $html='';
    for($i=0;$i<$len;$i+=2)
        $html.='&#'.hexdec(dechex(ord($str[$i+1])).
                   sprintf("s",dechex(ord($str[$i])))).';';
    return($html);
 }
 
 
function loadgsm7arrs()
{
 
  global $g2aarr, $a2garr;
 
  $g2aarr = array(
                  0x0040,
                  0x00A3,
                  0x0024,
                  0x00A5,
                  0x00E8,
                  0x00E9,
                  0x00F9,
                  0x00EC,
                  0x00F2,
                  0x00E7,
                  0x000A,
                  0x00D8,
                  0x00F8,
                  0x000D,
                  0x00C5,
                  0x00E5,
                  0x0394,
                  0x005F,
                  0x03A6,
                  0x0393,
                  0x039B,
                  0x03A9,
                  0x03A0,
                  0x03A8,
                  0x03A3,
                  0x0398,
                  0x039E,
                  0x00A0,
                  0x00C6,
                  0x00E6,
                  0x00DF,
                  0x00C9,
                  0x0020,
                  0x0021,
                  0x0022,
                  0x0023,
                  0x00A4,
                  0x0025,
                  0x0026,
                  0x0027,
                  0x0028,
                  0x0029,
                  0x002A,
                  0x002B,
                  0x002C,
                  0x002D,
                  0x002E,
                  0x002F,
                  0x0030,
                  0x0031,
                  0x0032,
                  0x0033,
                  0x0034,
                  0x0035,
                  0x0036,
                  0x0037,
                  0x0038,
                  0x0039,
                  0x003A,
                  0x003B,
                  0x003C,
                  0x003D,
                  0x003E,
                  0x003F,
                  0x00A1,
                  0x0041,
                  0x0042,
                  0x0043,
                  0x0044,
                  0x0045,
                  0x0046,
                  0x0047,
                  0x0048,
                  0x0049,
                  0x004A,
                  0x004B,
                  0x004C,
                  0x004D,
                  0x004E,
                  0x004F,
                  0x0050,
                  0x0051,
                  0x0052,
                  0x0053,
                  0x0054,
                  0x0055,
                  0x0056,
                  0x0057,
                  0x0058,
                  0x0059,
                  0x005A,
                  0x00C4,
                  0x00D6,
                  0x00D1,
                  0x00DC,
                  0x00A7,
                  0x00BF,
                  0x0061,
                  0x0062,
                  0x0063,
                  0x0064,
                  0x0065,
                  0x0066,
                  0x0067,
                  0x0068,
                  0x0069,
                  0x006A,
                  0x006B,
                  0x006C,
                  0x006D,
                  0x006E,
                  0x006F,
                  0x0070,
                  0x0071,
                  0x0072,
                  0x0073,
                  0x0074,
                  0x0075,
                  0x0076,
                  0x0077,
                  0x0078,
                  0x0079,
                  0x007A,
                  0x00E4,
                  0x00F6,
                  0x00F1,
                  0x00FC,
                  0x00E0 
                        );
 
  // create $a2garr
  // just flip the contents of keys and values
  foreach($g2aarr as $key => $val)
  {
    $a2garr[$val] = $key;
  }
 
  // then add the special chars we want to translate our way
  // in some cases they will be overwritten, for a reason
  $a2garr[13]   =  10;
  $a2garr[126]  =  32;
  $a2garr[94]   =  32;
  $a2garr[123]  =  40;
  $a2garr[125]  =  41;
  $a2garr[92]   =  47;
  $a2garr[91]   =  40;
  $a2garr[93]   =  41;
  $a2garr[124]  = 161;
  $a2garr[96]   =  39;
  $a2garr[8364] = 101;
 
}
 
//// ----------------------------------------
// asc2pdu()
//
// translates a string from regular alphabet to gsm-7
// encodes a string from septets to octets
// based upon 3GPP TS 23.038
// provides padding to match the septet boundary
//
// required parameters:
// - text
//   can be any length
// - padding bits
//   depending upon how long the header is from UDHL on,
//   we might need to add some padding bits as the pdu message
//   starts counting in septets from UDHL (inclusive),
//   but the whole UDH is in octets; padding is necessary
//   to start on the right septet boundary.
//   for further reference, check:
//   mobiletidings.com/2009/02/18/combining-sms-messages and
//   www.dreamfabric.com/sms
//
// needed globals:
// $a2garr[]
//
// returns {string}
// - translated/encoded string
//
 
function asc2pdu($txt, $pad)
{
 
  // global declare
  global $a2garr;
 
  // create a binary string starting with the
  // requested amount of padding bits (set to zero)
  $bstr = str_repeat('0', $pad);
 
  // sweep $txt for each character
  // append the 7 least significant bits to $bstr
  $txtlen = strlen($txt);
  for($tind = 0; $tind < $txtlen; $tind++)
  {
 
    // extract the char
    $xchr = substr($txt, $tind, 1);
 
    // read the ascii decimal chr
    $achr = ord($xchr);
 
    // translate it into gsm-7
    $tchr = $a2garr[$achr];
 
    // get the binary
    $bchr = base_convert($tchr, 10, 2);
 
    // pad it with zeroes
    $pchr = str_pad($bchr, 8, '0', STR_PAD_LEFT);
 
    // if it's in the high half of the byte
    // - log an error -- class 1
    // - change it into space
    //
    // further investigation incoming
    //
    if($pchr > 10000000)
    {
      // find your way to log the error
      // echoing is not the brightest way to do it :)
      echo "Found a char in the high byte half for text: ".$txt.
               " -- char is asc".$tchr."\r\n";
      $phcr = str_pad(base_convert('20', 16, 2), 8, '0', STR_PAD_LEFT);
    }
 
    // strip off the highest bit
    $schr = substr($pchr, 1);
 
    // reverse it and add to the resulting string
    $bstr .= strrev($schr);
 
  }
 
  // split into 8-bit chunks
  $carr = str_split($bstr, 8);
 
  // put together the hex string
  $hstr = '';
  foreach($carr as $chunk)
  {
    // reverse
    $rchk = strrev($chunk);
 
    // convert into hex
    $hchk = base_convert($rchk, 2, 16);
 
    // left pad with zeroes
    // add it to the hex string
    $hstr .= str_pad($hchk, 2, '0', STR_PAD_LEFT);
  }
 
  return $hstr;
 
}
 
 
//// ----------------------------------------
// pdu2asc()
//
// translates a string from gsm-7 to regular alphabet
// decodes a string from octets to septets
// based upon 3GPP TS 23.038
// provides psdding bits stripping
//
// required parameters:
// - text
// - padding bits to strip
//
// see header of asc2pdu()
//
// needed globals:
// $g2aarr[]
//
// returns {string}
// - translated/decoded string
//
 
function pdu2asc($pdu, $pad)
{
 
  // global declare
  global $g2aarr;
 
  // converting all octets in a big binary string
  $pdulen = strlen($pdu);
 
  $bstr = '';
  for($lind = 0; $lind < $pdulen; $lind += 2)
  {
    // extract the octet
    $xoct = substr($pdu, $lind, 2);
 
    // translate in binary
    $boct = base_convert($xoct, 16, 2);
 
    // pad it for the non significant zeroes
    $poct = str_pad($boct, 8, '0', STR_PAD_LEFT);
 
    // reverse it
    // add it to the binary string
    $bstr .= strrev($poct);
  }
 
  // strip off the padding bits
  // it has been previously added from the sender
  // to fit the next septet boundary
  // and we know exactly how many they are supposed to be
  $bstr = substr($bstr, $pad);
 
  // kill the extra bits off the last unfinished chunk, if any
  // or they would translate into nice @s
  $bmod = strlen($bstr) % 7;
  if($bmod)
  {
    $bstr = substr($bstr, 0, -$bmod);
  }
 
  // split it into 7-bit chunks
  $carr = str_split($bstr, 7);
 
  // put together the ascii string
  $astr = '';
  foreach($carr as $chunk)
  {
    // pad it with the non significant bits
    $pchk = str_pad(strrev($chunk), 8, '0', STR_PAD_LEFT);
 
    // translate it into ascii decimal
    $dchk = base_convert($pchk, 2, 10);
 
    // translate it into regular ascii alphabet
    $achk = $g2aarr[$dchk];
 
    // make it an ascii char and add it to the ascii string
    $astr .= chr($achk);
  }
 
  return $astr;
 
}
 
function utf16_to_utf8($str) {
    $c0 = ord($str[0]);
    $c1 = ord($str[1]);
 
    if ($c0 == 0xFE && $c1 == 0xFF) {
        $be = true;
    } else if ($c0 == 0xFF && $c1 == 0xFE) {
        $be = false;
    } else {
        return $str;
    }
 
    $str = substr($str, 2);
    $len = strlen($str);
    $dec = '';
    for ($i = 0; $i < $len; $i += 2) {
        $c = ($be) ? ord($str[$i]) << 8 | ord($str[$i + 1]) : 
                ord($str[$i + 1]) << 8 | ord($str[$i]);
        if ($c >= 0x0001 && $c <= 0x007F) {
            $dec .= chr($c);
        } else if ($c > 0x07FF) {
            $dec .= chr(0xE0 | (($c >> 12) & 0x0F));
            $dec .= chr(0x80 | (($c >>  6) & 0x3F));
            $dec .= chr(0x80 | (($c >>  0) & 0x3F));
        } else {
            $dec .= chr(0xC0 | (($c >>  6) & 0x1F));
            $dec .= chr(0x80 | (($c >>  0) & 0x3F));
        }
    }
    return $dec;
}