webadmin.php

/var/www/(Del)hsihk.com/wp-content/plugins/backupbuddy/lib/zipbuddy/legacy.zipbuddy.php

<?php
/**
 *    pluginbuddy_zipbuddy Class
 *
 *    Handles zipping and unzipping, using the best methods available and falling back to worse methods
 *    as needed for compatibility. Allows for forcing compatibility modes.
 *    
 *    Version: 3.0.0
 *    Author: Dustin Bolton
 *    Author URI: http://dustinbolton.com/
 *
 *    $temp_dir        string        Temporary directory absolute path for temporary file storage. Must be writable!
 *    $zip_methods    array        Optional. Array of available zip methods to use. Useful for not having to re-test every time.
 *                                If omitted then a test will be performed to find the methods that work on this host.
 *    $mode            string        Future use to allow for other compression methods other than zip. Currently not in use.
 *
 */



// Try and load the experimental version - if successful then class will exist and remaining code will be ignored
if (
        ( defined( 'USE_EXPERIMENTAL_ZIPBUDDY' ) && ( true === USE_EXPERIMENTAL_ZIPBUDDY ) )
        ||
        ( isset( pb_backupbuddy::$options['alternative_zip'] ) && ( '1' == pb_backupbuddy::$options['alternative_zip'] ) )
    ) {
        require_once( dirname( __FILE__ ) . '/x-zipbuddy.php' );
}



if ( !class_exists( "pluginbuddy_zipbuddy" ) ) {
    class pluginbuddy_zipbuddy {
        
        
        /********** Properties **********/
        
        
        const ZIP_METHODS_TRANSIENT = 'pb_backupbuddy_avail_zip_methods_classic';
        const ZIP_EXECPATH_TRANSIENT = 'pb_backupbuddy_exec_path_classic';
        const ZIP_TRANSIENT_LIFE = 60;
        const NORM_DIRECTORY_SEPARATOR = '/';
        const DIRECTORY_SEPARATORS = '/\\';
        
        private $_commandbuddy;
        public $_zip_methods;        // Array of available zip methods.
        
        
        /********** Methods **********/
        
        
        function __construct( $temp_dir, $zip_methods = array(), $mode = 'zip' ) {
            //$this->_status = array();
            $this->_tempdir = $temp_dir;
            $this->_execpath = '';
            
            // Handles command line execution.
            require_once( pb_backupbuddy::plugin_path() . '/lib/commandbuddy/commandbuddy.php' );
            $this->_commandbuddy = new pb_backupbuddy_commandbuddy();
            
            if ( !empty( $zip_methods ) && ( count( $zip_methods ) > 0 ) ) {
                $this->_zip_methods = $zip_methods;
            } else {
                if ( function_exists( 'get_transient' ) ) { // Inside WordPress
                    
                    if ( pb_backupbuddy::$options['disable_zipmethod_caching'] == '1' ) {
                        pb_backupbuddy::status( 'details', 'Zip method caching disabled based on settings.' );
                        $available_methods = false;
                        $exec_path = false;
                    } else { // Use caching.
                        $available_methods = get_transient( self::ZIP_METHODS_TRANSIENT );
                        $exec_path = get_transient( self::ZIP_EXECPATH_TRANSIENT );
                    }
                    
                    if ( ( $available_methods === false ) || ( $exec_path === false ) ) {
                        pb_backupbuddy::status( 'details', 'Zip methods or exec path were not cached; detecting...' );
                        $this->_zip_methods = $this->available_zip_methods( false, $mode );
                        set_transient( self::ZIP_METHODS_TRANSIENT, $this->_zip_methods, self::ZIP_TRANSIENT_LIFE );
                        set_transient( self::ZIP_EXECPATH_TRANSIENT, $this->_execpath, self::ZIP_TRANSIENT_LIFE ); // Calculated and set in available_zip_methods().
                        pb_backupbuddy::status( 'details', 'Caching zipbuddy classic methods & exec path for `' . self::ZIP_TRANSIENT_LIFE . '` seconds.' );
                    } else {
                        pb_backupbuddy::status( 'details', 'Using cached zipbuddy classic methods: `' . implode( ',', $available_methods ) . '`.' );
                        pb_backupbuddy::status( 'details', 'Using cached zipbuddy classic exec path: `' . $exec_path . '`.' );
                        $this->_zip_methods = $available_methods;
                    }
                } else { // Outside WordPress
                    $this->_zip_methods = $this->available_zip_methods( false, $mode );
                    pb_backupbuddy::status( 'details', 'Zipbuddy classic methods not cached due to being outside WordPress.' );
                }
            }
        }
        
        
        // Function to translate a ZipArchive error code into an informative string description
        function ziparchive_error_info( $error, $full = true ) {
        
            // For safety let's check that the class actually exists...
            if ( class_exists( 'ZipArchive', false ) ) {
            
                // We can check the symbolic values
                switch( (int) $error ) {
                 case ZIPARCHIVE::ER_OK:
                     $error_name = "ZIPARCHIVE::ERR_OK";
                     $error_description = "No error";
                     break;
                 case ZIPARCHIVE::ER_OPEN:
                     $error_name = "ZIPARCHIVE::ER_OPEN";
                     $error_description = "Can't open file";
                     break;
                 case ZIPARCHIVE::ER_MEMORY:
                     $error_name = "ZIPARCHIVE::ER_MEMORY";
                     $error_description = "Memory allocation failure";
                     break;
                 case ZIPARCHIVE::ER_EXISTS:
                     $error_name = "ZIPARCHIVE::ERR_EXISTS";
                     $error_description = "File already exists";
                     break;
                 case ZIPARCHIVE::ER_INCONS:
                     $error_name = "ZIPARCHIVE::ER_INCONS";
                     $error_description = "Zip archive inconsistent";
                     break;
                 case ZIPARCHIVE::ER_INVAL:
                     $error_name = "ZIPARCHIVE::ER_INVAL";
                     $error_description = "Invalid argument";
                     break;
                 case ZIPARCHIVE::ER_NOENT:
                     $error_name = "ZIPARCHIVE::ER_NOENT";
                     $error_description = "No such file";
                     break;
                 case ZIPARCHIVE::ER_NOZIP:
                     $error_name = "ZIPARCHIVE::ER_NOZIP";
                     $error_description = "Not a zip archive";
                     break;
                 case ZIPARCHIVE::ER_READ:
                     $error_name = "ZIPARCHIVE::ER_READ";
                     $error_description = "Read error";
                     break;
                 case ZIPARCHIVE::ER_SEEK:
                     $error_name = "ZIPARCHIVE::ER_SEEK";
                     $error_description = "Seek error";
                     break;
                 case ZIPARCHIVE::ER_MULTIDISK:
                     $error_name = "ZIPARCHIVE::ER_MULTIDISK";
                     $error_description = "Multi-disk zip archives not supported";
                     break;
                 case ZIPARCHIVE::ER_RENAME:
                     $error_name = "ZIPARCHIVE::ER_RENAME";
                     $error_description = "Renaming temporary file failed";
                     break;
                 case ZIPARCHIVE::ER_CLOSE:
                     $error_name = "ZIPARCHIVE::ER_CLOSE";
                     $error_description = "Closing zip archive failed";
                     break;
                 case ZIPARCHIVE::ER_WRITE:
                     $error_name = "ZIPARCHIVE::ER_WRITE";
                     $error_description = "Write error";
                     break;
                 case ZIPARCHIVE::ER_CRC:
                     $error_name = "ZIPARCHIVE::ER_CRC";
                     $error_description = "CRC error";
                     break;
                 case ZIPARCHIVE::ER_ZIPCLOSED:
                     $error_name = "ZIPARCHIVE::ER_ZIPCLOSED";
                     $error_description = "Containing zip archive was closed";
                     break;
                 case ZIPARCHIVE::ER_TMPOPEN:
                     $error_name = "ZIPARCHIVE::ER_TMPOPEN";
                     $error_description = "Failure to create temporary file";
                     break;
                 case ZIPARCHIVE::ER_ZLIB:
                     $error_name = "ZIPARCHIVE::ER_ZLIB";
                     $error_description = "Zlib error";
                     break;
                 case ZIPARCHIVE::ER_CHANGED:
                     $error_name = "ZIPARCHIVE::ER_CHANGED";
                     $error_description = "Entry has been changed";
                     break;
                 case ZIPARCHIVE::ER_COMPNOTSUPP:
                     $error_name = "ZIPARCHIVE::ER_COMPNOTSUPP";
                     $error_description = "Compression method not supported";
                     break;
                 case ZIPARCHIVE::ER_EOF:
                     $error_name = "ZIPARCHIVE::ER_EOF";
                     $error_description = "Premature EOF";
                     break;
                 case ZIPARCHIVE::ER_INTERNAL:
                     $error_name = "ZIPARCHIVE::ER_INTERNAL";
                     $error_description = "Internal error";
                     break;
                 case ZIPARCHIVE::ER_REMOVE:
                     $error_name = "ZIPARCHIVE::ER_REMOVE";
                     $error_description = "Can't remove file";
                     break;
                 case ZIPARCHIVE::ER_DELETED:
                     $error_name = "ZIPARCHIVE::ER_DELETED";
                     $error_description = "Entry has been deleted";
                     break;
                 default:
                     $error_name = "ZIPARCHIVE::ERR_UNKNOWN";
                     $error_description = "Unkmown error";
                }
                
                $error_string = $error_name . "(" . $error . ") : " . $error_description;
            
            } else {
            
                // If the ZipArchive class doesn't exists just return a generic
                $error_string = "ZIPARCHIVE::ER_UNKNOWN(" . $error . ") : Unknown error";
            
            }
            
            // One way or another we have a string to return
            return $error_string;
        
        }
        
        // Returns true if the file (with path) exists in the ZIP.
        // If leave_open is true then the zip object will be left open for faster checking for subsequent files within this zip
        // Note: leave_open functionality currently not implemented
        function file_exists( $zip_file, $locate_file, $leave_open = false ) {

            // Use ZipArchive if available
            if ( in_array( 'ziparchive', $this->_zip_methods ) ) {
            
                // Make doubly sure it is available - if not we'll just drop through
                if ( class_exists( 'ZipArchive', false) ) {
                
                    $za = new ZipArchive();
                    $result = $za->open( $zip_file );
                    
                    // Make sure we opened the zip ok
                    if ( $result === true ) {
                    
                        // Now try and find the index of the file
                        $index = $za->locateName( $locate_file );
                        
                        // We have finished with the archive (leave_open ignored for now)
                        $za->close();
                        
                        // If we got an index we found it otherwise not found
                        if ( $index !== false ) {
                        
                            pb_backupbuddy::status( 'details', __('File found (ziparchive)','it-l10n-backupbuddy' ) . ': ' . $locate_file );
                            return true;
                            
                        } else {
                        
                            pb_backupbuddy::status( 'details', __('File not found (ziparchive)','it-l10n-backupbuddy' ) . ': ' . $locate_file );
                            return false;
                            
                        }
                        
                    } else {
                    
                        // Couldn't open archive - drop through as maybe other method will succeed?
                        $error_string = $this->ziparchive_error_info( $result );
                        pb_backupbuddy::status( 'details', sprintf( __('ZipArchive failed to open file to check if file exists (looking for %1$s in %2$s) - Error Info: %3$s.','it-l10n-backupbuddy' ), $locate_file , $zip_file, $error_string ) );

                    }
                
                } else {
                
                    // Something fishy - the methods indicated ziparchive but we couldn't find the class
                    pb_backupbuddy::status( 'details', __('ziparchive indicated as available method but ZipArchive class non-existent','it-l10n-backupbuddy' ) );

                }
                
            }
            
            // Dropped through because ZipArchive not available or failed to open file
            if ( in_array( 'pclzip', $this->_zip_methods ) ) {
            
                // Make sure we have it
                if ( !class_exists( 'PclZip', false ) ) {
                
                    // It's not already loaded so try and find/load it from possible locations
                    if ( file_exists( ABSPATH . 'wp-admin/includes/class-pclzip.php' ) ) {
                    
                        // Running under WordPress
                        @include_once( ABSPATH . 'wp-admin/includes/class-pclzip.php' );
                        
                    } elseif ( file_exists( pb_backupbuddy::plugin_path() . '/lib/pclzip/pclzip.php' ) ) {
                    
                        // Running Standalone (importbuddy)
                        @include_once( pb_backupbuddy::plugin_path() . '/lib/pclzip/pclzip.php' );
                        
                    }
                    
                }
                
                // Make sure we did load it
                if ( class_exists( 'PclZip', false ) ) {
                
                    $za = new PclZip( $zip_file );
                    
                    // Make sure we opened the zip ok and it has content
                    if ( ( $content_list = $za->listContent() ) !== 0 ) {
                    
                        // Get each file in sequence by index and get the properties
                        for ( $i = 0; $i < sizeof( $content_list ); $i++ ) {
                        
                            $stat = $content_list[ $i ];
                            
                            // Assume the key exists (consider testing)
                            if ( $stat[ 'filename' ] == $locate_file ) {
                            
                                // File found so we can just return
                                pb_backupbuddy::status( 'details', __('File found (pclzip)','it-l10n-backupbuddy' ) . ': ' . $locate_file );
                                return true;
                                
                            }
                            
                        }
                        
                        // Only get here if the file wasn't found
                        pb_backupbuddy::status( 'details', __('File not found (pclzip)','it-l10n-backupbuddy' ) . ': ' . $locate_file );
                        return false;

                    } else {
                    
                        // Couldn't open archive - drop through as maybe other method will succeed?
                        $error_string = $za->errorInfo( true );
                        pb_backupbuddy::status( 'details', sprintf( __('pclzip failed to open file to check if file exists (looking for %1$s in %2$s) - Error Info: %3$s.','it-l10n-backupbuddy' ), $locate_file , $zip_file, $error_string ) );

                    }
                                
                } else {
                
                    // Something fishy - the methods indicated pclzip but we couldn't find the class
                    pb_backupbuddy::status( 'details', __('pclzip indicated as available method but class PclZip non-existent','it-l10n-backupbuddy' ) );

                }
                
            }
            
            // If we got this far then no method to check backup content was available or worked
            pb_backupbuddy::status( 'details', sprintf( __('Unable to check if file exists (looking for %1$s in %2$s): No compatible zip method found.','it-l10n-backupbuddy' ), $locate_file, $zip_file ) );
            return false;

        }
        
        
        
        /*    set_comment()
         *    
         *    Retrieve archive comment.
         *    
         *    @param        string            $zip_file        Filename of archive to set comment on.
         *    @param        string            $comment        Comment to apply to archive.
         *    @return        boolean/string                    true on success, error message otherwise.
         */
        function set_comment( $zip_file, $comment ) {
        
            //Use ZipArchive if available
            if ( in_array( 'ziparchive', $this->_zip_methods ) ) {
            
                // Make doubly sure it is available
                if ( class_exists( 'ZipArchive', false ) ) {
                
                    $za = new ZipArchive;
                    $result = $za->open( $zip_file );
                    
                    // Make sure at least the zip file opened ok
                    if ( $result === true ) {
                    
                            // Set the comment - true on success, false on failure
                            $result = $za->setArchiveComment( $comment );
                            $za->close();
                            
                            // If we got back true then all is well with the world
                            if ( $result === true ) {
                            
                                pb_backupbuddy::status( 'details', sprintf( __('ZipArchive set comment in file %1$s','it-l10n-backupbuddy' ), $zip_file ) );
                                return true;
                                
                            } else {
                            
                                // If we failed to set the commnent then log it (?) and drop through
                                pb_backupbuddy::status( 'details', sprintf( __('ZipArchive failed to set comment in file %1$s','it-l10n-backupbuddy' ), $zip_file ) );

                            }
                            
                    } else {
                    
                        // If we couldn't open the zip file then log it (?) and drop through
                        $error_string = $this->ziparchive_error_info( $result );
                        pb_backupbuddy::status( 'details', sprintf( __('ZipArchive failed to open file to set comment in file %1$s - Error Info: %2$s','it-l10n-backupbuddy' ), $zip_file, $error_string ) );
                        
                    }
                                    
                } else {
                
                    // Something fishy - the methods indicated ziparchive but we couldn't find the class
                    pb_backupbuddy::status( 'details', __('ziparchive indicated as available method but ZipArchive class non-existent','it-l10n-backupbuddy' ) );

                }
                
            }
            
            // Dropped through because ZipArchive not available or failed for some reason
            if ( in_array( 'pclzip', $this->_zip_methods ) ) {
            
                // Make sure we have it
                if ( !class_exists( 'PclZip', false ) ) {
                
                    // It's not already loaded so try and find/load it from possible locations
                    if ( file_exists( ABSPATH . 'wp-admin/includes/class-pclzip.php' ) ) {
                    
                        // Running under WordPress
                        @include_once( ABSPATH . 'wp-admin/includes/class-pclzip.php' );
                        
                    } elseif ( file_exists( pb_backupbuddy::plugin_path() . '/lib/pclzip/pclzip.php' ) ) {
                    
                        // Running Standalone (importbuddy)
                        @include_once( pb_backupbuddy::plugin_path() . '/lib/pclzip/pclzip.php' );
                        
                    }
                    
                }
                
                // Make sure we did load it
                if ( class_exists( 'PclZip', false) ) {
                
                    $za = new PclZip( $zip_file );
                    
                    // Make sure we opened the zip ok and we added the comment ok
                    // Note: using empty array as we don't actually want to add any files
                    if ( ( $list = $za->add( array(), PCLZIP_OPT_COMMENT, $comment ) ) !== 0 ) {
                    
                        // We got a list back so adding comment should have been successful
                        pb_backupbuddy::status( 'details', sprintf( __('PclZip set comment in file %1$s','it-l10n-backupbuddy' ), $zip_file ) );
                        return true;
                        
                    } else {
                    
                        // If we failed to set the commnent then log it (?) and drop through
                        $error_string = $za->errorInfo( true );
                        pb_backupbuddy::status( 'details', sprintf( __('PclZip failed to set comment in file %1$s - Error Info: %2$s','it-l10n-backupbuddy' ), $zip_file, $error_string ) );
                        
                    }
                
                } else {
                
                    // Something fishy - the methods indicated pclzip but we couldn't find the class
                    pb_backupbuddy::status( 'details', __('pclzip indicated as available method but class PclZip non-existent','it-l10n-backupbuddy' ) );

                }
                
            }
            
            // We couldn't set a comment at all - either no available method or all methods failed
            pb_backupbuddy::status( 'details', sprintf( __('Unable to set comment in file %1$s: No compatible zip method found or all methods failed - note stored internally only.','it-l10n-backupbuddy' ), $zip_file ) );

            // Return message for display - maybe should return false and have caller display it's own message?
            $message = "\n\nUnable to set note in file.\nThe note will only be stored internally in your settings and not in the zip file itself.";
            return $message;
            
        } // End set_comment().
        
        
        
        /*    get_comment()
         *    
         *    Retrieve archive comment.
         *    
         *    @param        string        $zip_file        Filename of archive to retrieve comment from.
         *    @return        string                        Zip comment.
         */
        function get_comment( $zip_file ) {
        
            // Use ZipArchive if available
            if ( in_array( 'ziparchive', $this->_zip_methods ) ) {
            
                // Make doubly sure it is available
                if ( class_exists( 'ZipArchive', false ) ) {
                
                    $za = new ZipArchive();
                    $result = $za->open( $zip_file );
                    
                    // Make sure that at least the zip file opened ok
                    if ( $result === true ) {
                    
                        // Get the comment or false on failure for some reason
                        $comment = $za->getArchiveComment();
                        $za->close();
                        
                        // If we have a comment (even if empty) then return it
                        if ( $comment !== false ) {
                        
                            // Note: new archives will return an empty comment if one was not added at creation
                            pb_backupbuddy::status( 'details', sprintf( __('ZipArchive retrieved comment in file %1$s','it-l10n-backupbuddy' ), $zip_file ) );

                            // Format has changed and no longer encoding as htmlemtities when setting comment
                            // For older backups may need to remove encoding - action _should_ be null if N/A
                            // Only spanner would be if someone had put an entity in their comment but that is
                            // really an outsider and in any case the correction is simply to edit and resave
                            // TODO: Remove this when new format has been in use for some time
                            $comment = html_entity_decode( $comment );                

                            return $comment;
                            
                        } else {
                        
                            // If we failed to get the commnent then log it (?) and drop through
                            pb_backupbuddy::status( 'details', sprintf( __('ZipArchive failed to retrieve comment in file %1$s','it-l10n-backupbuddy' ), $zip_file ) );

                        }

                    } else {
                    
                        // If we couldn't open the zip file then log it (?) and drop through
                        $error_string = $this->ziparchive_error_info( $result );
                        pb_backupbuddy::status( 'details', sprintf( __('ZipArchive failed to open file to retrieve comment in file %1$s - Error Info: %2$s','it-l10n-backupbuddy' ), $zip_file, $error_string ) );

                    }
                
                } else {
                
                    // Something fishy - the methods indicated ziparchive but we couldn't find the class
                    pb_backupbuddy::status( 'details', __('ziparchive indicated as available method but ZipArchive class non-existent','it-l10n-backupbuddy' ) );

                }
                
            }
            
            // Dropped through because ZipArchive not available or failed for some reason
            if ( in_array( 'pclzip', $this->_zip_methods ) ) {
            
                // Make sure we have it
                if ( !class_exists( 'PclZip', false ) ) {
                
                    // It's not already loaded so try and find/load it from possible locations
                    if ( file_exists( ABSPATH . 'wp-admin/includes/class-pclzip.php' ) ) {
                    
                        // Running under WordPress
                        @include_once( ABSPATH . 'wp-admin/includes/class-pclzip.php' );
                        
                    } elseif ( file_exists( pb_backupbuddy::plugin_path() . '/lib/pclzip/pclzip.php' ) ) {
                    
                        // Running Standalone (importbuddy)
                        @include_once( pb_backupbuddy::plugin_path() . '/lib/pclzip/pclzip.php' );
                        
                    }
                    
                }
                
                // Make sure we did load it
                if ( class_exists( 'PclZip', false) ) {
                
                    $za = new PclZip( $zip_file );
                    
                    // Make sure we opened the zip ok and it has properties
                    if ( ( $properties = $za->properties() ) !== 0 ) {
                    
                        // We got properties so should have a comment to return, even if empty
                        pb_backupbuddy::status( 'details', sprintf( __('PclZip retrieved comment in file %1$s','it-l10n-backupbuddy' ), $zip_file ) );
                        $comment = $properties[ 'comment' ];

                        // Format has changed and no longer encoding as htmlemtities when setting comment
                        // For older backups may need to remove encoding - action _should_ be null if N/A
                        // Only spanner would be if someone had put an entity in their comment but that is
                        // really an outsider and in any case the correction is simply to edit and resave
                        // TODO: Remove this when new format has been in use for some time
                        $comment = html_entity_decode( $comment );
                    
                        return $comment;
                        
                    } else {
                    
                        // If we failed to get the commnent then log it (?) and drop through
                        $error_string = $za->errorInfo( true );
                        pb_backupbuddy::status( 'details', sprintf( __('PclZip failed to retrieve comment in file %1$s - Error Info: %2$s','it-l10n-backupbuddy' ), $zip_file, $error_string ) );
                        
                    }
                
                } else {
                
                    // Something fishy - the methods indicated pclzip but we couldn't find the class
                    pb_backupbuddy::status( 'details', __('pclzip indicated as available method but class PclZip non-existent','it-l10n-backupbuddy' ) );

                }
                
            }
            
            // We couldn't get a comment at all - either no available method or all methods failed
            pb_backupbuddy::status( 'details', __('Unable to get comment: No compatible zip method found.','it-l10n-backupbuddy' ) );
            return false;
            
        } // End get_comment().
        
        
        
        // FOR FUTURE USE; NOT YET IMPLEMENTED. Use to check .sql file is non-empty.
        function file_stats( $zip_file, $locate_file, $leave_open = false ) {
            if ( in_array( 'ziparchive', $this->_zip_methods ) ) {
                $this->_zip = new ZipArchive;
                if ( $this->_zip->open( $zip_file ) === true ) {
                    if ( ( $stats = $this->_zip->statName( $locate_file ) ) === false ) { // File not found in zip.
                        $this->_zip->close();
                        pb_backupbuddy::status( 'details', __('File not found (ziparchive) for stats','it-l10n-backupbuddy' ) . ': ' . $locate_file );
                        return false;
                    }
                    $this->_zip->close();
                    return $stats;
                } else {
                    pb_backupbuddy::status( 'details', sprintf( __('ZipArchive failed to open file to check stats (looking in %1$s).','it-l10n-backupbuddy' ), $zip_file ) );
                    
                    return false;
                }
            }
            
            // If we made it this far then ziparchive not available/failed.
            if ( in_array( 'pclzip', $this->_zip_methods ) ) {
                require_once( ABSPATH . 'wp-admin/includes/class-pclzip.php' );
                $this->_zip = new PclZip( $zip_file );
                if ( ( $file_list = $this->_zip->listContent() ) == 0 ) { // If zero, zip is corrupt or empty.
                    pb_backupbuddy::status( 'details', $this->_zip->errorInfo( true ) );
                } else {
                    foreach( $file_list as $file ) {
                        if ( $file['filename'] == $locate_file ) { // Found file.
                            return true;
                        }
                    }
                    pb_backupbuddy::status( 'details', __('File not found (pclzip)','it-l10n-backupbuddy' ) . ': ' . $locate_file );
                    return false;
                }
            } else {
                pb_backupbuddy::status( 'details', __('Unable to check if file exists: No compatible zip method found.','it-l10n-backupbuddy' ) );
                return false;
            }
        }
        
        
        
        /*    get_zip_methods()
         *    
         *    Get an array of the zip methods. Useful for transient caching for constructor.
         *    
         *    @return        array        Array of methods.
         */
        public function get_zip_methods() {
            $this->_zip_methods;
        } // End get_zip_methods();
        
        
        
        /**
         *    add_directory_to_zip()
         *
         *    Adds a directory to a new or existing (TODO: not yet available) ZIP file.
         *
         *    $zip_file                    string                        Full path & filename of ZIP file to create.
         *    $add_directory                string                        Full directory to add to zip file.
         *    $compression                boolean                        True to enable ZIP compression,
         *                                                            (if possible with available zip methods)
         *    $excludes                    array(strings)                Array of strings of paths/files to exclude from zipping,
         *                                                            (if possible with available zip methods).
         *    $temporary_zip_directory    string                        Optional. Full directory path to directory to temporarily place ZIP
         *                                                            file while creating. Uses same directory if omitted.
         *    $force_compatibility_mode    boolean                        True: only use PCLZip. False: try exec first if available,
         *                                                            and fallback to lesser methods as required.
         *
         *    @return                                                    true on success, false otherwise
         *
         */
        function add_directory_to_zip( $zip_file, $add_directory, $compression, $excludes = array(), $temporary_zip_directory = '', $force_compatibility_mode = false ) {
            if ( $force_compatibility_mode === true ) {
                $zip_methods = array( 'pclzip' );
                pb_backupbuddy::status( 'message', __('Forced compatibility mode (PCLZip) based on settings. This is slower and less reliable.','it-l10n-backupbuddy' ) );
            } else {
                $zip_methods = $this->_zip_methods;
                pb_backupbuddy::status( 'details', __('Using all available zip methods in preferred order.','it-l10n-backupbuddy' ) );
            }
            
            $append = false; // Possible future option to allow appending if file exists.
            
            // Normalize $temporary_zip_directory to format: /xxx/yyy/zzz/.
            $temporary_zip_directory = rtrim( $temporary_zip_directory, '/\\' ) . '/';
            
            if ( !empty( $temporary_zip_directory ) ) {
                if ( !file_exists( $temporary_zip_directory ) ) { // Create temp dir if it does not exist.
                    mkdir( $temporary_zip_directory );
                }
            }
            
            if ( is_array( $excludes ) ) {
                $excludes_text = implode( ',', $excludes );
            } else {
                $excludes_text = '(in file: `' . $excludes . '`)';
            }
            pb_backupbuddy::status( 'details', __('Creating ZIP file','it-l10n-backupbuddy' ) . ' `' . $zip_file . '`. ' . __('Adding directory','it-l10n-backupbuddy' ) . ' `' . $add_directory . '`. ' . __('Compression','it-l10n-backupbuddy' ) . ': ' . $compression . '; ' . __('Excludes','it-l10n-backupbuddy' ) . ': ' . $excludes_text );
            unset( $excludes_text );
            
            if ( in_array( 'exec', $zip_methods ) ) {
                pb_backupbuddy::status( 'details', __('Using exec() method for ZIP.','it-l10n-backupbuddy' ) );
                
                $command = 'zip -q -r';
                
                if ( $compression !== true ) {
                    $command .= ' -0';
                    pb_backupbuddy::status( 'details', __('Exec compression disabled based on settings.','it-l10n-backupbuddy' ) );
                }
                if ( file_exists( $zip_file ) ) {
                    if ( $append === true ) {
                        pb_backupbuddy::status( 'details', __('ZIP file exists. Appending based on options.','it-l10n-backupbuddy' ) );
                        $command .= ' -g';
                    } else {
                        pb_backupbuddy::status( 'details', __('ZIP file exists. Deleting & writing based on options.','it-l10n-backupbuddy' ) );
                        unlink( $zip_file );
                    }
                }
                
                //$command .= " -r";
                
                // Set temporary directory to store ZIP while it's being generated.
                if ( !empty( $temporary_zip_directory ) ) {
                    $command .= " -b '{$temporary_zip_directory}'";
                }
                
                $command .= " '{$zip_file}' .";
                // -i '*'"; // Not needed. Zip defaults to doing this. Removed July 10, 2012 for v3.0.41.
                
                                
                // Handle exclusions by placing them in an exclusion text file.
                $exclusion_file = $temporary_zip_directory . 'exclusions.txt';
                $this->_render_exclusions_file( $exclusion_file, $excludes );
                pb_backupbuddy::status( 'details', 'Using exclusion file `' . $exclusion_file . '`.' );
                $command .= ' -x@' . "'{$exclusion_file}'";
                
                
                $command .= ' 2>&1'; //  2>&1 redirects STDERR to STDOUT
                
                $working_dir = getcwd();
                chdir( $add_directory ); // Change directory to the path we are adding.
                
                if ( $this->_execpath != '' ) {
                    pb_backupbuddy::status( 'details', __( 'Using custom exec() path: ', 'it-l10n-backupbuddy' ) . $this->_execpath );
                }
                
                // Run ZIP command.
                if ( stristr( PHP_OS, 'WIN' ) && !stristr( PHP_OS, 'DARWIN' ) ) { // Running Windows. (not darwin)
                    if ( file_exists( ABSPATH . 'zip.exe' ) ) {
                        pb_backupbuddy::status( 'message', __('Attempting to use provided Windows zip.exe.','it-l10n-backupbuddy' ) );
                        $command = str_replace( '\'', '"', $command ); // Windows wants double quotes
                        $command = ABSPATH . $command;
                    }
                    
                    pb_backupbuddy::status( 'details', __('Exec command (Windows)','it-l10n-backupbuddy' ) . ': ' . $command );
                    list( $exec_output, $exec_exit_code ) = $this->_commandbuddy->execute( $this->_execpath . $command );
                } else { // Allow exec warnings not in Windows
                    pb_backupbuddy::status( 'details', __('Exec command (Linux)','it-l10n-backupbuddy' ) . ': ' . $command );
                    list( $exec_output, $exec_exit_code ) = $this->_commandbuddy->execute( $this->_execpath . $command );
                }
                
                
                // Cleanup exclusions file if it exists.
                if ( file_exists( $temporary_zip_directory . 'exclusions.txt' ) ) {
                    @unlink( $temporary_zip_directory . 'exclusions.txt' );
                }
                
                
                sleep( 1 );
                
                // We may not have a zip file or we may have one but there was error/warning when producing it
                // Note: In event of warnings we could still get a zip file if the script terminates whilst zip command still running
                
                if ( ( ! file_exists( $zip_file ) ) || ( $exec_exit_code != 0 ) ) {
                    
                    // Log the failure
                    pb_backupbuddy::status( 'message', __( 'Full speed mode did not complete. Trying compatibility mode next.','it-l10n-backupbuddy' ) );
                    
                    // Check whether a zip file was actually produced in the backups directory (as opposed to the temp zip directory)
                    if ( ! file_exists( $zip_file ) ) {
                    
                        pb_backupbuddy::status( 'details', __( 'Exec command ran but ZIP file did not exist.','it-l10n-backupbuddy' ) );
                        
                    }
                    
                    // We did get a zip file but cannot truest it so must delete it
                    if ( file_exists( $zip_file ) ) {
                    
                        pb_backupbuddy::status( 'details', __( 'Cleaning up damaged ZIP file. Issue #3489328998.','it-l10n-backupbuddy' ) );
                        unlink( $zip_file );
                        
                    }
                    
                    // Need to clean up any temporary zip directory
                    if ( file_exists( $temporary_zip_directory ) ) {
                    
                        pb_backupbuddy::status( 'details', __( 'Cleaning up incomplete temporary ZIP file. Issue #343894.','it-l10n-backupbuddy' ) );
                        if ( !( $this->delete_directory_recursive( $temporary_zip_directory ) ) ) {
                        
                            pb_backupbuddy::status( 'details', __( 'Unable to delete temporary zip directory','it-l10n-backupbuddy' ) );
                        
                        }
                        
                    }
                    
                } else {
                
                    // We got a zip file and no errors/warnings so good to go
                    pb_backupbuddy::status( 'message', __( 'Full speed mode completed & generated ZIP file.','it-l10n-backupbuddy' ) );
                    if ( !( $this->delete_directory_recursive( $temporary_zip_directory ) ) ) {
                    
                        pb_backupbuddy::status( 'details', __( 'Unable to delete temporary zip directory','it-l10n-backupbuddy' ) );
                    
                    }
                    
                    return true;
                    
                }
                
                chdir( $working_dir );
                
                unset( $command );
                unset( $exclude );
                unset( $excluding_additional );
                
                pb_backupbuddy::status( 'details', __('Exec command did not succeed. Falling back.','it-l10n-backupbuddy' ) );
                
            }
            
            if ( in_array( 'pclzip', $zip_methods ) ) {
                pb_backupbuddy::status( 'message', __('Using Compatibility Mode for ZIP. This is slower and less reliable.','it-l10n-backupbuddy' ) );
                pb_backupbuddy::status( 'message', __('If your backup times out in compatibility mode try disabled zip compression.','it-l10n-backupbuddy' ) );
                pb_backupbuddy::status( 'message', __('WARNING: Directory/file exclusion unavailable in Compatibility Mode. Even existing old backups will be backed up.','it-l10n-backupbuddy' ) );
                
                require_once( ABSPATH . 'wp-admin/includes/class-pclzip.php' );
                
                // Determine zip file name / path.
                if ( !empty( $temporary_zip_directory ) ) {
                    $pclzip_file = $temporary_zip_directory . basename( $zip_file );
                } else {
                    $pclzip_file = $zip_file;
                }
                
                if ( !file_exists( dirname( $pclzip_file ) ) ) {
                    pb_backupbuddy::status( 'details', 'Creating PCLZip file directory `' . dirname( $pclzip_file ) . '`.' );
                    mkdir( dirname( $pclzip_file ) );
                }
                
                // Instantiate PclZip Object.
                pb_backupbuddy::status( 'details', 'PclZip zip filename: `' . $pclzip_file . '`.' );
                $pclzip = new PclZip( $pclzip_file );
                
                if ( $compression !== true ) {
                    pb_backupbuddy::status( 'details', __('PCLZip compression disabled based on settings.','it-l10n-backupbuddy' ) );
                    $arguments = array( $add_directory, PCLZIP_OPT_NO_COMPRESSION, PCLZIP_OPT_REMOVE_PATH, $add_directory );
                } else {
                    pb_backupbuddy::status( 'details', __('PCLZip compression enabled based on settings.','it-l10n-backupbuddy' ) );
                    $arguments = array( $add_directory, PCLZIP_OPT_REMOVE_PATH, $add_directory );
                }
                
                $mode = 'create';
                if ( file_exists( $zip_file ) && ( $append === true ) ) {
                    pb_backupbuddy::status( 'details', __('ZIP file exists. Appending based on options.','it-l10n-backupbuddy' ) );
                    $mode = 'append';
                }
                
                if ( $mode == 'append' ) {
                    pb_backupbuddy::status( 'details', __('Appending to ZIP file via PCLZip.','it-l10n-backupbuddy' ) );
                    $retval = call_user_func_array( array( &$pclzip, 'add' ), $arguments );
                } else { // create
                    pb_backupbuddy::status( 'details', __( 'Creating ZIP file via PCLZip','it-l10n-backupbuddy' ) . ':' . implode( ';', $arguments ) );
                    //error_log( 'pclzip args: ' . print_r( $arguments, true ) . "\n" );
                    $retval = call_user_func_array( array( &$pclzip, 'create' ), $arguments );
                }
                
                // Move the zip file if we were creating it in a temporary directory
                if ( !empty( $temporary_zip_directory ) ) {
                    if ( file_exists( $temporary_zip_directory . basename( $zip_file ) ) ) {
                        pb_backupbuddy::status( 'details', __('Renaming PCLZip File...','it-l10n-backupbuddy' ) );
                        rename( $temporary_zip_directory . basename( $zip_file ), $zip_file );
                        if ( file_exists( $zip_file ) ) {
                            pb_backupbuddy::status( 'details', __('Renaming PCLZip success.','it-l10n-backupbuddy' ) );
                        } else {
                            pb_backupbuddy::status( 'details', __('Renaming PCLZip failure.','it-l10n-backupbuddy' ) );
                        }
                    } else {
                        pb_backupbuddy::status( 'details', __('Temporary PCLZip archive file expected but not found. Please verify permissions on the ZIP archive directory.','it-l10n-backupbuddy' ) );
                    }
                }
                
                // Work out whether we have a problem or not
                if ( is_array( $retval ) ) {
                
                    // It's an array so a good result
                    $exitcode = 0;
                
                } else {
                
                    // Not an array so a bad error code
                    $exitcode = $pclzip->errorCode();
                
                }
                
                // Convenience for handling different scanarios
                $result = false;
                
                // See if we can figure out what happened - note that $exitcode could be non-zero for a warning or error
                // There may be no zip file at all if there was a problem creating it or it may be left in the temp
                // directory if it couldn't be moved
                if ( ( ! file_exists( $zip_file ) ) || ( $exitcode != 0 ) ) {
                
                    // If we had a non-zero exit code then should report it (file may or may not be created)
                    if ( $exitcode != 0 ) {
                    
                        pb_backupbuddy::status( 'details', __('Zip process exit code: ','it-l10n-backupbuddy' ) . $exitcode );
                        
                    }
    
                    // Report whether or not the zip file was created                
                    if ( ! file_exists( $zip_file ) ) {
                    
                        pb_backupbuddy::status( 'details', __( 'Zip Archive file not created - check process exit code.','it-l10n-backupbuddy' ) );
                        
                    } else {
                        
                        pb_backupbuddy::status( 'details', __( 'Zip Archive file created but will be removed - check process exit code.','it-l10n-backupbuddy' ) );
    
                        @unlink( $zip_file );
                        
                    }
                    
                    // Put the error information into an array for consistency
                    $zip_output[] = $pclzip->errorInfo( true );
                    
                    // Now we don't move it (because either it doesn't exist or may be incomplete) but we'll show any error/wartning output
                    if ( !empty( $zip_output ) ) {
                    
                        // Assume we don't have a lot of lines for now - could be risky assumption!
                        foreach ( $zip_output as $line ) {
                        
                            pb_backupbuddy::status( 'details', __( 'Zip process reported: ','it-l10n-backupbuddy' ) . $line );
                        
                        }
                    
                        // Extra details for particular error
                        if ( false !== strpos( $pclzip->errorInfo( true ), 'PCLZIP_ERR_READ_OPEN_FAIL' ) ) {
                            pb_backupbuddy::status( 'details', __( 'PCLZIP_ERR_READ_OPEN_FAIL details: This error indicates that fopen failed (returned false) when trying to open the file in the mode specified. This is almost always due to permissions.', 'it-l10n-backupbuddy' ) );
                        }
                                        
                    }
                    
                    // One way or another we failed
                    $result = false;
                    
                } else {
                
                    // Got file with no error or warnings at all so it should be good to go
                    
                    if ( file_exists( $zip_file ) ) {
                    
                        pb_backupbuddy::status( 'details', __('Zip Archive file moved to local archive directory.','it-l10n-backupbuddy' ) );
                        pb_backupbuddy::status( 'message', __( 'Zip Archive file successfully created with no errors or warnings.','it-l10n-backupbuddy' ) );
                        $result = true;
                        
                    } else {
                    
                        pb_backupbuddy::status( 'details', __('Zip Archive file could not be moved to local archive directory.','it-l10n-backupbuddy' ) );
                        $result = false;
                        
                    }
                                    
                }            
    
                if ( !empty( $temporary_zip_directory ) ) {
                
                    // Cleanup the temporary directory that will have all detritus and maybe incomplete zip file            
                    pb_backupbuddy::status( 'details', __('Removing temporary directory.','it-l10n-backupbuddy' ) );
                    
                    if ( !( $this->delete_directory_recursive( $temporary_zip_directory ) ) ) {
                    
                            pb_backupbuddy::status( 'details', __('Temporary directory could not be deleted: ','it-l10n-backupbuddy' ) . $temporary_zip_directory );
                    
                    }
                
                }
                
                if ( $result ) return $result;
                
            }
            
            // If we made it this far then something didnt result in a success.
            return false;
        }
        
        
        
        /**
         *    unzip()
         *
         *    Extracts the contents of a zip file to the specified directory using the best unzip methods possible.
         *
         *    $zip_file                    string        Full path & filename of ZIP file to create.
         *    $destination_directory        string        Full directory path to extract into.
         *    $force_compatibility_mode    mixed        false (default): use best methods available (zip exec first), falling back as needed.
         *                                            ziparchive: first fallback method. (Medium performance)
         *                                            pclzip: second fallback method. (Worst performance; buggy)
         *
         *    @return``                                true on success, false otherwise
         */
        function unzip( $zip_file, $destination_directory, $force_compatibility_mode = false ) {
            
            $destination_directory = rtrim( $destination_directory, '\\/' ) . '/'; // Make sure trailing slash exists to normalize.
            
            if ( $force_compatibility_mode == 'ziparchive' ) {
                $zip_methods = array( 'ziparchive' );
                pb_backupbuddy::status( 'message', __('Forced compatibility mode (ZipArchive; medium speed) based on settings. This is slower and less reliable.','it-l10n-backupbuddy' ) );
            } elseif ( $force_compatibility_mode == 'pclzip' ) {
                $zip_methods = array( 'pclzip' );
                pb_backupbuddy::status( 'message', __('Forced compatibility mode (PCLZip; slow speed) based on settings. This is slower and less reliable.','it-l10n-backupbuddy' ) );
            } else {
                $zip_methods = $this->_zip_methods;
                pb_backupbuddy::status( 'details', __('Using all available zip methods in preferred order.','it-l10n-backupbuddy' ) );
            }
            
            if ( in_array( 'exec', $zip_methods ) ) {
                pb_backupbuddy::status( 'details',  'Starting highspeed extraction (exec)... This may take a moment...' );
                
                $command = 'unzip -qo'; // q = quiet, o = overwrite without prompt.
                $command .= " '$zip_file' -d '$destination_directory' -x 'importbuddy.php'"; // x excludes importbuddy script to prevent overwriting newer importbuddy on extract step.
            
                // Handle windows.
                if ( stristr( PHP_OS, 'WIN' ) && !stristr( PHP_OS, 'DARWIN' ) ) { // Running Windows. (not darwin)
                    if ( file_exists( ABSPATH . 'unzip.exe' ) ) {
                        pb_backupbuddy::status( 'details',  'Attempting to use Windows unzip.exe.' );
                        $command = str_replace( '\'', '"', $command ); // Windows wants double quotes
                        $command = ABSPATH . $command;
                    }
                }
                
                $command .= '  2>&1'; // Redirect STDERR to STDOUT.
                
                if ( $this->_execpath != '' ) {
                    pb_backupbuddy::status( 'details', __( 'Using custom exec() path: ', 'it-l10n-backupbuddy' ) . $this->_execpath );
                }
                
                pb_backupbuddy::status( 'details', 'Running ZIP command. This may take a moment.' );
                list( $exec_output, $exec_exit_code ) = $this->_commandbuddy->execute( $this->_execpath . $command );
                
                $failed = false; // Default.
                
                if ( !file_exists( $destination_directory . 'wp-login.php' ) && !file_exists( $destination_directory . 'db_1.sql' ) && !file_exists( $destination_directory . 'wordpress/wp-login.php' ) ) { // wp-login.php for WordPress, db_1.sql for DB backup, wordpress/wp-login.php for fresh WordPress downloaded from wp.org for MS export
                    pb_backupbuddy::status( 'error', 'Both wp-login.php (full backups) and db_1.sql (database only backups) are missing after extraction. Unzip process appears to have failed.' );
                    $failed = true;
                }
                
                if ( $exec_exit_code != '0' ) {
                    pb_backupbuddy::status( 'error',  'Exit code `' . $exec_exit_code . '` indicates a problem was encountered.' );
                    $failed = true;
                }
                
                // Sometimes exec returns success codes but never extracted actual files. Do a check to make sure known files were extracted to verify against that.
                if ( $failed === false ) {
                    pb_backupbuddy::status( 'message', 'File extraction complete.' );
                    return true;
                } else {
                    pb_backupbuddy::status( 'message',  'Falling back to next compatibility mode.' );
                }
            }
            
            if ( in_array( 'ziparchive', $zip_methods ) ) {
                pb_backupbuddy::status( 'details',  'Starting medium speed extraction (ziparchive)... This may take a moment...' );
                
                $zip = new ZipArchive;
                if ( $zip->open( $zip_file ) === true ) {
                    if ( true === $zip->extractTo( $destination_directory ) ) {
                        pb_backupbuddy::status( 'details',  'ZipArchive extraction success.' );
                        $zip->close();
                        return true;
                    } else {
                        $zip->close();
                        pb_backupbuddy::status( 'message',  'Error: ZipArchive was available but failed extracting files.  Falling back to next compatibility mode.' );
                    }
                } else {
                    pb_backupbuddy::status( 'message',  'Error: Unable to open zip file via ZipArchive. Falling back to next compatibility mode.' );
                }
            }
            
            if ( in_array( 'pclzip', $zip_methods ) ) {
                pb_backupbuddy::status( 'details',  'Starting low speed extraction (pclzip)... This may take a moment...' );
                
                if ( !class_exists( 'PclZip' ) ) {
                    $pclzip_file = pb_backupbuddy::plugin_path() . '/lib/pclzip/pclzip.php';
                    pb_backupbuddy::status( 'details', 'PCLZip class not found. Attempting to load from `' . $pclzip_file . '`.' );
                    if ( file_exists( $pclzip_file ) ) {
                        pb_backupbuddy::status( 'details', 'Loading `' . $pclzip_file . '`.' );
                        require_once( $pclzip_file );
                    } else {
                        pb_backupbuddy::status( 'details', 'PCLZip file not found: `' . $pclzip_file . '`.' );
                    }
                }
                
                $archive = new PclZip( $zip_file );
                $result = $archive->extract(); // Extract to current directory. Explicity using PCLZIP_OPT_PATH results in extraction to a PCLZIP_OPT_PATH subfolder.
                
                if ( 0 == $result ) {
                    pb_backupbuddy::status( 'details',  'PCLZip Failure: ' . $archive->errorInfo( true ) );
                    pb_backupbuddy::status( 'message',  'Low speed (PCLZip) extraction failed.', $archive->errorInfo( true ) );
                } else {
                    return true;
                }
            }
            
            // Nothing succeeded if we made it this far...
            return false;
        }
        
        
        
        // Test availability of ZipArchive and that it actually works.
        function test_ziparchive() {
            if ( class_exists( 'ZipArchive' ) ) {
                $test_file = $this->_tempdir . 'temp_test_' . uniqid() . '.zip';
                
                $zip = new ZipArchive;
                if ( $zip->open( $test_file, ZIPARCHIVE::CREATE | ZIPARCHIVE::OVERWRITE ) === true ) {
                    $zip->addFile( __FILE__, 'this_is_a_test.txt');
                    $zip->close();
                    if ( file_exists( $test_file ) ) {
                        unlink( $test_file );
                        pb_backupbuddy::status( 'details', __('ZipArchive test passed.','it-l10n-backupbuddy' ) );
                        return true;
                    } else {
                        pb_backupbuddy::status( 'details', __('ZipArchive test failed: Zip file not found.','it-l10n-backupbuddy' ) );
                        return false;
                    }
                } else {
                    pb_backupbuddy::status( 'details', __('ZipArchive test FAILED: Unable to create/open zip file.','it-l10n-backupbuddy' ) );
                    return false;
                }
            }
        }
        
        
        
        /*    get_file_list()
         *    
         *    Get an array of all files in a zip file.
         *    
         *    @param        
         *    @return        array    
         */
        public function get_file_list( $zip_file ) {
        
            $file_list = array();
            
            // Use ZipArchive if available
            if ( in_array( 'ziparchive', $this->_zip_methods ) ) {
            
                // Make doubly sure it is available
                if ( class_exists( 'ZipArchive', false) ) {
                
                    $za = new ZipArchive();
                    $result = $za->open( $zip_file );
                    
                    // Make sure we opened the zip ok and it has content
                    if ( $result === true ) {
                    
                        if ( ( $file_count = $za->numFiles ) > 0 ) {
                    
                            // Get each file in sequence by index and get the properties
                            for( $i = 0; $i < $file_count; $i++ ){
                            
                                $stat = $za->statIndex( $i );
                                
                                // Assume all these keys do exist (consider testing)
                                $file_list[] = array(
                                    $stat['name'],
                                    $stat['size'],
                                    $stat['comp_size'],
                                    $stat['mtime'],
                                );
                                
                            }
                            
                        }
                        
                        $za->close();
                        
                        return $file_list;
                        
                    } else {
                    
                        // Couldn't open archive - drop through as maybe other method will succeed?
                        $error_string = $this->ziparchive_error_info( $result );
                        pb_backupbuddy::status( 'details', sprintf( __('ZipArchive failed to open file to list content in file %1$s - Error Info: %2$s.','it-l10n-backupbuddy' ), $zip_file, $error_string ) );
                    
                    }
                
                } else {
                
                    // Something fishy - the methods indicated ziparchive but we couldn't find the class
                    pb_backupbuddy::status( 'details', __('ziparchive indicated as available method but ZipArchive class non-existent','it-l10n-backupbuddy' ) );
                
                }
                
            }
            
            // Dropped through because ZipArchive not available or failed to open file
            if ( in_array( 'pclzip', $this->_zip_methods ) ) {
            
                // Make sure we have it
                if ( !class_exists( 'PclZip', false ) ) {
                
                    // It's not already loaded so try and find/load it from possible locations
                    if ( file_exists( ABSPATH . 'wp-admin/includes/class-pclzip.php' ) ) {
                    
                        // Running under WordPress
                        @include_once( ABSPATH . 'wp-admin/includes/class-pclzip.php' );
                        
                    } elseif ( file_exists( pb_backupbuddy::plugin_path() . '/lib/pclzip/pclzip.php' ) ) {
                    
                        // Running Standalone (importbuddy)
                        @include_once( pb_backupbuddy::plugin_path() . '/lib/pclzip/pclzip.php' );
                        
                    }
                    
                }
                
                // Make sure we did load it
                if ( class_exists( 'PclZip', false ) ) {
                
                    $za = new PclZip( $zip_file );
                    
                    // Make sure we opened the zip ok and it has content
                    if ( ( $content_list = $za->listContent() ) !== 0 ) {
                    
                        $file_count = sizeof( $content_list );
                        
                        // Get each file in sequence by index and get the properties
                        for ( $i = 0; $i < $file_count; $i++ ) {
                        
                            $stat = $content_list[ $i ];
                            
                            // Assume all these keys do exist (consider testing)
                            $file_list[] = array(
                                $stat[ 'filename' ],
                                $stat[ 'size' ],
                                $stat[ 'compressed_size' ],
                                $stat[ 'mtime' ]
                            );
                            
                        }
                        
                        return $file_list;

                    } else {
                    
                        // Couldn't open archive - drop through as maybe other method will succeed?
                        $error_string = $za->errorInfo( true );
                        pb_backupbuddy::status( 'details', sprintf( __('PclZip failed to open file to list content in file %1$s - Error Info: %2$s.','it-l10n-backupbuddy' ), $zip_file, $error_string ) );
                    
                    }
                    
                } else {
                
                    // Something fishy - the methods indicated pclzip but we couldn't find the class
                    pb_backupbuddy::status( 'details', __('pclzip indicated as available method but class PclZip non-existent','it-l10n-backupbuddy' ) );
                
                }
            
            }
            
            // If we got this far then no method to list backup content was available or worked
            return false;
            
        } // End get_file_list().
        
        
                                
        /*    available_zip_methods()
         *    
         *    Test availability of zip methods to determine which exist and actually work.
         *    Detects the available zipping methods on this server. Tests command line zip via exec(), PHP's ZipArchive, or emulated zip via the PHP PCLZip library.
         *    TODO: Actually test unzipping in unzip mode not just zipping and assuming the other will work
         *    
         *    @param        boolean        $return_best    
         *    @param        string        $mode            Possible values: zip, unzip
         *    @return        array                        Possible return values: exec, ziparchive, pclzip
         */
        function available_zip_methods( $return_best = true, $mode = 'zip' ) {
            $return = array();
            $test_file = $this->_tempdir . 'temp_' . uniqid() . '.zip';
            
            // Test command-line ZIP.
            if ( function_exists( 'exec' ) ) {
                $command = 'zip';
                $run_exec_zip_test = true;
                
                // Handle windows.
                if ( stristr( PHP_OS, 'WIN' ) && !stristr( PHP_OS, 'DARWIN' ) ) { // Running Windows. (not darwin)
                    if ( file_exists( ABSPATH . 'zip.exe' ) ) {
                        $command = ABSPATH . $command;
                    }
                    // If unzip mode and unzip.exe is found then assume we have that option for unzipping since we arent actually testing unzip.
                    if ( $mode == 'unzip' ) {
                        $run_exec_zip_test = false;
                        if ( file_exists( ABSPATH . 'unzip.exe' ) ) {
                            array_push( $return, 'exec' );
                        }
                    }
                    
                    $exec_paths = array( '' );
                } else { // *NIX system.
                    $exec_paths = array( '', '/usr/bin/', '/usr/local/bin/', '/usr/local/sbin/', '/usr/sbin/', '/sbin/', '/bin/' ); // Include preceeding & trailing slash.
                }
                
                if ( $run_exec_zip_test === true ) {
                    // Possible locations to find the ZIP executable. Start with a blank string to attempt to run in current directory.
                    
                    pb_backupbuddy::status( 'details', 'Trying exec() in the following paths: `' . implode( ',', $exec_paths ) . '`' );
                    
                    $exec_completion = false; // default state.
                    while( $exec_completion === false ) { // Check all possible zip path locations starting with current dir. Usually the path is set to make this work without hunting.
                        if ( empty( $exec_paths ) ) {
                            $exec_completion = true;
                            pb_backupbuddy::status( 'error', __( 'Exhausted all known exec() path possibilities with no success.', 'it-l10n-backupbuddy' ) );
                            break;
                        }
                        $path = array_shift( $exec_paths );
                        pb_backupbuddy::status( 'details', __( 'Trying exec() ZIP path:', 'it-l10n-backupbuddy' ) . ' `' . $path . '`.' );
                        
                        $exec_command = $path . $command . ' "' . $test_file . '" "' . __FILE__ . '"  2>&1'; //  2>&1 to redirect STRERR to STDOUT.
                        pb_backupbuddy::status( 'details', 'Zip test exec() command: `' . $exec_command . '`' );
                        list( $exec_output, $exec_exit_code ) = $this->_commandbuddy->execute( $exec_command );
                        
                        if ( ( !file_exists( $test_file ) ) || ( $exec_exit_code == '-1' ) ) { // File not made or error returned.
                            $exec_completion = false;
                            
                            if ( $exec_exit_code == '-1' ) {
                                pb_backupbuddy::status( 'details', __( 'Exec command returned -1.', 'it-l10n-backupbuddy' ) );
                            }
                            if ( !file_exists( $test_file ) ) {
                                pb_backupbuddy::status( 'details', __( 'Exec command ran but ZIP file did not exist.', 'it-l10n-backupbuddy' ) );
                            }
                            if ( file_exists( $test_file ) ) { // If file was somehow created, do cleanup on it.
                                pb_backupbuddy::status( 'details', __( 'Cleaning up damaged ZIP file. Issue #3489328998.', 'it-l10n-backupbuddy' ) );
                                unlink( $test_file );
                            }
                        } else { // Success.
                            $exec_completion = true;
                            
                            if ( !unlink( $test_file ) ) {
                                echo sprintf( __( 'Error #564634. Unable to delete test file (%s)!', 'it-l10n-backupbuddy' ), $test_file );
                            }
                            array_push( $return, 'exec' );
                            $this->_execpath = $path;
                            
                            break;
                        }
                    } // end while
                } // End $run_exec_test === true.
            } // End function_exists( 'exec' ).
            
            // Test ZipArchive
            if ( class_exists( 'ZipArchive' ) ) {
                if ( $this->test_ziparchive() === true ) {
                    array_push( $return, 'ziparchive' );
                }
            }
            
            // Test PCLZip
            if ( class_exists( 'PclZip' ) ) { // Class already loaded.
                array_push( $return, 'pclzip' );
            } else { // Class not loaded. Seek it out.
                
                if ( file_exists( ABSPATH . 'wp-admin/includes/class-pclzip.php' ) ) { // Inside WP.
                    require_once( ABSPATH . 'wp-admin/includes/class-pclzip.php' );
                    array_push( $return, 'pclzip' );
                } elseif ( file_exists( pb_backupbuddy::plugin_path() . '/lib/pclzip/pclzip.php' ) ) { // ImportBuddy.
                    require_once( pb_backupbuddy::plugin_path() . '/lib/pclzip/pclzip.php' );
                    array_push( $return, 'pclzip' );
                }
                
            }
            
            return $return;
        } // End available_zip_methods().
        
        
        
        // Recursively delete a directory and all content within.
        function delete_directory_recursive( $directory ) {
            $directory = preg_replace( '|[/\\\\]+$|', '', $directory );
            
            $files = glob( $directory . '/*', GLOB_MARK );
            if ( is_array( $files ) && !empty( $files ) ) {
                foreach( $files as $file ) {
                    if( '/' === substr( $file, -1 ) )
                        $this->delete_directory_recursive( $file );
                    else
                        unlink( $file );
                }
            }
            
            if ( is_dir( $directory ) ) rmdir( $directory );
            
            if ( is_dir( $directory ) )
                return false;
            return true;
        } // End delete_directory_recursive().
        
        
        
        function set_zip_methods( $methods ) {
            $this->_zip_methods = $methods;
        } // End set_zip_methods().
        
        
        
        /*    _render_exclusions_file()
         *    
         *    function description
         *    
         *    @param        string        $file            File to write exclusions into.
         *    @param        array        $exclusions        Array of directories/paths to exclude. One per line.
         *    @return        null
         */
        public function _render_exclusions_file( $file, $exclusions ) {
        
            // Array for cleaned up exclusions list
            $sanitized_exclusions = array();
            
            pb_backupbuddy::status( 'details', 'Creating backup exclusions file `' . $file . '`.' );
            //$exclusions = backupbuddy_core::get_directory_exclusions();
            
            // Test each exclusion for validity (presence) and drop those not actually present
            foreach( $exclusions as $exclusion ) {
                
                // Make sure platform specific directory separators are used (could have migrated from different platform)
                $exclusion = preg_replace( '|[' . addslashes( self::DIRECTORY_SEPARATORS ) . ']+|', DIRECTORY_SEPARATOR, $exclusion );
                
                // DIRECTORY.
                if ( is_dir( ABSPATH . ltrim( $exclusion, DIRECTORY_SEPARATOR ) ) ) {
                    
                    pb_backupbuddy::status( 'details', 'Excluding directory `' . $exclusion . '`.' );
                    
                    // Need to add the wildcard so that zip will exclude the directory and content
                    $exclusion = rtrim( $exclusion, DIRECTORY_SEPARATOR ) . DIRECTORY_SEPARATOR . '*';
                
                // FILE.
                } elseif ( is_file( ABSPATH . ltrim( $exclusion, DIRECTORY_SEPARATOR ) ) ) {
                    
                    pb_backupbuddy::status( 'details', 'Excluding file `' . $exclusion . '`.' );
                
                // SYMBOLIC LINK.
                } elseif ( is_link( ABSPATH . ltrim( $exclusion, DIRECTORY_SEPARATOR ) ) ) {
                    
                    pb_backupbuddy::status( 'details', 'Excluding symbolic link `' . $exclusion . '`.' );
                
                // DOES NOT EXIST.
                } else {
                    
                    pb_backupbuddy::status( 'details', 'Omitting exclusion as file/directory does not currently exist: `' . $exclusion . '`.' );
                    
                    // Skip to next exclusion
                    continue;
                    
                }
                
                // We have a valid exclude so add it
                $sanitized_exclusions[] = $exclusion;
                
            }
            
            // Put the exclusions to a file as a string
            file_put_contents( $file, implode( PHP_EOL, $sanitized_exclusions ) . PHP_EOL );
            pb_backupbuddy::status( 'details', 'Backup exclusions file created.' );
            
        } // End render_exclusions_file().
        
        
        
    } // End class
    
}
?>