/**
  * Load translation data (TBX file reader)
  *
  * @param  string  $filename  TBX file to add, full path must be given for access
  * @param  string  $locale    Locale has no effect for TBX because TBX defines all languages within
  *                            the source file
  * @param  array   $option    OPTIONAL Options to use
  * @throws Zend_Translation_Exception
  * @return array
  */
 protected function _loadTranslationData($filename, $locale, array $options = array())
 {
     $this->_data = array();
     if (!is_readable($filename)) {
         require_once 'Zend/Translate/Exception.php';
         throw new Zend_Translate_Exception('Translation file \'' . $filename . '\' is not readable.');
     }
     $encoding = $this->_findEncoding($filename);
     $this->_file = xml_parser_create($encoding);
     xml_set_object($this->_file, $this);
     xml_parser_set_option($this->_file, XML_OPTION_CASE_FOLDING, 0);
     xml_set_element_handler($this->_file, "_startElement", "_endElement");
     xml_set_character_data_handler($this->_file, "_contentElement");
     try {
         Zend_Xml_Security::scanFile($filename);
     } catch (Zend_Xml_Exception $e) {
         require_once 'Zend/Translate/Exception.php';
         throw new Zend_Translate_Exception($e->getMessage());
     }
     if (!xml_parse($this->_file, file_get_contents($filename))) {
         $ex = sprintf('XML error: %s at line %d of file %s', xml_error_string(xml_get_error_code($this->_file)), xml_get_current_line_number($this->_file), $filename);
         xml_parser_free($this->_file);
         require_once 'Zend/Translate/Exception.php';
         throw new Zend_Translate_Exception($ex);
     }
     return $this->_data;
 }

 /**
  * @param string $file
  * @return SimpleXMLElement
  * @throws XenForo_Exception
  */
 public static function scanFile($file)
 {
     $xml = Zend_Xml_Security::scanFile($file);
     if (!$xml) {
         throw new XenForo_Exception("Invalid XML in {$file}");
     }
     return $xml;
 }

 /**
  * Load configuration XML
  * 
  * @param string $configurationXml Configuration XML
  */
 public function loadXml($configurationXml)
 {
     // Convert to SimpleXMLElement
     $configurationXml = Zend_Xml_Security::scan($configurationXml);
     // Assign general settings
     $this->DataSources->OverallQuotaInMB = (int) $configurationXml->DataSources->OverallQuotaInMB;
     // Assign Logs settings
     $this->DataSources->Logs->BufferQuotaInMB = (int) $configurationXml->DataSources->Logs->BufferQuotaInMB;
     $this->DataSources->Logs->ScheduledTransferPeriodInMinutes = (int) $configurationXml->DataSources->Logs->ScheduledTransferPeriodInMinutes;
     $this->DataSources->Logs->ScheduledTransferLogLevelFilter = (string) $configurationXml->DataSources->Logs->ScheduledTransferLogLevelFilter;
     // Assign DiagnosticInfrastructureLogs settings
     $this->DataSources->DiagnosticInfrastructureLogs->BufferQuotaInMB = (int) $configurationXml->DataSources->DiagnosticInfrastructureLogs->BufferQuotaInMB;
     $this->DataSources->DiagnosticInfrastructureLogs->ScheduledTransferPeriodInMinutes = (int) $configurationXml->DataSources->DiagnosticInfrastructureLogs->ScheduledTransferPeriodInMinutes;
     $this->DataSources->DiagnosticInfrastructureLogs->ScheduledTransferLogLevelFilter = (string) $configurationXml->DataSources->DiagnosticInfrastructureLogs->ScheduledTransferLogLevelFilter;
     // Assign PerformanceCounters settings
     $this->DataSources->PerformanceCounters->BufferQuotaInMB = (int) $configurationXml->DataSources->PerformanceCounters->BufferQuotaInMB;
     $this->DataSources->PerformanceCounters->ScheduledTransferPeriodInMinutes = (int) $configurationXml->DataSources->PerformanceCounters->ScheduledTransferPeriodInMinutes;
     if ($configurationXml->DataSources->PerformanceCounters->Subscriptions && $configurationXml->DataSources->PerformanceCounters->Subscriptions->PerformanceCounterConfiguration) {
         $subscriptions = $configurationXml->DataSources->PerformanceCounters->Subscriptions;
         if (count($subscriptions->PerformanceCounterConfiguration) > 1) {
             $subscriptions = $subscriptions->PerformanceCounterConfiguration;
         } else {
             $subscriptions = array($subscriptions->PerformanceCounterConfiguration);
         }
         foreach ($subscriptions as $subscription) {
             $this->DataSources->PerformanceCounters->addSubscription((string) $subscription->CounterSpecifier, (int) $subscription->SampleRateInSeconds);
         }
     }
     // Assign WindowsEventLog settings
     $this->DataSources->WindowsEventLog->BufferQuotaInMB = (int) $configurationXml->DataSources->WindowsEventLog->BufferQuotaInMB;
     $this->DataSources->WindowsEventLog->ScheduledTransferPeriodInMinutes = (int) $configurationXml->DataSources->WindowsEventLog->ScheduledTransferPeriodInMinutes;
     $this->DataSources->WindowsEventLog->ScheduledTransferLogLevelFilter = (string) $configurationXml->DataSources->WindowsEventLog->ScheduledTransferLogLevelFilter;
     if ($configurationXml->DataSources->WindowsEventLog->Subscriptions && $configurationXml->DataSources->WindowsEventLog->Subscriptions->string) {
         $subscriptions = $configurationXml->DataSources->WindowsEventLog->Subscriptions;
         if (count($subscriptions->string) > 1) {
             $subscriptions = $subscriptions->string;
         } else {
             $subscriptions = array($subscriptions->string);
         }
         foreach ($subscriptions as $subscription) {
             $this->DataSources->WindowsEventLog->addSubscription((string) $subscription);
         }
     }
     // Assign Directories settings
     $this->DataSources->Directories->BufferQuotaInMB = (int) $configurationXml->DataSources->Directories->BufferQuotaInMB;
     $this->DataSources->Directories->ScheduledTransferPeriodInMinutes = (int) $configurationXml->DataSources->Directories->ScheduledTransferPeriodInMinutes;
     if ($configurationXml->DataSources->Directories->Subscriptions && $configurationXml->DataSources->Directories->Subscriptions->DirectoryConfiguration) {
         $subscriptions = $configurationXml->DataSources->Directories->Subscriptions;
         if (count($subscriptions->DirectoryConfiguration) > 1) {
             $subscriptions = $subscriptions->DirectoryConfiguration;
         } else {
             $subscriptions = array($subscriptions->DirectoryConfiguration);
         }
         foreach ($subscriptions as $subscription) {
             $this->DataSources->Directories->addSubscription((string) $subscription->Path, (string) $subscription->Container, (int) $subscription->DirectoryQuotaInMB);
         }
     }
 }

 public static function scanXmlString($xmlString)
 {
     if (self::callbackChecker('Zend_Xml_Security', 'scan')) {
         //Protected method
         $xmlObj = Zend_Xml_Security::scan($xmlString);
         if (!$xmlObj) {
             throw new XenForo_Exception("Invalid XML in {$xmlObj}");
         }
     } else {
         //Classic PHP method
         $xmlObj = simplexml_load_string($xmlString);
     }
     return $xmlObj;
 }

 /**
  * Constructor
  *
  * @param string $data XML Result
  * @return void
  */
 public function __construct($data)
 {
     set_error_handler(array($this, 'handleXmlErrors'));
     $this->_sxml = Zend_Xml_Security::scan($data);
     restore_error_handler();
     if ($this->_sxml === false) {
         if ($this->_errstr === null) {
             $message = "An error occured while parsing the REST response with simplexml.";
         } else {
             $message = "REST Response Error: " . $this->_errstr;
             $this->_errstr = null;
         }
         throw new Zend_Rest_Client_Result_Exception($message);
     }
 }

 /**
  * Class constructor.  Parse the XML response from a Nirvanix method
  * call into a decorated SimpleXMLElement element.
  *
  * @param string $xml  XML response string from Nirvanix
  * @throws Zend_Service_Nirvanix_Exception
  */
 public function __construct($xml)
 {
     $this->_sxml = Zend_Xml_Security::scan($xml);
     if (!$this->_sxml instanceof SimpleXMLElement) {
         $this->_throwException("XML could not be parsed from response: {$xml}");
     }
     $name = $this->_sxml->getName();
     if ($name != 'Response') {
         $this->_throwException("Expected XML element Response, got {$name}");
     }
     $code = (int) $this->_sxml->ResponseCode;
     if ($code != 0) {
         $msg = (string) $this->_sxml->ErrorMessage;
         $this->_throwException($msg, $code);
     }
 }

 /**
  * Returns a SimpleXML element from the provided file name (or XenForo_Upload object)
  * provided it is valid. If it is not valid, an error is thrown.
  *
  * @param string|XenForo_Upload $file
  *
  * @return SimpleXMLElement
  */
 public function getXmlFromFile($file)
 {
     if ($file instanceof XenForo_Upload) {
         $file = $file->getTempFile();
     }
     if (!file_exists($file)) {
         throw $this->_controller->responseException($this->_controller->responseError(new XenForo_Phrase('please_enter_valid_file_name_requested_file_not_read')));
     }
     try {
         $xml = Zend_Xml_Security::scanFile($file);
         if ($xml) {
             return $xml;
         }
     } catch (Exception $e) {
     }
     throw $this->_controller->responseException($this->_controller->responseError(new XenForo_Phrase('provided_file_was_not_valid_xml_file')));
 }

 /**
  * Zend_Feed_Entry_Abstract constructor
  *
  * The Zend_Feed_Entry_Abstract constructor takes the URI of the feed the entry
  * is part of, and optionally an XML construct (usually a
  * SimpleXMLElement, but it can be an XML string or a DOMNode as
  * well) that contains the contents of the entry.
  *
  * @param  string $uri
  * @param  SimpleXMLElement|DOMNode|string  $element
  * @return void
  * @throws Zend_Feed_Exception
  */
 public function __construct($uri = null, $element = null)
 {
     if (!$element instanceof DOMElement) {
         if ($element) {
             // Load the feed as an XML DOMDocument object
             @ini_set('track_errors', 1);
             $doc = new DOMDocument();
             $doc = @Zend_Xml_Security::scan($element, $doc);
             @ini_restore('track_errors');
             if (!$doc) {
                 // prevent the class to generate an undefined variable notice (ZF-2590)
                 if (!isset($php_errormsg)) {
                     if (function_exists('xdebug_is_enabled')) {
                         $php_errormsg = '(error message not available, when XDebug is running)';
                     } else {
                         $php_errormsg = '(error message not available)';
                     }
                 }
                 /**
                  * @see Zend_Feed_Exception
                  */
                 // require_once 'Zend/Feed/Exception.php';
                 throw new Zend_Feed_Exception("DOMDocument cannot parse XML: {$php_errormsg}");
             }
             $element = $doc->getElementsByTagName($this->_rootElement)->item(0);
             if (!$element) {
                 /**
                  * @see Zend_Feed_Exception
                  */
                 // require_once 'Zend/Feed/Exception.php';
                 throw new Zend_Feed_Exception('No root <' . $this->_rootElement . '> element found, cannot parse feed.');
             }
         } else {
             $doc = new DOMDocument('1.0', 'utf-8');
             if ($this->_rootNamespace !== null) {
                 $element = $doc->createElementNS(Zend_Feed::lookupNamespace($this->_rootNamespace), $this->_rootElement);
             } else {
                 $element = $doc->createElement($this->_rootElement);
             }
         }
     }
     parent::__construct($element);
 }

 /**
  * Create auth adapter
  *
  * @param string $rolefile File containing XML with users and roles
  */
 public function __construct($rolefile)
 {
     $this->_acl = new Zend_Acl();
     $xml = Zend_Xml_Security::scanFile($rolefile);
     /*
     Roles file format:
      <roles>
        <role id=”admin”>
             <user name=”user1” password=”pwd”/>
         </role>
        <role id=”hr”>
             <user name=”user2” password=”pwd2”/>
         </role>
     </roles>
     */
     foreach ($xml->role as $role) {
         $this->_acl->addRole(new Zend_Acl_Role((string) $role["id"]));
         foreach ($role->user as $user) {
             $this->_users[(string) $user["name"]] = array("password" => (string) $user["password"], "role" => (string) $role["id"]);
         }
     }
 }

 /**
  * Extract metadata from document
  *
  * @param ZipArchive $package    ZipArchive OpenXML package
  * @return array    Key-value pairs containing document meta data
  */
 protected function extractMetaData(ZipArchive $package)
 {
     // Data holders
     $coreProperties = array();
     // Read relations and search for core properties
     $relations = Zend_Xml_Security::scan($package->getFromName("_rels/.rels"));
     foreach ($relations->Relationship as $rel) {
         if ($rel["Type"] == Zend_Search_Lucene_Document_OpenXml::SCHEMA_COREPROPERTIES) {
             // Found core properties! Read in contents...
             $contents = Zend_Xml_Security::scan($package->getFromName(dirname($rel["Target"]) . "/" . basename($rel["Target"])));
             foreach ($contents->children(Zend_Search_Lucene_Document_OpenXml::SCHEMA_DUBLINCORE) as $child) {
                 $coreProperties[$child->getName()] = (string) $child;
             }
             foreach ($contents->children(Zend_Search_Lucene_Document_OpenXml::SCHEMA_COREPROPERTIES) as $child) {
                 $coreProperties[$child->getName()] = (string) $child;
             }
             foreach ($contents->children(Zend_Search_Lucene_Document_OpenXml::SCHEMA_DUBLINCORETERMS) as $child) {
                 $coreProperties[$child->getName()] = (string) $child;
             }
         }
     }
     return $coreProperties;
 }

 /**
  * Convert XML to SimpleXml
  * If user wants DomDocument they can use dom_import_simplexml
  *
  * @return SimpleXml Object
  */
 public function readXmlString()
 {
     $string = $this->_stream->readLongUTF();
     return Zend_Xml_Security::scan($string);
     //simplexml_load_string($string);
 }

 /**
  * Converts $response body to a DOM object and checks it.
  *
  * @param   Zend_Http_Response $response
  * @return  DOMDocument
  * @throws  Zend_Service_Technorati_Exception if response content contains an error message
  * @access  protected
  */
 protected function _convertResponseAndCheckContent(Zend_Http_Response $response)
 {
     $dom = new DOMDocument();
     $dom = Zend_Xml_Security::scan($response->getBody(), $dom);
     self::_checkErrors($dom);
     return $dom;
 }

 /**
  * Updates instance count in configuration XML.
  *
  * @param string|array $roleName			The role name
  * @param string|array $instanceCount		The instance count
  * @param string $configuration             XML configuration represented as a string
  * @throws Zend_Service_WindowsAzure_Management_Exception
  */
 protected function _updateInstanceCountInConfiguration($roleName, $instanceCount, $configuration)
 {
     // Change variables
     if (!is_array($roleName)) {
         $roleName = array($roleName);
     }
     if (!is_array($instanceCount)) {
         $instanceCount = array($instanceCount);
     }
     $configuration = preg_replace('/(<\\?xml[^?]+?)utf-16/i', '$1utf-8', $configuration);
     //$configuration = '<?xml version="1.0">' . substr($configuration, strpos($configuration, '>') + 2);
     $xml = Zend_Xml_Security::scan($configuration);
     // http://www.php.net/manual/en/simplexmlelement.xpath.php#97818
     $namespaces = $xml->getDocNamespaces();
     $xml->registerXPathNamespace('__empty_ns', $namespaces['']);
     for ($i = 0; $i < count($roleName); $i++) {
         $elements = $xml->xpath('//__empty_ns:Role[@name="' . $roleName[$i] . '"]/__empty_ns:Instances');
         if (count($elements) == 1) {
             $element = $elements[0];
             $element['count'] = $instanceCount[$i];
         }
     }
     $configuration = $xml->asXML();
     //$configuration = preg_replace('/(<\?xml[^?]+?)utf-8/i', '$1utf-16', $configuration);
     return $configuration;
 }

 /**
  * Load a response from an XML response
  *
  * Attempts to load a response from an XMLRPC response, autodetecting if it
  * is a fault response.
  *
  * @param string $response
  * @return boolean True if a valid XMLRPC response, false if a fault
  * response or invalid input
  */
 public function loadXml($response)
 {
     if (!is_string($response)) {
         $this->_fault = new Zend_XmlRpc_Fault(650);
         $this->_fault->setEncoding($this->getEncoding());
         return false;
     }
     try {
         $xml = Zend_Xml_Security::scan($response);
     } catch (Zend_Xml_Exception $e) {
         // Not valid XML
         $this->_fault = new Zend_XmlRpc_Fault(651);
         $this->_fault->setEncoding($this->getEncoding());
         return false;
     }
     if (!empty($xml->fault)) {
         // fault response
         $this->_fault = new Zend_XmlRpc_Fault();
         $this->_fault->setEncoding($this->getEncoding());
         $this->_fault->loadXml($response);
         return false;
     }
     if (empty($xml->params)) {
         // Invalid response
         $this->_fault = new Zend_XmlRpc_Fault(652);
         $this->_fault->setEncoding($this->getEncoding());
         return false;
     }
     try {
         if (!isset($xml->params) || !isset($xml->params->param) || !isset($xml->params->param->value)) {
             require_once 'Zend/XmlRpc/Value/Exception.php';
             throw new Zend_XmlRpc_Value_Exception('Missing XML-RPC value in XML');
         }
         $valueXml = $xml->params->param->value->asXML();
         $value = Zend_XmlRpc_Value::getXmlRpcValue($valueXml, Zend_XmlRpc_Value::XML_STRING);
     } catch (Zend_XmlRpc_Value_Exception $e) {
         $this->_fault = new Zend_XmlRpc_Fault(653);
         $this->_fault->setEncoding($this->getEncoding());
         return false;
     }
     $this->setReturnValue($value->getValue());
     return true;
 }

 /**
  * Unserialize from WDDX to PHP
  *
  * @param  string $wddx
  * @param  array $opts
  * @return mixed
  * @throws Zend_Serializer_Exception on wddx error
  */
 public function unserialize($wddx, array $opts = array())
 {
     $ret = wddx_deserialize($wddx);
     if ($ret === null) {
         // check if the returned NULL is valid
         // or based on an invalid wddx string
         try {
             $simpleXml = Zend_Xml_Security::scan($wddx);
             if (isset($simpleXml->data[0]->null[0])) {
                 return null;
                 // valid null
             }
             $errMsg = 'Can\'t unserialize wddx string';
         } catch (Zend_Xml_Exception $e) {
             $errMsg = $e->getMessage();
         }
         require_once 'Zend/Serializer/Exception.php';
         throw new Zend_Serializer_Exception($errMsg);
     }
     return $ret;
 }

 /**
  * Import a feed from a string
  *
  * Protects against XXE attack vectors.
  * 
  * @param  string $feed 
  * @return string
  * @throws Zend_Feed_Exception on detection of an XXE vector
  */
 protected function _importFeedFromString($feed)
 {
     if (trim($feed) == '') {
         require_once 'Zend/Feed/Exception.php';
         throw new Zend_Feed_Exception('Remote feed being imported' . ' is an Empty string or comes from an empty HTTP response');
     }
     $doc = new DOMDocument();
     $doc = Zend_Xml_Security::scan($feed, $doc);
     if (!$doc) {
         // prevent the class to generate an undefined variable notice (ZF-2590)
         // Build error message
         $error = libxml_get_last_error();
         if ($error && $error->message) {
             $errormsg = "DOMDocument cannot parse XML: {$error->message}";
         } else {
             $errormsg = "DOMDocument cannot parse XML";
         }
         /**
          * @see Zend_Feed_Exception
          */
         require_once 'Zend/Feed/Exception.php';
         throw new Zend_Feed_Exception($errormsg);
     }
     return $doc->saveXML($doc->documentElement);
 }

 /**
  * Set request
  *
  * $request may be any of:
  * - DOMDocument; if so, then cast to XML
  * - DOMNode; if so, then grab owner document and cast to XML
  * - SimpleXMLElement; if so, then cast to XML
  * - stdClass; if so, calls __toString() and verifies XML
  * - string; if so, verifies XML
  *
  * @param DOMDocument|DOMNode|SimpleXMLElement|stdClass|string $request
  * @return Zend_Soap_Server
  */
 protected function _setRequest($request)
 {
     if ($request instanceof DOMDocument) {
         $xml = $request->saveXML();
     } elseif ($request instanceof DOMNode) {
         $xml = $request->ownerDocument->saveXML();
     } elseif ($request instanceof SimpleXMLElement) {
         $xml = $request->asXML();
     } elseif (is_object($request) || is_string($request)) {
         if (is_object($request)) {
             $xml = $request->__toString();
         } else {
             $xml = $request;
         }
         $dom = new DOMDocument();
         try {
             if (strlen($xml) == 0 || !($dom = Zend_Xml_Security::scan($xml, $dom))) {
                 #require_once 'Zend/Soap/Server/Exception.php';
                 throw new Zend_Soap_Server_Exception('Invalid XML');
             }
         } catch (Zend_Xml_Exception $e) {
             #require_once 'Zend/Soap/Server/Exception.php';
             throw new Zend_Soap_Server_Exception($e->getMessage());
         }
     }
     $this->_request = $xml;
     return $this;
 }

 /**
  * Gets the document object for this response
  *
  * @return DOMDocument the DOM Document for this response.
  */
 public function getDocument()
 {
     try {
         $body = $this->_httpResponse->getBody();
     } catch (Zend_Http_Exception $e) {
         $body = false;
     }
     if ($this->_document === null) {
         if ($body !== false) {
             // turn off libxml error handling
             $errors = libxml_use_internal_errors();
             $this->_document = new DOMDocument();
             $this->_document = Zend_Xml_Security::scan($body, $this->_document);
             // reset libxml error handling
             libxml_clear_errors();
             libxml_use_internal_errors($errors);
         } else {
             $this->_document = false;
         }
     }
     return $this->_document;
 }

 /**
  * Parses the provided XML text and generates data model classes for
  * each know element by turning the XML text into a DOM tree and calling
  * transferFromDOM($element).  The first data model element with the same
  * name as $this->_rootElement is used and the child elements are
  * recursively parsed.
  *
  * @param string $xml The XML text to parse
  */
 public function transferFromXML($xml)
 {
     if ($xml) {
         // Load the feed as an XML DOMDocument object
         @ini_set('track_errors', 1);
         $doc = new DOMDocument();
         $doc = @Zend_Xml_Security::scan($xml, $doc);
         @ini_restore('track_errors');
         if (!$doc) {
             // require_once 'Zend/Gdata/App/Exception.php';
             throw new Zend_Gdata_App_Exception("DOMDocument cannot parse XML: {$php_errormsg}");
         }
         $element = $doc->getElementsByTagName($this->_rootElement)->item(0);
         if (!$element) {
             // require_once 'Zend/Gdata/App/Exception.php';
             throw new Zend_Gdata_App_Exception('No root <' . $this->_rootElement . '> element');
         }
         $this->transferFromDOM($element);
     } else {
         // require_once 'Zend/Gdata/App/Exception.php';
         throw new Zend_Gdata_App_Exception('XML passed to transferFromXML cannot be null');
     }
 }

 /**
  * Import an AppsForYourDomain error from XML.
  *
  * @param string $string The XML data to be imported
  * @return Zend_Gdata_Gapps_ServiceException Provides a fluent interface.
  * @throws Zend_Gdata_App_Exception
  */
 public function importFromString($string)
 {
     if ($string) {
         // Check to see if an AppsForYourDomainError exists
         //
         // track_errors is temporarily enabled so that if an error
         // occurs while parsing the XML we can append it to an
         // exception by referencing $php_errormsg
         @ini_set('track_errors', 1);
         $doc = new DOMDocument();
         $doc = @Zend_Xml_Security::scan($string, $doc);
         @ini_restore('track_errors');
         if (!$doc) {
             // require_once 'Zend/Gdata/App/Exception.php';
             // $php_errormsg is automatically generated by PHP if
             // an error occurs while calling loadXML(), above.
             throw new Zend_Gdata_App_Exception("DOMDocument cannot parse XML: {$php_errormsg}");
         }
         // Ensure that the outermost node is an AppsForYourDomain error.
         // If it isn't, something has gone horribly wrong.
         $rootElement = $doc->getElementsByTagName($this->_rootElement)->item(0);
         if (!$rootElement) {
             // require_once 'Zend/Gdata/App/Exception.php';
             throw new Zend_Gdata_App_Exception('No root <' . $this->_rootElement . '> element found, cannot parse feed.');
         }
         foreach ($rootElement->childNodes as $errorNode) {
             if (!$errorNode instanceof DOMText) {
                 $error = new Zend_Gdata_Gapps_Error();
                 $error->transferFromDom($errorNode);
                 $this->addError($error);
             }
         }
         return $this;
     } else {
         // require_once 'Zend/Gdata/App/Exception.php';
         throw new Zend_Gdata_App_Exception('XML passed to transferFromXML cannot be null');
     }
 }