Net_Growl
[ class tree: Net_Growl ] [ index: Net_Growl ] [ all elements ]

Source for file Gntp.php

Documentation is available at Gntp.php

  1. <?php
  2. /**
  3.  * Copyright (c) 2009-2013, Laurent Laville <pear@laurent-laville.org>
  4.  *                          Bertrand Mansion <bmansion@mamasam.com>
  5.  *
  6.  * All rights reserved.
  7.  *
  8.  * Redistribution and use in source and binary forms, with or without
  9.  * modification, are permitted provided that the following conditions
  10.  * are met:
  11.  *
  12.  *     * Redistributions of source code must retain the above copyright
  13.  *       notice, this list of conditions and the following disclaimer.
  14.  *     * Redistributions in binary form must reproduce the above copyright
  15.  *       notice, this list of conditions and the following disclaimer in the
  16.  *       documentation and/or other materials provided with the distribution.
  17.  *     * Neither the name of the authors nor the names of its contributors
  18.  *       may be used to endorse or promote products derived from this software
  19.  *       without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  22.  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
  25.  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27.  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  29.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31.  * POSSIBILITY OF SUCH DAMAGE.
  32.  *
  33.  * PHP version 5
  34.  *
  35.  * @category Networking
  36.  * @package  Net_Growl
  37.  * @author   Laurent Laville <pear@laurent-laville.org>
  38.  * @author   Bertrand Mansion <bmansion@mamasam.com>
  39.  * @license  http://www.opensource.org/licenses/bsd-license.php  BSD
  40.  * @version  SVN: $Id: Gntp.php 329331 2013-01-29 13:18:57Z farell $
  41.  * @link     http://growl.laurent-laville.org/
  42.  * @link     http://pear.php.net/package/Net_Growl
  43.  * @since    File available since Release 0.9.0
  44.  */
  45.  
  46. /**
  47.  * Growl implements GNTP 1.0 protocol
  48.  *
  49.  * @category Networking
  50.  * @package  Net_Growl
  51.  * @author   Laurent Laville <pear@laurent-laville.org>
  52.  * @author   Bertrand Mansion <bmansion@mamasam.com>
  53.  * @license  http://www.opensource.org/licenses/bsd-license.php  BSD
  54.  * @version  Release: 2.7.0
  55.  * @link     http://growl.laurent-laville.org/
  56.  * @link     http://pear.php.net/package/Net_Growl
  57.  * @link     http://www.growlforwindows.com/gfw/ Growl for Windows Homepage
  58.  * @since    Class available since Release 0.9.0
  59.  */
  60. class Net_Growl_Gntp extends Net_Growl
  61. {
  62.     /**
  63.      * Password hash alorithms supported by Gfw 2.0
  64.      * @var array 
  65.      */
  66.     private $_passwordHashAlgorithm = array('md5''sha1''sha256''sha512');
  67.  
  68.     /**
  69.      * Class constructor
  70.      *
  71.      * @param mixed  &$application  Can be either a Net_Growl_Application object
  72.      *                               or the application name string
  73.      * @param array  $notifications List of notification types
  74.      * @param string $password      (optional) Password for Growl
  75.      * @param array  $options       (optional) List of options : 'host', 'port',
  76.      *                               'protocol', 'timeout' for Growl socket server.
  77.      *                               'passwordHashAlgorithm', 'encryptionAlgorithm'
  78.      *                               to secure communications.
  79.      *                               'debug' to know what data are sent and received.
  80.      */
  81.     public function __construct(&$application$notifications = array(),
  82.         $password ''$options = array()
  83.     {
  84.         parent::__construct($application$notifications$password$options);
  85.     }
  86.  
  87.     /**
  88.      * Sends the REGISTER message type
  89.      *
  90.      * @return Net_Growl_Response 
  91.      * @throws Net_Growl_Exception if remote server communication failure
  92.      */
  93.     public function sendRegister()
  94.     {
  95.         $binaries = array();
  96.  
  97.         // Application-Name: <string>
  98.         // Required - The name of the application that is registering
  99.         $data "Application-Name: "
  100.               .  $this->utf8Encode($this->getApplication()->getGrowlName())
  101.               .  "\r\n";
  102.  
  103.         // Application-Icon: <url> | <uniqueid>
  104.         // Optional - The icon of the application
  105.         $icon  $this->getApplication()->getGrowlIcon();
  106.         if (empty($icon)) {
  107.             $this->debug("Invalid Application Icon URL"'warning');
  108.             // invalid Application Icon URL; so use default growl logo
  109.             $icon $this->getDefaultGrowlIcon();
  110.         }
  111.  
  112.         $hash            md5($icon);
  113.         $binaries[$hash$icon;
  114.  
  115.         $data .= "Application-Icon: x-growl-resource://" $hash "\r\n";
  116.  
  117.         // Notifications-Count: <int>
  118.         // Required - The number of notifications being registered
  119.         $notifications $this->getApplication()->getGrowlNotifications();
  120.         $data .= "Notifications-Count: " count($notifications"\r\n";
  121.  
  122.         foreach ($notifications as $name => $options{
  123.             $data .= "\r\n";
  124.  
  125.             // Notification-Name: <string>
  126.             // Required - The name (type) of the notification being registered
  127.             $data .= "Notification-Name: " $this->utf8Encode($name"\r\n";
  128.  
  129.             // Notification-Display-Name: <string>
  130.             // Optional - The name of the notification that is displayed to the user
  131.             // (defaults to the same value as Notification-Name)
  132.             if (is_array($options&& isset($options['display'])) {
  133.                 $data .= "Notification-Display-Name: "
  134.                       .  $options['display']
  135.                       .  "\r\n";
  136.             }
  137.  
  138.             // Notification-Enabled: <boolean>
  139.             // Optional - Indicates if the notification should be enabled by default
  140.             // (defaults to False)
  141.             if (is_array($options&& isset($options['enabled'])) {
  142.                 $data .= "Notification-Enabled: "
  143.                       .  $this->_toBool($options['enabled'])
  144.                       .  "\r\n";
  145.             }
  146.  
  147.             // Notification-Icon: <url> | <uniqueid>
  148.             // Optional - The default icon to use for notifications of this type
  149.             if (is_array($options&& isset($options['icon'])) {
  150.  
  151.                 $icon = new Net_Growl_Icon($options['icon']);
  152.                 $icon $icon->getContents();
  153.  
  154.                 if (empty($icon)) {
  155.                     $this->debug("Invalid Notification Icon URL"'warning');
  156.                     // invalid Notification Icon URL; so use default growl logo
  157.                     $icon $this->getDefaultGrowlIcon();
  158.                 }
  159.  
  160.                 $hash            md5($icon);
  161.                 $binaries[$hash$icon;
  162.  
  163.                 $data .= "Notification-Icon: x-growl-resource://" $hash "\r\n";
  164.             }
  165.         }
  166.  
  167.         $meth 'REGISTER';
  168.         $crypt_algorithm strtolower($this->options['encryptionAlgorithm']);
  169.         if ($crypt_algorithm != 'none'{
  170.             // add extra CRLF to header before encryption to fix Gfw 2.0.21 problem
  171.             $data .= "\r\n";
  172.         }
  173.         $data $this->genMessageStructure($meth$data);
  174.         if ($crypt_algorithm != 'none'{
  175.             // add extra CRLF to header before encryption to fix Gfw 2.0.21 problem
  176.             $data .= "\r\n";
  177.         }
  178.  
  179.         // binary section
  180.         foreach ($binaries as $hash => $growl_logo{
  181.             $res $this->genMessageStructure($meth$growl_logotrue);
  182.  
  183.             $data .= "\r\n";
  184.             $data .= "Identifier: " $hash "\r\n";
  185.             $data .= "Length: " strlen($res"\r\n";
  186.             $data .= "\r\n";
  187.             $data .= $res;
  188.         }
  189.  
  190.         // message termination
  191.         // A GNTP request must end with <CRLF><CRLF> (two blank lines)
  192.         $data .= "\r\n";
  193.         $data .= "\r\n";
  194.  
  195.         return $this->sendRequest($meth$data);
  196.     }
  197.  
  198.     /**
  199.      * Sends the NOTIFY message type
  200.      *
  201.      * @param string $name        Notification name
  202.      * @param string $title       Notification title
  203.      * @param string $description Notification description
  204.      * @param string $options     Notification options
  205.      *
  206.      * @return Net_Growl_Response 
  207.      * @throws Net_Growl_Exception if remote server communication failure
  208.      */
  209.     public function sendNotify($name$title$description$options)
  210.     {
  211.         $binaries = array();
  212.  
  213.         $appName     $this->utf8Encode($this->getApplication()->getGrowlName());
  214.         $name        $this->utf8Encode($name);
  215.         $title       $this->utf8Encode($title);
  216.         $description $this->utf8Encode($description);
  217.         $priority    = isset($options['priority'])
  218.             ? $options['priority': self::PRIORITY_NORMAL;
  219.         $icon        = isset($options['icon']$options['icon''';
  220.  
  221.         if (!empty($icon)) {
  222.             // check if valid icon
  223.  
  224.             if (!$icon instanceof Net_Growl_Icon{
  225.                 $icon = new Net_Growl_Icon($icon);
  226.             }
  227.             $icon $icon->getContents();
  228.             if (empty($icon)) {
  229.                 $this->debug("Invalid Notification Icon URL"'warning');
  230.             }
  231.         }
  232.  
  233.         // Application-Name: <string>
  234.         // Required - The name of the application that sending the notification
  235.         // (must match a previously registered application)
  236.         $data "Application-Name: " $appName "\r\n";
  237.  
  238.         // Notification-Name: <string>
  239.         // Required - The name (type) of the notification (must match a previously
  240.         // registered notification name registered by the application specified
  241.         // in Application-Name)
  242.         $data .= "Notification-Name: " $name "\r\n";
  243.  
  244.         // Notification-Title: <string>
  245.         // Required - The notification's title
  246.         $data .= "Notification-Title: " $title "\r\n";
  247.  
  248.         // Notification-Text: <string>
  249.         // Optional - The notification's text. (defaults to "")
  250.         $data .= "Notification-Text: " $description "\r\n";
  251.  
  252.         // Notification-Priority: <int>
  253.         // Optional - A higher number indicates a higher priority.
  254.         // This is a display hint for the receiver which may be ignored.
  255.         $data .= "Notification-Priority: " $priority "\r\n";
  256.  
  257.         if (!empty($icon)) {
  258.             // Notification-Icon: <url>
  259.             // Optional - The icon to display with the notification.
  260.  
  261.             $hash            md5($icon);
  262.             $binaries[$hash$icon;
  263.  
  264.             $data .= "Notification-Icon: x-growl-resource://" $hash "\r\n";
  265.         }
  266.  
  267.         // Notification-Sticky: <boolean>
  268.         // Optional - Indicates if the notification should remain displayed
  269.         // until dismissed by the user. (default to False)
  270.         if (is_array($options&& isset($options['sticky'])) {
  271.             $sticky $options['sticky'];
  272.             $data .= "Notification-Sticky: " $this->_toBool($sticky"\r\n";
  273.         }
  274.  
  275.         // Notification-ID: <string>
  276.         // Optional - A unique ID for the notification. If present, serves as a hint
  277.         // to the notification system that this notification should replace any
  278.         // existing on-screen notification with the same ID. This can be used
  279.         // to update an existing notification.
  280.         // The notification system may ignore this hint.
  281.         if (is_array($options&& isset($options['ID'])) {
  282.             $data .= "Notification-ID: " $options['ID'"\r\n";
  283.         }
  284.  
  285.         // Notification-Coalescing-ID: <string>
  286.         // Optional - If present, should contain the value of the Notification-ID
  287.         // header of a previously-sent notification. This serves as a hint to the
  288.         // notification system that this notification should replace/update the
  289.         // matching previous notification.
  290.         // The notification system may ignore this hint.
  291.         if (is_array($options&& isset($options['CoalescingID'])) {
  292.             $data .= "Notification-Coalescing-ID: " $options['CoalescingID']
  293.                 . "\r\n";
  294.         }
  295.  
  296.         // Notification-Callback-Context: <string>
  297.         // Optional - Any data (will be passed back in the callback unmodified)
  298.  
  299.         // Notification-Callback-Context-Type: <string>
  300.         // Optional, but Required if 'Notification-Callback-Context' is passed.
  301.         // The type of data being passed in Notification-Callback-Context
  302.         // (will be passed back in the callback unmodified). This does not need
  303.         // to be of any pre-defined type, it is only a convenience
  304.         // to the sending application.
  305.         if (is_array($options)
  306.             && (isset($options['CallbackContext'])
  307.             || isset($options['CallbackTarget']))
  308.         {
  309.             $data .= "Notification-Callback-Context: "
  310.                   .  $options['CallbackContext']
  311.                   .  "\r\n";
  312.             $data .= "Notification-Callback-Context-Type: "
  313.                   .  $options['CallbackContextType']
  314.                   .  "\r\n";
  315.             $callback = true;
  316.         else {
  317.             $callback = false;
  318.         }
  319.  
  320.         // Notification-Callback-Target: <string>
  321.         // Optional - An alternate target for callbacks from this notification.
  322.         // If passed, the standard behavior of performing the callback over the
  323.         // original socket will be ignored and the callback data will be passed
  324.         // to this target instead.
  325.         if (is_array($options)
  326.             && isset($options['CallbackTarget'])
  327.         {
  328.             $query '';
  329.             if (is_array($options&& isset($options['ID'])) {
  330.                 $query .= '&NotificationID='
  331.                        .  urlencode($options['ID']);
  332.             }
  333.             if (is_array($options&& isset($options['ID'])) {
  334.                 $query .= '&NotificationContext='
  335.                        .  urlencode($options['CallbackContext']);
  336.             }
  337.  
  338.             $callbackTarget $options['CallbackTarget';
  339.  
  340.             if (strpos($options['CallbackTarget']'?'=== false{
  341.                 $callbackTarget .= '?' substr($query1);
  342.             else {
  343.                 $callbackTarget .= $query;
  344.             }
  345.  
  346.             // BOTH methods are provided here for GfW compatibility.
  347.             $data .= "Notification-Callback-Context-Target: "
  348.                   .  $callbackTarget
  349.                   .  "\r\n";
  350.             // header kept for compatibility - @todo remove on final version
  351.             $data .= "Notification-Callback-Context-Target-Method: GET \r\n";
  352.  
  353.             // Only those ones should be keep on final version
  354.             $data .= "Notification-Callback-Target: "
  355.                   .  $callbackTarget
  356.                   .  "\r\n";
  357.             // header kept for compatibility - @todo remove on final version
  358.             $data .= "Notification-Callback-Target-Method: GET \r\n";
  359.         }
  360.  
  361.         $meth 'NOTIFY';
  362.         $data $this->genMessageStructure($meth$data);
  363.  
  364.         // binary section
  365.         foreach ($binaries as $hash => $growl_logo{
  366.             $res $this->genMessageStructure($meth$growl_logotrue);
  367.  
  368.             $data .= "\r\n";
  369.             $data .= "Identifier: " $hash "\r\n";
  370.             $data .= "Length: " strlen($res"\r\n";
  371.             $data .= "\r\n";
  372.             $data .= $res;
  373.         }
  374.  
  375.         // message termination
  376.         // A GNTP request must end with <CRLF><CRLF> (two blank lines)
  377.         $data .= "\r\n";
  378.         $data .= "\r\n";
  379.  
  380.         $res $this->sendRequest($meth$data$callback);
  381.         if ($res
  382.             && is_array($options&& isset($options['CallbackFunction'])
  383.             && is_callable($options['CallbackFunction'])
  384.         {
  385.             // handle Socket Callbacks
  386.             call_user_func_array(
  387.                 $options['CallbackFunction'],
  388.                 $this->growlNotificationCallback
  389.             );
  390.         }
  391.         return $res;
  392.     }
  393.  
  394.     /**
  395.      * Generates full message structure (header + body).
  396.      *
  397.      * @param string $method   Identifies the type of message
  398.      * @param string $data     Request message type data
  399.      * @param bool   $binaries (optional) Do not encrypt binary data header
  400.      *
  401.      * @return string 
  402.      */
  403.     protected function genMessageStructure($method$data$binaries = false)
  404.     {
  405.         static $keys;
  406.  
  407.         if ($binaries === false{
  408.             $data 'X-Sender: '
  409.                 . 'PEAR/Net_Growl ' Net_Growl::VERSION
  410.                 . ' PHP ' phpversion()
  411.                 . "\r\n"
  412.                 . $data;
  413.         }
  414.  
  415.         $password $this->getApplication()->getGrowlPassword();
  416.         $req      '';
  417.  
  418.         if (empty($password)) {
  419.             if ($binaries === false{
  420.                 $req = "GNTP/1.0 $method NONE\r\n";
  421.             }
  422.             $cipherText $data;
  423.         else {
  424.             if (!isset($keys)) {
  425.                 $password $this->utf8Encode($password);
  426.                 $keys     $this->_genKey($password);
  427.             }
  428.             list($hash$key)         $keys;
  429.             list($crypt$cipherText$this->_genEncryption($key$data);
  430.             if ($binaries === false{
  431.                 $req = "GNTP/1.0 $method $crypt $hash\r\n";
  432.             }
  433.         }
  434.         $req .= $cipherText;
  435.  
  436.         return $req;
  437.     }
  438.  
  439.     /**
  440.      * Generates Security Header message part.
  441.      *
  442.      * The authorization of messages is accomplished by passing key information
  443.      * that proves that the sending application knows a shared secret with the
  444.      * notification system, namely a password. Users that want to authorize
  445.      * applications must share with them a password that will be used for both
  446.      * authorization and encryption.
  447.      *
  448.      * Note: By default, authorization is not required for requests orginating
  449.      *       on the local machine.
  450.      *
  451.      * @param string $password Both client and server should know the password
  452.      *
  453.      * @return array 
  454.      * @throws Net_Growl_Exception on wrong password hash algorithm
  455.      */
  456.     private function _genKey($password)
  457.     {
  458.         $hash_algorithm strtolower($this->options['passwordHashAlgorithm']);
  459.         if ($hash_algorithm == 'none'{
  460.             return array('NONE''');
  461.         }
  462.         if (!in_array($hash_algorithmhash_algos())) {
  463.             // Hash algo unknown
  464.             $message 'Password hash algorithm not supported by php Mcrypt.';
  465.             throw new Net_Growl_Exception($message);
  466.         }
  467.         if (!in_array($hash_algorithm$this->_passwordHashAlgorithm)) {
  468.             // Hash algo incompatible with Gfw 2.0
  469.             $message 'Password hash algorithm is not compatible with Gfw 2.0';
  470.             throw new Net_Growl_Exception($message);
  471.         }
  472.         $saltVal   mt_rand(268435456mt_getrandmax());
  473.         $saltHex   dechex($saltVal);
  474.         $saltBytes pack("H*"$saltHex);
  475.  
  476.         $passHex   bin2hex($password);
  477.         $passBytes pack("H*"$passHex);
  478.         $keyBasis  $passBytes $saltBytes;
  479.  
  480.         $key     hash($hash_algorithm$keyBasistrue);
  481.         $keyHash hash($hash_algorithm$key);
  482.  
  483.         return array(strtoupper("$hash_algorithm:$keyHash.$saltHex")$key);
  484.     }
  485.  
  486.     /**
  487.      * Generates Encryption Header message part.
  488.      *
  489.      * @param string $key       Key generated from the password and salt
  490.      * @param string $plainText Request message type data
  491.      *
  492.      * @return array 
  493.      * @throws Net_Growl_Exception on wrong hash/crypt algorithms usage
  494.      */
  495.     private function _genEncryption($key$plainText)
  496.     {
  497.         static $ivVal;
  498.  
  499.         $hash_algorithm  strtolower($this->options['passwordHashAlgorithm']);
  500.         $crypt_algorithm strtolower($this->options['encryptionAlgorithm']);
  501.         $crypt_mode      = MCRYPT_MODE_CBC;
  502.  
  503.         $k array_search($hash_algorithm$this->_passwordHashAlgorithm);
  504.  
  505.         switch ($crypt_algorithm{
  506.         case 'aes':
  507.             if ($k < 2{
  508.                 $message = "Password hash ($hash_algorithm)"
  509.                         .  " and encryption ($crypt_algorithm) algorithms"
  510.                         .  " are not compatible."
  511.                         .  " Please uses SHA256 or SHA512 instead.";
  512.                 throw new Net_Growl_Exception($message);
  513.             }
  514.             $cipher = MCRYPT_RIJNDAEL_128;
  515.             // Be compatible with Gfw 2, PHP Mcrypt ext. returns 32 in this case
  516.             $key_size = 24;
  517.             break;
  518.         case 'des':
  519.             $cipher = MCRYPT_DES;
  520.             break;
  521.         case '3des':
  522.             if ($k < 2{
  523.                 $message = "Password hash ($hash_algorithm)"
  524.                         .  " and encryption ($crypt_algorithm) algorithms"
  525.                         .  " are not compatible."
  526.                         .  " Please uses SHA256 or SHA512 instead.";
  527.                 throw new Net_Growl_Exception($message);
  528.             }
  529.             $cipher = MCRYPT_3DES;
  530.             break;
  531.         case 'none':  // No encryption required
  532.             return array('NONE'$plainText);
  533.         default:      // Encryption algorithm unknown
  534.             $message = "Invalid encryption algorithm ($crypt_algorithm)";
  535.             throw new Net_Growl_Exception($message);
  536.         }
  537.  
  538.         // All encryption algorithms should use
  539.         // a block mode of CBC (Cipher Block Chaining)
  540.  
  541.         $td = mcrypt_module_open($cipher''$crypt_mode'');
  542.  
  543.         $iv_size    = mcrypt_enc_get_iv_size($td);
  544.         $block_size = mcrypt_enc_get_block_size($td);
  545.         if (!isset($key_size)) {
  546.             $key_size = mcrypt_enc_get_key_size($td);
  547.         }
  548.  
  549.         // Here's our 128-bit IV which is used for both 256-bit and 128-bit keys.
  550.         if (!isset($ivVal)) {
  551.             $ivVal = mcrypt_create_iv($iv_sizeMCRYPT_RAND);
  552.         }
  553.         $ivHex bin2hex($ivVal);
  554.  
  555.         // Different encryption algorithms require different key lengths
  556.         // and IV sizes, so use the first X bytes of the key as required.
  557.         $key substr($key0$key_size);
  558.  
  559.         $init = mcrypt_generic_init($td$key$ivVal);
  560.         if ($init != -1{
  561.             if ($crypt_mode == MCRYPT_MODE_CBC{
  562.                 /**
  563.                  * Pads a string using the RSA PKCS7 padding standards
  564.                  * so that its length is a multiple of the blocksize.
  565.                  * $block_size - (strlen($text) % $block_size) bytes are added,
  566.                  * each of which is equal to
  567.                  * chr($block_size - (strlen($text) % $block_size)
  568.                  */
  569.                 $length $this->strByteLen($plainText);
  570.                 $pad $block_size ($length $block_size);
  571.                 $plainText str_pad($plainText$length $padchr($pad));
  572.             }
  573.             $cipherText = mcrypt_generic($td$plainText);
  574.             mcrypt_generic_deinit($td);
  575.             mcrypt_module_close($td);
  576.         else {
  577.             $cipherText $plainText;
  578.         }
  579.  
  580.         return array(strtoupper("$crypt_algorithm:$ivHex")$cipherText);
  581.     }
  582.  
  583.     /**
  584.      * Translates boolean value to comprehensible text for GNTP messages
  585.      *
  586.      * @param mixed $value Compatible Boolean String or value to translate
  587.      *
  588.      * @return string 
  589.      */
  590.     private function _toBool($value)
  591.     {
  592.         if (preg_match('/^([Tt]rue|[Yy]es)$/'$value)) {
  593.             return 'True';
  594.         }
  595.         if (preg_match('/^([Ff]alse|[Nn]o)$/'$value)) {
  596.             return 'False';
  597.         }
  598.         if ((bool)$value === true{
  599.             return 'True';
  600.         }
  601.         return 'False';
  602.     }
  603. }

Documentation generated on Tue, 29 Jan 2013 18:30:04 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.