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

Source for file Exceptions.php

Documentation is available at Exceptions.php

  1. <?php
  2.  
  3. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  4.  
  5. /**
  6.  * Various exception handling classes for Crypt_GPG
  7.  *
  8.  * Crypt_GPG provides an object oriented interface to GNU Privacy
  9.  * Guard (GPG). It requires the GPG executable to be on the system.
  10.  *
  11.  * This file contains various exception classes used by the Crypt_GPG package.
  12.  *
  13.  * PHP version 5
  14.  *
  15.  * LICENSE:
  16.  *
  17.  * This library is free software; you can redistribute it and/or modify
  18.  * it under the terms of the GNU Lesser General Public License as
  19.  * published by the Free Software Foundation; either version 2.1 of the
  20.  * License, or (at your option) any later version.
  21.  *
  22.  * This library is distributed in the hope that it will be useful,
  23.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  25.  * Lesser General Public License for more details.
  26.  *
  27.  * You should have received a copy of the GNU Lesser General Public
  28.  * License along with this library; if not, write to the Free Software
  29.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  30.  *
  31.  * @category  Encryption
  32.  * @package   Crypt_GPG
  33.  * @author    Nathan Fredrickson <nathan@silverorange.com>
  34.  * @author    Michael Gauthier <mike@silverorange.com>
  35.  * @copyright 2005-2011 silverorange
  36.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  37.  * @version   CVS: $Id$
  38.  * @link      http://pear.php.net/package/Crypt_GPG
  39.  */
  40.  
  41. /**
  42.  * PEAR Exception handler and base class
  43.  */
  44. require_once 'PEAR/Exception.php';
  45.  
  46. // {{{ class Crypt_GPG_Exception
  47.  
  48. /**
  49.  * An exception thrown by the Crypt_GPG package
  50.  *
  51.  * @category  Encryption
  52.  * @package   Crypt_GPG
  53.  * @author    Michael Gauthier <mike@silverorange.com>
  54.  * @copyright 2005 silverorange
  55.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  56.  * @link      http://pear.php.net/package/Crypt_GPG
  57.  */
  58. class Crypt_GPG_Exception extends PEAR_Exception
  59. {
  60. }
  61.  
  62. // }}}
  63. // {{{ class Crypt_GPG_FileException
  64.  
  65. /**
  66.  * An exception thrown when a file is used in ways it cannot be used
  67.  *
  68.  * For example, if an output file is specified and the file is not writeable, or
  69.  * if an input file is specified and the file is not readable, this exception
  70.  * is thrown.
  71.  *
  72.  * @category  Encryption
  73.  * @package   Crypt_GPG
  74.  * @author    Michael Gauthier <mike@silverorange.com>
  75.  * @copyright 2007-2008 silverorange
  76.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  77.  * @link      http://pear.php.net/package/Crypt_GPG
  78.  */
  79. {
  80.     // {{{ private class properties
  81.  
  82.     /**
  83.      * The name of the file that caused this exception
  84.      *
  85.      * @var string 
  86.      */
  87.     private $_filename '';
  88.  
  89.     // }}}
  90.     // {{{ __construct()
  91.  
  92.     /**
  93.      * Creates a new Crypt_GPG_FileException
  94.      *
  95.      * @param string  $message  an error message.
  96.      * @param integer $code     a user defined error code.
  97.      * @param string  $filename the name of the file that caused this exception.
  98.      */
  99.     public function __construct($message$code = 0$filename '')
  100.     {
  101.         $this->_filename $filename;
  102.         parent::__construct($message$code);
  103.     }
  104.  
  105.     // }}}
  106.     // {{{ getFilename()
  107.  
  108.     /**
  109.      * Returns the filename of the file that caused this exception
  110.      *
  111.      * @return string the filename of the file that caused this exception.
  112.      *
  113.      * @see Crypt_GPG_FileException::$_filename
  114.      */
  115.     public function getFilename()
  116.     {
  117.         return $this->_filename;
  118.     }
  119.  
  120.     // }}}
  121. }
  122.  
  123. // }}}
  124. // {{{ class Crypt_GPG_OpenSubprocessException
  125.  
  126. /**
  127.  * An exception thrown when the GPG subprocess cannot be opened
  128.  *
  129.  * This exception is thrown when the {@link Crypt_GPG_Engine} tries to open a
  130.  * new subprocess and fails.
  131.  *
  132.  * @category  Encryption
  133.  * @package   Crypt_GPG
  134.  * @author    Michael Gauthier <mike@silverorange.com>
  135.  * @copyright 2005 silverorange
  136.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  137.  * @link      http://pear.php.net/package/Crypt_GPG
  138.  */
  139. {
  140.     // {{{ private class properties
  141.  
  142.     /**
  143.      * The command used to try to open the subprocess
  144.      *
  145.      * @var string 
  146.      */
  147.     private $_command '';
  148.  
  149.     // }}}
  150.     // {{{ __construct()
  151.  
  152.     /**
  153.      * Creates a new Crypt_GPG_OpenSubprocessException
  154.      *
  155.      * @param string  $message an error message.
  156.      * @param integer $code    a user defined error code.
  157.      * @param string  $command the command that was called to open the
  158.      *                          new subprocess.
  159.      *
  160.      * @see Crypt_GPG::_openSubprocess()
  161.      */
  162.     public function __construct($message$code = 0$command '')
  163.     {
  164.         $this->_command $command;
  165.         parent::__construct($message$code);
  166.     }
  167.  
  168.     // }}}
  169.     // {{{ getCommand()
  170.  
  171.     /**
  172.      * Returns the contents of the internal _command property
  173.      *
  174.      * @return string the command used to open the subprocess.
  175.      *
  176.      * @see Crypt_GPG_OpenSubprocessException::$_command
  177.      */
  178.     public function getCommand()
  179.     {
  180.         return $this->_command;
  181.     }
  182.  
  183.     // }}}
  184. }
  185.  
  186. // }}}
  187. // {{{ class Crypt_GPG_InvalidOperationException
  188.  
  189. /**
  190.  * An exception thrown when an invalid GPG operation is attempted
  191.  *
  192.  * @category  Encryption
  193.  * @package   Crypt_GPG
  194.  * @author    Michael Gauthier <mike@silverorange.com>
  195.  * @copyright 2008 silverorange
  196.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  197.  * @link      http://pear.php.net/package/Crypt_GPG
  198.  */
  199. {
  200.     // {{{ private class properties
  201.  
  202.     /**
  203.      * The attempted operation
  204.      *
  205.      * @var string 
  206.      */
  207.     private $_operation '';
  208.  
  209.     // }}}
  210.     // {{{ __construct()
  211.  
  212.     /**
  213.      * Creates a new Crypt_GPG_OpenSubprocessException
  214.      *
  215.      * @param string  $message   an error message.
  216.      * @param integer $code      a user defined error code.
  217.      * @param string  $operation the operation.
  218.      */
  219.     public function __construct($message$code = 0$operation '')
  220.     {
  221.         $this->_operation $operation;
  222.         parent::__construct($message$code);
  223.     }
  224.  
  225.     // }}}
  226.     // {{{ getOperation()
  227.  
  228.     /**
  229.      * Returns the contents of the internal _operation property
  230.      *
  231.      * @return string the attempted operation.
  232.      *
  233.      * @see Crypt_GPG_InvalidOperationException::$_operation
  234.      */
  235.     public function getOperation()
  236.     {
  237.         return $this->_operation;
  238.     }
  239.  
  240.     // }}}
  241. }
  242.  
  243. // }}}
  244. // {{{ class Crypt_GPG_KeyNotFoundException
  245.  
  246. /**
  247.  * An exception thrown when Crypt_GPG fails to find the key for various
  248.  * operations
  249.  *
  250.  * @category  Encryption
  251.  * @package   Crypt_GPG
  252.  * @author    Michael Gauthier <mike@silverorange.com>
  253.  * @copyright 2005 silverorange
  254.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  255.  * @link      http://pear.php.net/package/Crypt_GPG
  256.  */
  257. {
  258.     // {{{ private class properties
  259.  
  260.     /**
  261.      * The key identifier that was searched for
  262.      *
  263.      * @var string 
  264.      */
  265.     private $_keyId '';
  266.  
  267.     // }}}
  268.     // {{{ __construct()
  269.  
  270.     /**
  271.      * Creates a new Crypt_GPG_KeyNotFoundException
  272.      *
  273.      * @param string  $message an error message.
  274.      * @param integer $code    a user defined error code.
  275.      * @param string  $keyId   the key identifier of the key.
  276.      */
  277.     public function __construct($message$code = 0$keyId'')
  278.     {
  279.         $this->_keyId $keyId;
  280.         parent::__construct($message$code);
  281.     }
  282.  
  283.     // }}}
  284.     // {{{ getKeyId()
  285.  
  286.     /**
  287.      * Gets the key identifier of the key that was not found
  288.      *
  289.      * @return string the key identifier of the key that was not found.
  290.      */
  291.     public function getKeyId()
  292.     {
  293.         return $this->_keyId;
  294.     }
  295.  
  296.     // }}}
  297. }
  298.  
  299. // }}}
  300. // {{{ class Crypt_GPG_NoDataException
  301.  
  302. /**
  303.  * An exception thrown when Crypt_GPG cannot find valid data for various
  304.  * operations
  305.  *
  306.  * @category  Encryption
  307.  * @package   Crypt_GPG
  308.  * @author    Michael Gauthier <mike@silverorange.com>
  309.  * @copyright 2006 silverorange
  310.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  311.  * @link      http://pear.php.net/package/Crypt_GPG
  312.  */
  313. {
  314. }
  315.  
  316. // }}}
  317. // {{{ class Crypt_GPG_BadPassphraseException
  318.  
  319. /**
  320.  * An exception thrown when a required passphrase is incorrect or missing
  321.  *
  322.  * @category  Encryption
  323.  * @package   Crypt_GPG
  324.  * @author    Michael Gauthier <mike@silverorange.com>
  325.  * @copyright 2006-2008 silverorange
  326.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  327.  * @link      http://pear.php.net/package/Crypt_GPG
  328.  */
  329. {
  330.     // {{{ private class properties
  331.  
  332.     /**
  333.      * Keys for which the passhprase is missing
  334.      *
  335.      * This contains primary user ids indexed by sub-key id.
  336.      *
  337.      * @var array 
  338.      */
  339.     private $_missingPassphrases = array();
  340.  
  341.     /**
  342.      * Keys for which the passhprase is incorrect
  343.      *
  344.      * This contains primary user ids indexed by sub-key id.
  345.      *
  346.      * @var array 
  347.      */
  348.     private $_badPassphrases = array();
  349.  
  350.     // }}}
  351.     // {{{ __construct()
  352.  
  353.     /**
  354.      * Creates a new Crypt_GPG_BadPassphraseException
  355.      *
  356.      * @param string  $message            an error message.
  357.      * @param integer $code               a user defined error code.
  358.      * @param string  $badPassphrases     an array containing user ids of keys
  359.      *                                     for which the passphrase is incorrect.
  360.      * @param string  $missingPassphrases an array containing user ids of keys
  361.      *                                     for which the passphrase is missing.
  362.      */
  363.     public function __construct($message$code = 0,
  364.         array $badPassphrases = array()array $missingPassphrases = array()
  365.     {
  366.         $this->_badPassphrases     $badPassphrases;
  367.         $this->_missingPassphrases $missingPassphrases;
  368.  
  369.         parent::__construct($message$code);
  370.     }
  371.  
  372.     // }}}
  373.     // {{{ getBadPassphrases()
  374.  
  375.     /**
  376.      * Gets keys for which the passhprase is incorrect
  377.      *
  378.      * @return array an array of keys for which the passphrase is incorrect.
  379.      *                The array contains primary user ids indexed by the sub-key
  380.      *                id.
  381.      */
  382.     public function getBadPassphrases()
  383.     {
  384.         return $this->_badPassphrases;
  385.     }
  386.  
  387.     // }}}
  388.     // {{{ getMissingPassphrases()
  389.  
  390.     /**
  391.      * Gets keys for which the passhprase is missing
  392.      *
  393.      * @return array an array of keys for which the passphrase is missing.
  394.      *                The array contains primary user ids indexed by the sub-key
  395.      *                id.
  396.      */
  397.     public function getMissingPassphrases()
  398.     {
  399.         return $this->_missingPassphrases;
  400.     }
  401.  
  402.     // }}}
  403. }
  404.  
  405. // }}}
  406. // {{{ class Crypt_GPG_DeletePrivateKeyException
  407.  
  408. /**
  409.  * An exception thrown when an attempt is made to delete public key that has an
  410.  * associated private key on the keyring
  411.  *
  412.  * @category  Encryption
  413.  * @package   Crypt_GPG
  414.  * @author    Michael Gauthier <mike@silverorange.com>
  415.  * @copyright 2008 silverorange
  416.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  417.  * @link      http://pear.php.net/package/Crypt_GPG
  418.  */
  419. {
  420.     // {{{ private class properties
  421.  
  422.     /**
  423.      * The key identifier the deletion attempt was made upon
  424.      *
  425.      * @var string 
  426.      */
  427.     private $_keyId '';
  428.  
  429.     // }}}
  430.     // {{{ __construct()
  431.  
  432.     /**
  433.      * Creates a new Crypt_GPG_DeletePrivateKeyException
  434.      *
  435.      * @param string  $message an error message.
  436.      * @param integer $code    a user defined error code.
  437.      * @param string  $keyId   the key identifier of the public key that was
  438.      *                          attempted to delete.
  439.      *
  440.      * @see Crypt_GPG::deletePublicKey()
  441.      */
  442.     public function __construct($message$code = 0$keyId '')
  443.     {
  444.         $this->_keyId $keyId;
  445.         parent::__construct($message$code);
  446.     }
  447.  
  448.     // }}}
  449.     // {{{ getKeyId()
  450.  
  451.     /**
  452.      * Gets the key identifier of the key that was not found
  453.      *
  454.      * @return string the key identifier of the key that was not found.
  455.      */
  456.     public function getKeyId()
  457.     {
  458.         return $this->_keyId;
  459.     }
  460.  
  461.     // }}}
  462. }
  463.  
  464. // }}}
  465. // {{{ class Crypt_GPG_KeyNotCreatedException
  466.  
  467. /**
  468.  * An exception thrown when an attempt is made to generate a key and the
  469.  * attempt fails
  470.  *
  471.  * @category  Encryption
  472.  * @package   Crypt_GPG
  473.  * @author    Michael Gauthier <mike@silverorange.com>
  474.  * @copyright 2011 silverorange
  475.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  476.  * @link      http://pear.php.net/package/Crypt_GPG
  477.  */
  478. {
  479. }
  480.  
  481. // }}}
  482. // {{{ class Crypt_GPG_InvalidKeyParamsException
  483.  
  484. /**
  485.  * An exception thrown when an attempt is made to generate a key and the
  486.  * key parameters set on the key generator are invalid
  487.  *
  488.  * @category  Encryption
  489.  * @package   Crypt_GPG
  490.  * @author    Michael Gauthier <mike@silverorange.com>
  491.  * @copyright 2011 silverorange
  492.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  493.  * @link      http://pear.php.net/package/Crypt_GPG
  494.  */
  495. {
  496.     // {{{ private class properties
  497.  
  498.     /**
  499.      * The key algorithm
  500.      *
  501.      * @var integer 
  502.      */
  503.     private $_algorithm = 0;
  504.  
  505.     /**
  506.      * The key size
  507.      *
  508.      * @var integer 
  509.      */
  510.     private $_size = 0;
  511.  
  512.     /**
  513.      * The key usage
  514.      *
  515.      * @var integer 
  516.      */
  517.     private $_usage = 0;
  518.  
  519.     // }}}
  520.     // {{{ __construct()
  521.  
  522.     /**
  523.      * Creates a new Crypt_GPG_InvalidKeyParamsException
  524.      *
  525.      * @param string  $message   an error message.
  526.      * @param integer $code      a user defined error code.
  527.      * @param string  $algorithm the key algorithm.
  528.      * @param string  $size      the key size.
  529.      * @param string  $usage     the key usage.
  530.      */
  531.     public function __construct(
  532.         $message,
  533.         $code = 0,
  534.         $algorithm = 0,
  535.         $size = 0,
  536.         $usage = 0
  537.     {
  538.         parent::__construct($message$code);
  539.  
  540.         $this->_algorithm $algorithm;
  541.         $this->_size      $size;
  542.         $this->_usage     $usage;
  543.     }
  544.  
  545.     // }}}
  546.     // {{{ getAlgorithm()
  547.  
  548.     /**
  549.      * Gets the key algorithm
  550.      *
  551.      * @return integer the key algorithm.
  552.      */
  553.     public function getAlgorithm()
  554.     {
  555.         return $this->_algorithm;
  556.     }
  557.  
  558.     // }}}
  559.     // {{{ getSize()
  560.  
  561.     /**
  562.      * Gets the key size
  563.      *
  564.      * @return integer the key size.
  565.      */
  566.     public function getSize()
  567.     {
  568.         return $this->_size;
  569.     }
  570.  
  571.     // }}}
  572.     // {{{ getUsage()
  573.  
  574.     /**
  575.      * Gets the key usage
  576.      *
  577.      * @return integer the key usage.
  578.      */
  579.     public function getUsage()
  580.     {
  581.         return $this->_usage;
  582.     }
  583.  
  584.     // }}}
  585. }
  586.  
  587. // }}}
  588.  
  589. ?>

Documentation generated on Wed, 13 Mar 2013 18:30:07 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.