Make WordPress Core

Ticket #7875: 7875.diff

File 7875.diff, 52.5 KB (added by DD32, 13 years ago)
  • wp-admin/includes/class-wp-filesystem-base.php

     
    4646         * @return string The location of the remote path.
    4747         */
    4848        function abspath() {
    49                 if ( defined('FTP_BASE') && strpos($this->method, 'ftp') !== false )
    50                         return FTP_BASE;
    5149                $folder = $this->find_folder(ABSPATH);
    5250                //Perhaps the FTP folder is rooted at the WordPress install, Check for wp-includes folder in root, Could have some false positives, but rare.
    5351                if ( ! $folder && $this->is_dir('/wp-includes') )
     
    6260         * @return string The location of the remote path.
    6361         */
    6462        function wp_content_dir() {
    65                 if ( defined('FTP_CONTENT_DIR') && strpos($this->method, 'ftp') !== false )
    66                         return FTP_CONTENT_DIR;
    6763                return $this->find_folder(WP_CONTENT_DIR);
    6864        }
    6965        /**
     
    7571         * @return string The location of the remote path.
    7672         */
    7773        function wp_plugins_dir() {
    78                 if ( defined('FTP_PLUGIN_DIR') && strpos($this->method, 'ftp') !== false )
    79                         return FTP_PLUGIN_DIR;
    8074                return $this->find_folder(WP_PLUGIN_DIR);
    8175        }
    8276        /**
     
    142136         */
    143137        function find_folder($folder) {
    144138
    145                 $folder = preg_replace('|^([a-z]{1}):|i', '', $folder); //Strip out windows driveletter if its there.
     139                if ( strpos($this->method, 'ftp') !== false ) {
     140                        $constant_overrides = array( 'FTP_BASE' => ABSPATH, 'FTP_CONTENT_DIR' => WP_CONTENT_DIR, 'FTP_PLUGIN_DIR' => WP_PLUGIN_DIR );
     141                        foreach ( $constant_overrides as $constant => $dir )
     142                                if ( defined($constant) && $folder === $dir )
     143                                        return trailingslashit(constant($constant));
     144                } elseif ( 'direct' == $this->method ) {
     145                        return trailingslashit($folder);
     146                }
     147
     148                $folder = preg_replace('|^([a-z]{1}):|i', '', $the_folder); //Strip out windows driveletter if its there.
    146149                $folder = str_replace('\\', '/', $folder); //Windows path sanitiation
    147150
    148151                if ( isset($this->cache[ $folder ] ) )
    149152                        return $this->cache[ $folder ];
    150153
    151154                if ( $this->exists($folder) ) { //Folder exists at that absolute path.
     155                        $folder = trailingslashit($folder);
    152156                        $this->cache[ $folder ] = $folder;
    153157                        return $folder;
    154158                }
     
    189193                        // If its found, change into it and follow through looking for it.
    190194                        // If it cant find WordPress down that route, it'll continue onto the next folder level, and see if that matches, and so on.
    191195                        // If it reaches the end, and still cant find it, it'll return false for the entire function.
    192                         if( isset($files[ $key ]) ){
     196                        if ( isset($files[ $key ]) ){
    193197                                //Lets try that folder:
    194198                                $newdir = trailingslashit(path_join($base, $key));
    195                                 if( $this->verbose )
     199                                if ( $this->verbose )
    196200                                        printf( __('Changing to %s') . '<br/>', $newdir );
    197                                 if( $ret = $this->search_for_folder( $folder, $newdir, $loop) )
     201                                if ( $ret = $this->search_for_folder( $folder, $newdir, $loop) )
    198202                                        return $ret;
    199203                        }
    200204                }
    201205
    202206                //Only check this as a last resort, to prevent locating the incorrect install. All above proceeedures will fail quickly if this is the right branch to take.
    203                 if(isset( $files[ $last_path ] ) ) {
    204                         if( $this->verbose )
     207                if (isset( $files[ $last_path ] ) ) {
     208                        if ( $this->verbose )
    205209                                printf( __('Found %s') . '<br/>',  $base . $last_path );
    206                         return $base . $last_path;
     210                        return trailingslashit($base . $last_path);
    207211                }
    208                 if( $loop )
     212                if ( $loop )
    209213                        return false;//Prevent tihs function looping again.
    210214                //As an extra last resort, Change back to / if the folder wasnt found. This comes into effect when the CWD is /home/user/ but WP is at /var/www/.... mainly dedicated setups.
    211215                return $this->search_for_folder($folder, '/', true);
  • wp-admin/includes/class-wp-filesystem-direct.php

     
    4949                return @chdir($dir);
    5050        }
    5151        function chgrp($file, $group, $recursive = false) {
    52                 if( ! $this->exists($file) )
     52                if ( ! $this->exists($file) )
    5353                        return false;
    54                 if( ! $recursive )
     54                if ( ! $recursive )
    5555                        return @chgrp($file, $group);
    56                 if( ! $this->is_dir($file) )
     56                if ( ! $this->is_dir($file) )
    5757                        return @chgrp($file, $group);
    5858                //Is a directory, and we want recursive
    5959                $file = trailingslashit($file);
    6060                $filelist = $this->dirlist($file);
    61                 foreach($filelist as $filename)
     61                foreach ($filelist as $filename)
    6262                        $this->chgrp($file . $filename, $group, $recursive);
    6363
    6464                return true;
    6565        }
    6666        function chmod($file, $mode = false, $recursive = false) {
    67                 if( ! $mode )
     67                if ( ! $mode )
    6868                        $mode = $this->permission;
    69                 if( ! $this->exists($file) )
     69                if ( ! $this->exists($file) )
    7070                        return false;
    71                 if( ! $recursive )
     71                if ( ! $recursive )
    7272                        return @chmod($file,$mode);
    73                 if( ! $this->is_dir($file) )
     73                if ( ! $this->is_dir($file) )
    7474                        return @chmod($file, $mode);
    7575                //Is a directory, and we want recursive
    7676                $file = trailingslashit($file);
    7777                $filelist = $this->dirlist($file);
    78                 foreach($filelist as $filename)
     78                foreach ($filelist as $filename)
    7979                        $this->chmod($file . $filename, $mode, $recursive);
    8080
    8181                return true;
    8282        }
    8383        function chown($file, $owner, $recursive = false) {
    84                 if( ! $this->exists($file) )
     84                if ( ! $this->exists($file) )
    8585                        return false;
    86                 if( ! $recursive )
     86                if ( ! $recursive )
    8787                        return @chown($file, $owner);
    88                 if( ! $this->is_dir($file) )
     88                if ( ! $this->is_dir($file) )
    8989                        return @chown($file, $owner);
    9090                //Is a directory, and we want recursive
    9191                $filelist = $this->dirlist($file);
    92                 foreach($filelist as $filename){
     92                foreach ($filelist as $filename){
    9393                        $this->chown($file . '/' . $filename, $owner, $recursive);
    9494                }
    9595                return true;
    9696        }
    9797        function owner($file) {
    9898                $owneruid = @fileowner($file);
    99                 if( ! $owneruid )
     99                if ( ! $owneruid )
    100100                        return false;
    101                 if( ! function_exists('posix_getpwuid') )
     101                if ( ! function_exists('posix_getpwuid') )
    102102                        return $owneruid;
    103103                $ownerarray = posix_getpwuid($owneruid);
    104104                return $ownerarray['name'];
    105105        }
    106106        function getchmod($file) {
    107                 return @fileperms($file);
     107                return substr(decoct(@fileperms($file)),3);
    108108        }
    109109        function group($file) {
    110110                $gid = @filegroup($file);
    111                 if( ! $gid )
     111                if ( ! $gid )
    112112                        return false;
    113                 if( ! function_exists('posix_getgrgid') )
     113                if ( ! function_exists('posix_getgrgid') )
    114114                        return $gid;
    115115                $grouparray = posix_getgrgid($gid);
    116116                return $grouparray['name'];
    117117        }
    118118
    119119        function copy($source, $destination, $overwrite = false) {
    120                 if( ! $overwrite && $this->exists($destination) )
     120                if ( ! $overwrite && $this->exists($destination) )
    121121                        return false;
    122122                return copy($source, $destination);
    123123        }
    124124
    125125        function move($source, $destination, $overwrite = false) {
    126126                //Possible to use rename()?
    127                 if( $this->copy($source, $destination, $overwrite) && $this->exists($destination) ){
     127                if ( $this->copy($source, $destination, $overwrite) && $this->exists($destination) ){
    128128                        $this->delete($source);
    129129                        return true;
    130130                } else {
     
    135135        function delete($file, $recursive = false) {
    136136                $file = str_replace('\\', '/', $file); //for win32, occasional problems deleteing files otherwise
    137137
    138                 if( $this->is_file($file) )
     138                if ( $this->is_file($file) )
    139139                        return @unlink($file);
    140                 if( ! $recursive && $this->is_dir($file) )
     140                if ( ! $recursive && $this->is_dir($file) )
    141141                        return @rmdir($file);
    142142
    143143                //At this point its a folder, and we're in recursive mode
     
    145145                $filelist = $this->dirlist($file, true);
    146146
    147147                $retval = true;
    148                 if( is_array($filelist) ) //false if no files, So check first.
    149                         foreach($filelist as $filename => $fileinfo)
    150                                 if( ! $this->delete($file . $filename, $recursive) )
     148                if ( is_array($filelist) ) //false if no files, So check first.
     149                        foreach ($filelist as $filename => $fileinfo)
     150                                if ( ! $this->delete($file . $filename, $recursive) )
    151151                                        $retval = false;
    152152
    153                 if( ! @rmdir($file) )
    154                         return false;
     153                if ( file_exists($file) && ! @rmdir($file) )
     154                        $retval = false;
    155155                return $retval;
    156156        }
    157157
     
    187187        }
    188188
    189189        function touch($file, $time = 0, $atime = 0){
    190                 if($time == 0)
     190                if ($time == 0)
    191191                        $time = time();
    192                 if($atime == 0)
     192                if ($atime == 0)
    193193                        $atime = time();
    194194                return @touch($file, $time, $atime);
    195195        }
    196196
    197197        function mkdir($path, $chmod = false, $chown = false, $chgrp = false){
    198                 if( ! $chmod)
     198                if ( ! $chmod)
    199199                        $chmod = $this->permission;
    200200
    201                 if( ! @mkdir($path, $chmod) )
     201                if ( ! @mkdir($path, $chmod) )
    202202                        return false;
    203                 if( $chown )
     203                if ( $chown )
    204204                        $this->chown($path, $chown);
    205                 if( $chgrp )
     205                if ( $chgrp )
    206206                        $this->chgrp($path, $chgrp);
    207207                return true;
    208208        }
    209209
    210210        function rmdir($path, $recursive = false) {
    211211                //Currently unused and untested, Use delete() instead.
    212                 if( ! $recursive )
     212                if ( ! $recursive )
    213213                        return @rmdir($path);
    214214                //recursive:
    215215                $filelist = $this->dirlist($path);
    216                 foreach($filelist as $filename => $det) {
     216                foreach ($filelist as $filename => $det) {
    217217                        if ( '/' == substr($filename, -1, 1) )
    218218                                $this->rmdir($path . '/' . $filename, $recursive);
    219219                        @rmdir($filename);
     
    222222        }
    223223
    224224        function dirlist($path, $incdot = false, $recursive = false) {
    225                 if( $this->is_file($path) ) {
     225                if ( $this->is_file($path) ) {
    226226                        $limitFile = basename($path);
    227227                        $path = dirname($path);
    228228                } else {
    229229                        $limitFile = false;
    230230                }
    231                 if( ! $this->is_dir($path) )
     231                if ( ! $this->is_dir($path) )
    232232                        return false;
    233233
    234234                $ret = array();
     
    239239                        $struc = array();
    240240                        $struc['name'] = $entry;
    241241
    242                         if( '.' == $struc['name'] || '..' == $struc['name'] )
     242                        if ( '.' == $struc['name'] || '..' == $struc['name'] )
    243243                                continue; //Do not care about these folders.
    244                         if( '.' == $struc['name'][0] && !$incdot)
     244                        if ( '.' == $struc['name'][0] && !$incdot)
    245245                                continue;
    246                         if( $limitFile && $struc['name'] != $limitFile)
     246                        if ( $limitFile && $struc['name'] != $limitFile)
    247247                                continue;
    248248
    249249                        $struc['perms']         = $this->gethchmod($path.'/'.$entry);
     
    258258                        $struc['type']          = $this->is_dir($path.'/'.$entry) ? 'd' : 'f';
    259259
    260260                        if ( 'd' == $struc['type'] ) {
    261                                 if( $recursive )
     261                                if ( $recursive )
    262262                                        $struc['files'] = $this->dirlist($path . '/' . $struc['name'], $incdot, $recursive);
    263263                                else
    264264                                        $struc['files'] = array();
  • wp-admin/includes/class-wp-filesystem-ftpext.php

     
    169169        }
    170170        function getchmod($file) {
    171171                $dir = $this->dirlist($file);
    172                 return $dir[$file]['permsn'];
     172                return $this->getnumchmodfromh( $dir[basename($file)]['perms'] );
    173173        }
    174174        function group($file) {
    175175                $dir = $this->dirlist($file);
     
    321321        }
    322322
    323323        function dirlist($path = '.', $incdot = false, $recursive = false) {
    324                 if( $this->is_file($path) ) {
    325                         $limitFile = basename($path);
    326                         $path = dirname($path) . '/';
     324
     325                if ( substr($path, -1) !== '/') {
     326                        $limit = basename($path);
     327                        $path = trailingslashit(dirname($path));
    327328                } else {
    328                         $limitFile = false;
     329                        $limit = false;
    329330                }
    330331
    331332                $list = @ftp_rawlist($this->link, '-a ' . $path, false);
     
    339340                        if ( empty($entry) )
    340341                                continue;
    341342
    342                         if ( '.' == $entry["name"] || '..' == $entry["name"] )
     343                        if ( '.' == $entry['name'] || '..' == $entry['name'] )
    343344                                continue;
    344345
     346                        if ( $limit && $entry['name'] != $limit )
     347                                continue;
     348
    345349                        $dirlist[ $entry['name'] ] = $entry;
    346350                }
    347351
  • wp-admin/includes/class-wp-filesystem-ftpsockets.php

     
    186186
    187187        function getchmod($file) {
    188188                $dir = $this->dirlist($file);
    189                 return $dir[$file]['permsn'];
     189                return $this->getnumchmodfromh( $dir[basename($file)]['perms'] );
    190190        }
    191191
    192192        function group($file) {
     
    281281        }
    282282
    283283        function dirlist($path = '.', $incdot = false, $recursive = false ) {
    284                 if( $this->is_file($path) ) {
    285                         $limitFile = basename($path);
    286                         $path = dirname($path) . '/';
     284
     285                if ( substr($path, -1) !== '/') {
     286                        $limit = basename($path);
     287                        $path = trailingslashit(dirname($path));
    287288                } else {
    288                         $limitFile = false;
     289                        $limit = false;
    289290                }
    290291
    291292                $list = $this->ftp->dirlist($path);
    292293                if( ! $list )
    293294                        return false;
     295
    294296                if( empty($list) )
    295297                        return array();
    296298
    297299                $ret = array();
    298300                foreach ( $list as $struc ) {
     301                        if ( $limit && $struc['name'] != $limit )
     302                                continue;
    299303
    300304                        if ( 'd' == $struc['type'] ) {
    301305                                $struc['files'] = array();
  • wp-admin/includes/class-wp-upgrader.php

     
     1<?php
     2/**
     3 * This file is an attempt at an abstracted version of the plugin/theme/core installer/upgrader which can be used interchangably for all uses needed within WordPress.
     4 * It is designed to be as flexible as possible, but some logic may seem rather, crazy to say the least.
     5 * Yes, this header is designed to be replaced before commiting, Hopefully i'll get some proper documentation in here.
     6 *
     7 * Oh yeah, this needs testing with FTP, only tested with Direct class.
     8 */
     9class WP_Upgrader {
     10        var $strings = array(); //Set in child classes constructor.
     11       
     12        function generic_strings() {
     13                $this->strings['bad_request'] = __('Invalid Data provided.');
     14                $this->strings['fs_unavailable'] = __('Could not access filesystem.');
     15                $this->strings['fs_error'] = __('Filesystem error');
     16                $this->strings['fs_no_root_dir'] = __('Unable to locate WordPress Root directory.');
     17                $this->strings['fs_no_content_dir'] = __('Unable to locate WordPress Content directory (wp-content).');
     18                $this->strings['fs_no_plugins_dir'] = __('Unable to locate WordPress Plugin directory.');
     19                $this->strings['fs_no_themes_dir'] = __('Unable to locate WordPress Theme directory.');
     20                $this->strings['fs_no_folder'] = __('Unable to locate needed folder (%s).');
     21
     22                $this->strings['download_failed'] = __('Download failed.');
     23                $this->strings['installing_package'] = __('Installing the latest version.');
     24                $this->strings['folder_exists'] = __('Destination folder already exists.');
     25                $this->strings['mkdir_failed'] = __('Could not create directory.');
     26                $this->strings['bad_package'] = __('Incompatible Archive');
     27        }
     28       
     29        function feedback($string) {
     30                //TODO Front end fixing.
     31                $str = $this->strings[$string];
     32                 
     33                $args = func_get_args();
     34                $args = array_splice($args, 1);
     35                if ( !empty($args) )
     36                        $str = vsprintf($str, $args);
     37               
     38                return apply_filters('update_feedback', $str);
     39        }
     40
     41        function fs_connect( $directories = array() ) {
     42                global $wp_filesystem;
     43       
     44                // Is a filesystem accessor setup?
     45                if ( ! $wp_filesystem || ! is_object($wp_filesystem) )
     46                        WP_Filesystem();
     47       
     48                if ( ! is_object($wp_filesystem) )
     49                        return new WP_Error('fs_unavailable', $this->strings['fs_unavailable'] );
     50       
     51                if ( $wp_filesystem->errors->get_error_code() )
     52                        return new WP_Error('fs_error', $this->strings['fs_error'], $wp_filesystem->errors);
     53
     54                foreach ( (array)$directories as $dir ) {
     55                        if ( ABSPATH == $dir && ! $wp_filesystem->abspath() )
     56                                return new WP_Error('fs_no_root_dir', $this->strings['fs_no_root_dir']);
     57
     58                        elseif ( WP_CONTENT_DIR == $dir && ! $wp_filesystem->wp_content_dir() )
     59                                return new WP_Error('fs_no_content_dir', $this->strings['fs_no_content_dir']);
     60
     61                        elseif ( WP_PLUGIN_DIR == $dir && ! $wp_filesystem->wp_plugins_dir() )
     62                                return new WP_Error('fs_no_plugins_dir', $this->strings['fs_no_plugins_dir']);
     63
     64                        elseif ( WP_CONTENT_DIR . '/themes' == $dir && ! $wp_filesystem->find_folder(WP_CONTENT_DIR . '/themes') )
     65                                return new WP_Error('fs_no_themes_dir', $this->strings['fs_no_themes_dir']);
     66
     67                        elseif ( ! $wp_filesystem->find_folder($dir) )
     68                                return new WP_Error('fs_no_folder', sprintf($strings['fs_no_folder'], $dir));
     69                }
     70        } //end fs_connect();
     71
     72        function download_package($package) {
     73
     74                if ( ! preg_match('!^(http|https|ftp)://!i', $package) && file_exists($package) ) //Local file or remote?
     75                        return $package; //must be a local file..
     76               
     77                if ( empty($package) )
     78                        return new WP_Error('no_package', $this->strings['no_package']);
     79
     80                $this->feedback('downloading_package', $package);
     81
     82                $download_file = download_url($package); //TODO, move to class?
     83       
     84                if ( is_wp_error($download_file) )
     85                        return new WP_Error('download_failed', $this->strings['download_failed'], $download_file->get_error_message());
     86               
     87                return $download_file;
     88        }
     89       
     90        function unpack_package($package, $delete_package = true) {
     91                global $wp_filesystem;
     92               
     93                $this->feedback('unpack_package');
     94
     95                //We need a working directory
     96                $working_dir = $wp_filesystem->wp_content_dir() . 'upgrade/' . basename($package, '.zip');
     97
     98                // Clean up working directory
     99                if ( $wp_filesystem->is_dir($working_dir) )
     100                        $wp_filesystem->delete($working_dir, true);
     101
     102                // Unzip package to working directory
     103                $result = unzip_file($package, $working_dir); //TODO: Move to class?
     104
     105                // Once extracted, delete the package
     106                unlink($package);
     107
     108                if ( is_wp_error($result) ) {
     109                        $wp_filesystem->delete($working_dir, true);
     110                        return $result;
     111                }
     112               
     113                return $working_dir;
     114        }
     115       
     116        //TODO: Better variable naming.
     117        function install_package($args = array()) {
     118                global $wp_filesystem;
     119                $defaults = array( 'source' => '', 'destination' => '', //Please always pass these
     120                                                'clear_destination' => false, 'clear_working' => false,
     121                                                'hook_extra' => array());
     122
     123                $r = wp_parse_args($args, $defaults);
     124                extract($r);
     125               
     126                if ( empty($source) || empty($destination) )
     127                        return new WP_Error('bad_request', $this->strings['bad_request']);
     128               
     129                $this->feedback('installing_package');
     130
     131                $res = apply_filters('upgrader_pre_install', $hook_extra);
     132                if ( is_wp_error($res) )
     133                        return $res;
     134
     135                //Retain the Original source and destinations
     136                $the_source = $source;
     137                $local_destination = $destination;
     138               
     139                $source_files = array_keys( $wp_filesystem->dirlist($the_source) );
     140                $remote_destination = $wp_filesystem->find_folder($local_destination);
     141
     142                //Locate which directory to copy to the new folder, This is based on the actual folder holding the files.
     143                if ( count($source_files) > 1 ) //If multiple files, then we want the parent directory as source. //Note, This can be changed via the filter 'upgrader_source_selection'
     144                        $source = trailingslashit(dirname($source));
     145                elseif ( 1 == count($source_files) && $wp_filesystem->is_dir( trailingslashit($source) . $source_files[0]) ) //Only one folder? Then we want its contents.
     146                        $source = trailingslashit($source) . trailingslashit($source_files[0]);
     147                elseif ( count($source_files) == 0 )
     148                        return new WP_Error('bad_package', $this->strings['bad_package']); //There are no files?
     149                //else //Its only a single file, I guess this can just be dumped into the destination folder hopefully.
     150               
     151                //Hook ability to change the source file location..
     152                $source = apply_filters('upgrader_source_selection', $source, $the_source, &$this);
     153                if ( is_wp_error($source) )
     154                        return $source;
     155               
     156                //Has the source location changed? If so, we need a new source_files list.
     157                if ( $source !== $the_source )
     158                        $source_files = array_keys( $wp_filesystem->dirlist($source) );
     159               
     160                //Protection against deleting files in any important base directories.
     161                if ( in_array( $destination, array(ABSPATH, WP_CONTENT_DIR, WP_PLUGIN_DIR, WP_CONTENT_DIR . '/themes') ) ) {
     162                        $remote_destination = trailingslashit($remote_destination) . trailingslashit(basename($source));
     163                        $destination = trailingslashit($destination) . trailingslashit(basename($source));
     164                }
     165
     166                //If we're not clearing the destination folder, and something exists there allready, Bail.
     167                if ( ! $clear_destination && $wp_filesystem->exists($remote_destination) ) {
     168                        $wp_filesystem->delete($working_dir, true);
     169                        return new WP_Error('folder_exists', $this->strings['folder_exists'], $filelist[0] );
     170                } else if ( $clear_destination ) {
     171                        //We're going to clear the destination if theres something there
     172                        $this->feedback('remove_old');
     173
     174                        $removed = true;
     175                        if ( $wp_filesystem->exists($remote_destination) )
     176                                $removed = $wp_filesystem->delete($remote_destination, true);
     177
     178                        $removed = apply_filters('upgrader_clear_destination', $removed, $local_destination, $remote_destination, $hook_extra);
     179
     180                        if ( is_wp_error($removed) )
     181                                return $removed;
     182                        elseif ( ! $removed )
     183                                return new WP_Error('remove_old_failed', $this->strings['remove_old_failed']);
     184                }
     185
     186                //The folder name of the destination folder. will get put into the destiination folder, ie. WP_PLUGIN_DIR/SOURCE_DIR/
     187                $source_folder = basename($source);
     188               
     189                //Create destination if needed
     190                if ( !$wp_filesystem->exists($remote_destination) )
     191                        if ( !$wp_filesystem->mkdir($remote_destination) )
     192                                return new WP_Error('mkdir_failed', $this->strings['mkdir_failed'], $remote_destination);
     193               
     194                // Copy new version of item into place.
     195                $result = copy_dir($source, $remote_destination);
     196                if ( is_wp_error($result) ) {
     197                        if ( $clear_working )
     198                                $wp_filesystem->delete($the_source, true);
     199                        return $result;
     200                }
     201               
     202                //Clear the Working folder?
     203                if ( $clear_working )
     204                        $wp_filesystem->delete($the_source, true);
     205
     206                //Bombard the calling function will all the info which we've just used.
     207                return compact('the_source', 'source', 'source_folder', 'source_files', 'destination', 'remote_destination', 'clear_destination', 'delete_source_dir');
     208        }
     209       
     210        function run($options) {
     211
     212                $defaults = array(      'package' => '', //Please always pass this.
     213                                                        'destination' => '', //And this
     214                                                        'clear_destination' => false,
     215                                                        'clear_working' => true,
     216                                                        'hook_extra' => array() //Pass any extra $hook_extra args here, this will be passed to any hooked filters.
     217                                                );
     218
     219                $options = wp_parse_args($args, $options);
     220                extract($options);
     221       
     222                //Connect to the Filesystem first.
     223                $res = $this->fs_connect( array(WP_CONTENT_DIR, $destination) );
     224                if ( is_wp_error($res) )
     225                        return $res;
     226               
     227                //Download the package (Note, This just returns the filename of the file if the package is a local file)
     228                $download = $this->download_package( $package );
     229                if ( is_wp_error($download) )
     230                        return $download;
     231               
     232                //Unzip's the file into a temporary directory
     233                $working_dir = $this->unpack_package( $download );
     234                if ( is_wp_error($working_dir) )
     235                        return $working_dir;
     236
     237                //With the given options, this installs it to the destination directory.
     238                return $this->install_package( array(
     239                                                                                        'source' => $working_dir,
     240                                                                                        'destination' => $destination,
     241                                                                                        'clear_destination' => $clear_destination,
     242                                                                                        'clear_working' => $clear_working,
     243                                                                                        'hook_extra' => $hook_extra
     244                                                                                ) );
     245        }
     246       
     247}
     248
     249class Plugin_Upgrader extends WP_Upgrader {
     250
     251        function upgrade_strings() {
     252                $this->generic_strings();
     253                $this->strings['up_to_date'] = __('The plugin is at the latest version.');
     254                $this->strings['no_package'] = __('Upgrade package not available.');
     255                $this->strings['downloading_package'] = __('Downloading update from %s.');
     256                $this->strings['unpack_package'] = __('Unpacking the update.');
     257                $this->strings['deactivate_plugin'] = __('Deactivating the plugin.');
     258                $this->strings['remove_old'] = __('Removing the old version of the plugin.');
     259                $this->strings['remove_old_failed'] = __('Could not remove the old plugin.');
     260        }
     261
     262        function install_strings() {
     263                $this->generic_strings();
     264                $this->strings['no_package'] = __('Install package not available.');
     265                $this->strings['downloading_package'] = __('Downloading install package from %s.');
     266                $this->strings['unpack_package'] = __('Unpacking the package.');
     267        }
     268
     269        function install($package) {
     270               
     271                $this->install_strings();
     272
     273                $options = array(
     274                                                'package' => $package,
     275                                                'destination' => WP_PLUGIN_DIR,
     276                                                'clear_destination' => false, //Do not overwrite files.
     277                                                'clear_working' => true,
     278                                                'hook_extra' => array()
     279                                                );
     280               
     281                $result = $this->run($options);
     282       
     283                // Force refresh of plugin update information
     284                delete_transient('update_plugins');
     285       
     286                if( empty($result['destination_name']) )
     287                        return false;
     288
     289                $plugin = get_plugins('/' . $result['destination_name']); //Ensure to pass with leading slash
     290                $pluginfiles = array_keys($plugin); //Assume the requested plugin is the first in the list
     291       
     292                return $result['destination_name']. '/' . $pluginfiles[0];
     293        }
     294
     295        function upgrade($plugin) {
     296               
     297                $this->upgrade_strings();
     298               
     299                $current = get_transient( 'update_plugins' );
     300                if ( !isset( $current->response[ $plugin ] ) )
     301                        return new WP_Error('up_to_date', $this->strings['up_to_date']);
     302
     303                // Get the URL to the zip file
     304                $r = $current->response[ $plugin ];
     305               
     306                add_filter('upgrader_pre_install', array(&$this, 'deactivate_plugin_before_upgrade'));
     307                add_filter('upgrader_clear_destination', array(&$this, 'delete_old_plugin'), 10, 4);
     308                //'source_selection' => array(&$this, 'source_selection'), //theres a track ticket to move up the directory for zip's which are made a bit differently, useful for non-.org plugins.
     309               
     310                $options = array(
     311                                        'package' => $r->package,
     312                                        'destination' => WP_PLUGIN_DIR,
     313                                        'clear_destination' => true,
     314                                        'clear_working' => true,
     315                                        'hook_extra' => array(
     316                                                                'plugin' => $plugin
     317                                        )
     318                                );
     319               
     320                $result = $this->run($options);
     321
     322                //Cleanup our hooks, incase something else does a upgrade on this connection.
     323                remove_filter('upgrader_pre_install', array(&$this, 'deactivate_plugin_before_upgrade'));
     324                remove_filter('upgrader_clear_destination', array(&$this, 'delete_old_plugin'));
     325
     326                if ( is_wp_error($result) )
     327                        return $result;
     328
     329                // Force refresh of plugin update information
     330                delete_transient('update_plugins');
     331
     332                if( empty($result['source_folder']) )
     333                        return false;
     334
     335                $plugin = get_plugins('/' . $result['source_folder']); //Ensure to pass with leading slash
     336                $pluginfiles = array_keys($plugin); //Assume the requested plugin is the first in the list
     337       
     338                return $result['source_folder'] . '/' . $pluginfiles[0];
     339        }
     340
     341        //Hooked to pre_install
     342        function deactivate_plugin_before_upgrade($plugin) {
     343
     344                $plugin = isset($plugin['plugin']) ? $plugin['plugin'] : '';
     345                if ( empty($plugin) )
     346                        return new WP_Error('bad_request', $this->strings['bad_request']);
     347
     348                if ( is_plugin_active($plugin) ) {
     349                        $this->feedback('deactivate_plugin');
     350                        //Deactivate the plugin silently, Prevent deactivation hooks from running.
     351                        deactivate_plugins($plugin, true);
     352                }       
     353        }
     354
     355        //Hooked to upgrade_clear_destination
     356        function delete_old_plugin($removed, $local_destination, $remote_destination, $plugin) {
     357                global $wp_filesystem;
     358       
     359                if ( is_wp_error($removed) )
     360                        return $removed; //Pass errors through.
     361       
     362                $plugin = isset($plugin['plugin']) ? $plugin['plugin'] : '';
     363                if ( empty($plugin) )
     364                        return new WP_Error('bad_request', $this->strings['bad_request']);
     365
     366                $plugins_dir = $wp_filesystem->wp_plugins_dir();
     367                $this_plugin_dir = trailingslashit( dirname($plugins_dir . $plugin) );
     368       
     369                // If plugin is in its own directory, recursively delete the directory.
     370                if ( strpos($plugin, '/') && $this_plugin_dir != $plugins_dir ) //base check on if plugin includes directory seperator AND that its not the root plugin folder
     371                        $deleted = $wp_filesystem->delete($this_plugin_dir, true);
     372                else
     373                        $deleted = $wp_filesystem->delete($plugins_dir . $plugin);
     374
     375                if ( ! $deleted )
     376                        return new WP_Error('remove_old_failed', $this->strings['remove_old_failed']);
     377               
     378                return $removed;
     379        }
     380}
     381
     382
     383class Theme_Upgrader extends WP_Upgrader {
     384
     385        function upgrade_strings() {
     386                $this->generic_strings();
     387                $this->strings['up_to_date'] = __('The theme is at the latest version.');
     388                $this->strings['no_package'] = __('Upgrade package not available.');
     389                $this->strings['downloading_package'] = __('Downloading update from %s.');
     390                $this->strings['unpack_package'] = __('Unpacking the update.');
     391//              $this->strings['deactivate_plugin'] = __('Deactivating the plugin.'); // => Maintainence mode?
     392                $this->strings['remove_old'] = __('Removing the old version of the theme.');
     393                $this->strings['remove_old_failed'] = __('Could not remove the old theme.');
     394        }
     395
     396        function install_strings() {
     397                $this->generic_strings();
     398                $this->strings['no_package'] = __('Install package not available.');
     399                $this->strings['downloading_package'] = __('Downloading install package from %s.');
     400                $this->strings['unpack_package'] = __('Unpacking the package.');
     401        }
     402
     403        function install($package) {
     404               
     405                $this->install_strings();
     406
     407                $options = array(
     408                                                'package' => $package,
     409                                                'destination' => WP_CONTENT_DIR . '/themes',
     410                                                'clear_destination' => false, //Do not overwrite files.
     411                                                'clear_working' => true
     412                                                );
     413               
     414                $result = $this->run($options);
     415       
     416                // Force refresh of theme update information
     417                delete_transient('update_themes');
     418       
     419                if( empty($result['destination_name']) )
     420                        return false;
     421
     422                $plugin = get_plugins('/' . $result['destination_name']); //Ensure to pass with leading slash
     423                $pluginfiles = array_keys($plugin); //Assume the requested plugin is the first in the list
     424       
     425                return $folder . '/' . $pluginfiles[0];
     426        }
     427
     428        function upgrade($theme) {
     429               
     430                $this->upgrade_strings();
     431               
     432                // Is an update available?
     433                $current = get_transient( 'update_themes' );
     434                if ( !isset( $current->response[ $theme ] ) )
     435                        return new WP_Error('up_to_date', $this->strings['up_to_date']);
     436               
     437                $r = $current->response[ $theme ];
     438               
     439                $themes = get_themes();
     440                foreach ( (array) $themes as $this_theme ) {
     441                        if ( $this_theme['Stylesheet'] == $theme ) {
     442                                $theme_directory = preg_replace('!^/themes/!i', '', $this_theme['Stylesheet Dir']);
     443                                break;
     444                        }
     445                }
     446                unset($themes);
     447
     448                $options = array(
     449                                                'package' => $r['package'],
     450                                                'destination' => WP_CONTENT_DIR . '/themes',
     451                                                'clear_destination' => true,
     452                                                'clear_working' => true,
     453                                                'hook_extra' => array(
     454                                                                                        'theme' => $theme
     455                                                                                        )
     456                                                );
     457               
     458                $result = $this->run($options);
     459
     460                if ( is_wp_error($result) )
     461                        return $result;
     462
     463                // Force refresh of theme update information
     464                delete_transient('update_themes');
     465
     466                return true;
     467        }
     468
     469}
     470
     471//Untested.
     472class Core_Upgrader extends WP_Upgrader {
     473
     474        function upgrade_strings() {
     475                $this->generic_strings();
     476                $this->strings['up_to_date'] = __('WordPress is at the latest version.');
     477                $this->strings['no_package'] = __('Upgrade package not available.');
     478                $this->strings['downloading_package'] = __('Downloading update from %s.');
     479                $this->strings['unpack_package'] = __('Unpacking the update.');
     480                $this->strings['copy_failed'] = __('Could not copy files.');
     481        }
     482
     483        function upgrade($current) {
     484                global $wp_filesystem;
     485                $this->upgrade_strings();
     486               
     487                @set_time_limit( 300 );
     488       
     489                if ( !empty($feedback) )
     490                        add_filter('update_feedback', $feedback);
     491       
     492                // Is an update available?
     493                if ( !isset( $current->response ) || $current->response == 'latest' )
     494                        return new WP_Error('up_to_date', $this->strings['up_to_date']);
     495
     496                $res = $this->fs_connect( array(ABSPATH, WP_CONTENT_DIR) );
     497                if ( is_wp_error($res) )
     498                        return $res;
     499               
     500                $wp_dir = trailingslashit($wp_filesystem->abspath());
     501               
     502                $download = $this->download_package( $current->package );
     503                if ( is_wp_error($download) )
     504                        return $download;
     505               
     506                $working_dir = $this->unpack_package( $download );
     507                if ( is_wp_error($working_dir) )
     508                        return $working_dir;
     509
     510                // Copy update-core.php from the new version into place.
     511                if ( !$wp_filesystem->copy($working_dir . '/wordpress/wp-admin/includes/update-core.php', $wp_dir . 'wp-admin/includes/update-core.php', true) ) {
     512                        $wp_filesystem->delete($working_dir, true);
     513                        return new WP_Error('copy_failed', $this->strings['copy_failed']);
     514                }
     515                $wp_filesystem->chmod($wp_dir . 'wp-admin/includes/update-core.php', FS_CHMOD_FILE);
     516       
     517                require(ABSPATH . 'wp-admin/includes/update-core.php');
     518       
     519                return update_core($working_dir, $wp_dir);
     520        }
     521
     522}
     523 No newline at end of file
  • wp-admin/includes/plugin-install.php

     
    723723 * @return mixed.
    724724 */
    725725function wp_install_plugin($package, $feedback = '') {
    726         global $wp_filesystem;
    727 
    728726        if ( !empty($feedback) )
    729                 add_filter('install_feedback', $feedback);
     727                add_filter('update_feedback', $feedback);
    730728
    731         // Is a filesystem accessor setup?
    732         if ( ! $wp_filesystem || ! is_object($wp_filesystem) )
    733                 WP_Filesystem();
    734 
    735         if ( ! is_object($wp_filesystem) )
    736                 return new WP_Error('fs_unavailable', __('Could not access filesystem.'));
    737 
    738         if ( $wp_filesystem->errors->get_error_code() )
    739                 return new WP_Error('fs_error', __('Filesystem error'), $wp_filesystem->errors);
    740 
    741         //Get the base plugin folder
    742         $plugins_dir = $wp_filesystem->wp_plugins_dir();
    743         if ( empty($plugins_dir) )
    744                 return new WP_Error('fs_no_plugins_dir', __('Unable to locate WordPress Plugin directory.'));
    745 
    746         //And the same for the Content directory.
    747         $content_dir = $wp_filesystem->wp_content_dir();
    748         if( empty($content_dir) )
    749                 return new WP_Error('fs_no_content_dir', __('Unable to locate WordPress Content directory (wp-content).'));
    750 
    751         $plugins_dir = trailingslashit( $plugins_dir );
    752         $content_dir = trailingslashit( $content_dir );
    753 
    754         if ( empty($package) )
    755                 return new WP_Error('no_package', __('Install package not available.'));
    756 
    757         // Download the package
    758         apply_filters('install_feedback', sprintf(__('Downloading plugin package from %s'), $package));
    759         $download_file = download_url($package);
    760 
    761         if ( is_wp_error($download_file) )
    762                 return new WP_Error('download_failed', __('Download failed.'), $download_file->get_error_message());
    763 
    764         $working_dir = $content_dir . 'upgrade/' . basename($package, '.zip');
    765 
    766         // Clean up working directory
    767         if ( $wp_filesystem->is_dir($working_dir) )
    768                 $wp_filesystem->delete($working_dir, true);
    769 
    770         apply_filters('install_feedback', __('Unpacking the plugin package'));
    771         // Unzip package to working directory
    772         $result = unzip_file($download_file, $working_dir);
    773 
    774         // Once extracted, delete the package
    775         @unlink($download_file);
    776 
    777         if ( is_wp_error($result) ) {
    778                 $wp_filesystem->delete($working_dir, true);
    779                 return $result;
    780         }
    781 
    782         //Get a list of the directories in the working directory before we delete it, We need to know the new folder for the plugin
    783         $filelist = array_keys( $wp_filesystem->dirlist($working_dir) );
    784 
    785         if( $wp_filesystem->exists( $plugins_dir . $filelist[0] ) ) {
    786                 $wp_filesystem->delete($working_dir, true);
    787                 return new WP_Error('install_folder_exists', __('Folder already exists.'), $filelist[0] );
    788         }
    789 
    790         apply_filters('install_feedback', __('Installing the plugin'));
    791         // Copy new version of plugin into place.
    792         $result = copy_dir($working_dir, $plugins_dir);
    793         if ( is_wp_error($result) ) {
    794                 $wp_filesystem->delete($working_dir, true);
    795                 return $result;
    796         }
    797 
    798         //Get a list of the directories in the working directory before we delete it, We need to know the new folder for the plugin
    799         $filelist = array_keys( $wp_filesystem->dirlist($working_dir) );
    800 
    801         // Remove working directory
    802         $wp_filesystem->delete($working_dir, true);
    803 
    804         if( empty($filelist) )
    805                 return false; //We couldnt find any files in the working dir, therefor no plugin installed? Failsafe backup.
    806 
    807         $folder = $filelist[0];
    808         $plugin = get_plugins('/' . $folder); //Ensure to pass with leading slash
    809         $pluginfiles = array_keys($plugin); //Assume the requested plugin is the first in the list
    810 
    811         //Return the plugin files name.
    812         return  $folder . '/' . $pluginfiles[0];
     729        include ABSPATH . 'wp-admin/includes/class-wp-upgrader.php';
     730        $upgrader = new Plugin_Upgrader();
     731        return $upgrader->install($package);
    813732}
    814733
    815734/**
     
    822741 * @return mixed.
    823742 */
    824743function wp_install_plugin_local_package($package, $feedback = '') {
    825         global $wp_filesystem;
    826 
    827744        if ( !empty($feedback) )
    828                 add_filter('install_feedback', $feedback);
     745                add_filter('update_feedback', $feedback);
    829746
    830         // Is a filesystem accessor setup?
    831         if ( ! $wp_filesystem || ! is_object($wp_filesystem) )
    832                 WP_Filesystem();
    833 
    834         if ( ! is_object($wp_filesystem) )
    835                 return new WP_Error('fs_unavailable', __('Could not access filesystem.'));
    836 
    837         if ( $wp_filesystem->errors->get_error_code() )
    838                 return new WP_Error('fs_error', __('Filesystem error'), $wp_filesystem->errors);
    839 
    840         //Get the base plugin folder
    841         $plugins_dir = $wp_filesystem->wp_plugins_dir();
    842         if ( empty($plugins_dir) )
    843                 return new WP_Error('fs_no_plugins_dir', __('Unable to locate WordPress Plugin directory.'));
    844 
    845         //And the same for the Content directory.
    846         $content_dir = $wp_filesystem->wp_content_dir();
    847         if( empty($content_dir) )
    848                 return new WP_Error('fs_no_content_dir', __('Unable to locate WordPress Content directory (wp-content).'));
    849 
    850         $plugins_dir = trailingslashit( $plugins_dir );
    851         $content_dir = trailingslashit( $content_dir );
    852 
    853         if ( empty($package) )
    854                 return new WP_Error('no_package', __('Install package not available.'));
    855 
    856         $working_dir = $content_dir . 'upgrade/' . basename($package, '.zip');
    857 
    858         // Clean up working directory
    859         if ( $wp_filesystem->is_dir($working_dir) )
    860                 $wp_filesystem->delete($working_dir, true);
    861 
    862         apply_filters('install_feedback', __('Unpacking the plugin package'));
    863         // Unzip package to working directory
    864         $result = unzip_file($package, $working_dir);
    865 
    866         // Once extracted, delete the package
    867         unlink($package);
    868 
    869         if ( is_wp_error($result) ) {
    870                 $wp_filesystem->delete($working_dir, true);
    871                 return $result;
    872         }
    873 
    874         //Get a list of the directories in the working directory before we delete it, We need to know the new folder for the plugin
    875         $filelist = array_keys( $wp_filesystem->dirlist($working_dir) );
    876 
    877         if( $wp_filesystem->exists( $plugins_dir . $filelist[0] ) ) {
    878                 $wp_filesystem->delete($working_dir, true);
    879                 return new WP_Error('install_folder_exists', __('Folder already exists.'), $filelist[0] );
    880         }
    881 
    882         apply_filters('install_feedback', __('Installing the plugin'));
    883         // Copy new version of plugin into place.
    884         $result = copy_dir($working_dir, $plugins_dir);
    885         if ( is_wp_error($result) ) {
    886                 $wp_filesystem->delete($working_dir, true);
    887                 return $result;
    888         }
    889 
    890         //Get a list of the directories in the working directory before we delete it, We need to know the new folder for the plugin
    891         $filelist = array_keys( $wp_filesystem->dirlist($working_dir) );
    892 
    893         // Remove working directory
    894         $wp_filesystem->delete($working_dir, true);
    895 
    896         if( empty($filelist) )
    897                 return false; //We couldnt find any files in the working dir, therefor no plugin installed? Failsafe backup.
    898 
    899         $folder = $filelist[0];
    900         $plugin = get_plugins('/' . $folder); //Ensure to pass with leading slash
    901         $pluginfiles = array_keys($plugin); //Assume the requested plugin is the first in the list
    902 
    903         //Return the plugin files name.
    904         return  $folder . '/' . $pluginfiles[0];
     747        include ABSPATH . 'wp-admin/includes/class-wp-upgrader.php';
     748        $upgrader = new Plugin_Upgrader();
     749        return $upgrader->install($package);
    905750}
    906751
    907752?>
  • wp-admin/includes/update.php

     
    167167add_action( 'after_plugin_row', 'wp_plugin_update_row', 10, 2 );
    168168
    169169function wp_update_plugin($plugin, $feedback = '') {
    170         global $wp_filesystem;
    171170
    172171        if ( !empty($feedback) )
    173172                add_filter('update_feedback', $feedback);
    174173
    175         // Is an update available?
    176         $current = get_transient( 'update_plugins' );
    177         if ( !isset( $current->response[ $plugin ] ) )
    178                 return new WP_Error('up_to_date', __('The plugin is at the latest version.'));
    179 
    180         // Is a filesystem accessor setup?
    181         if ( ! $wp_filesystem || ! is_object($wp_filesystem) )
    182                 WP_Filesystem();
    183 
    184         if ( ! is_object($wp_filesystem) )
    185                 return new WP_Error('fs_unavailable', __('Could not access filesystem.'));
    186 
    187         if ( $wp_filesystem->errors->get_error_code() )
    188                 return new WP_Error('fs_error', __('Filesystem error'), $wp_filesystem->errors);
    189 
    190         //Get the base plugin folder
    191         $plugins_dir = $wp_filesystem->wp_plugins_dir();
    192         if ( empty($plugins_dir) )
    193                 return new WP_Error('fs_no_plugins_dir', __('Unable to locate WordPress Plugin directory.'));
    194 
    195         //And the same for the Content directory.
    196         $content_dir = $wp_filesystem->wp_content_dir();
    197         if( empty($content_dir) )
    198                 return new WP_Error('fs_no_content_dir', __('Unable to locate WordPress Content directory (wp-content).'));
    199 
    200         $plugins_dir = trailingslashit( $plugins_dir );
    201         $content_dir = trailingslashit( $content_dir );
    202 
    203         // Get the URL to the zip file
    204         $r = $current->response[ $plugin ];
    205 
    206         if ( empty($r->package) )
    207                 return new WP_Error('no_package', __('Upgrade package not available.'));
    208 
    209         // Download the package
    210         $package = $r->package;
    211         apply_filters('update_feedback', sprintf(__('Downloading update from %s'), $package));
    212         $download_file = download_url($package);
    213 
    214         if ( is_wp_error($download_file) )
    215                 return new WP_Error('download_failed', __('Download failed.'), $download_file->get_error_message());
    216 
    217         $working_dir = $content_dir . 'upgrade/' . basename($plugin, '.php');
    218 
    219         // Clean up working directory
    220         if ( $wp_filesystem->is_dir($working_dir) )
    221                 $wp_filesystem->delete($working_dir, true);
    222 
    223         apply_filters('update_feedback', __('Unpacking the update'));
    224         // Unzip package to working directory
    225         $result = unzip_file($download_file, $working_dir);
    226 
    227         // Once extracted, delete the package
    228         unlink($download_file);
    229 
    230         if ( is_wp_error($result) ) {
    231                 $wp_filesystem->delete($working_dir, true);
    232                 return $result;
    233         }
    234 
    235         if ( is_plugin_active($plugin) ) {
    236                 //Deactivate the plugin silently, Prevent deactivation hooks from running.
    237                 apply_filters('update_feedback', __('Deactivating the plugin'));
    238                 deactivate_plugins($plugin, true);
    239         }
    240 
    241         // Remove the existing plugin.
    242         apply_filters('update_feedback', __('Removing the old version of the plugin'));
    243         $this_plugin_dir = trailingslashit( dirname($plugins_dir . $plugin) );
    244 
    245         // If plugin is in its own directory, recursively delete the directory.
    246         if ( strpos($plugin, '/') && $this_plugin_dir != $plugins_dir ) //base check on if plugin includes directory seperator AND that its not the root plugin folder
    247                 $deleted = $wp_filesystem->delete($this_plugin_dir, true);
    248         else
    249                 $deleted = $wp_filesystem->delete($plugins_dir . $plugin);
    250 
    251         if ( ! $deleted ) {
    252                 $wp_filesystem->delete($working_dir, true);
    253                 return new WP_Error('delete_failed', __('Could not remove the old plugin'));
    254         }
    255 
    256         apply_filters('update_feedback', __('Installing the latest version'));
    257         // Copy new version of plugin into place.
    258         $result = copy_dir($working_dir, $plugins_dir);
    259         if ( is_wp_error($result) ) {
    260                 $wp_filesystem->delete($working_dir, true);
    261                 return $result;
    262         }
    263 
    264         //Get a list of the directories in the working directory before we delete it, We need to know the new folder for the plugin
    265         $filelist = array_keys( $wp_filesystem->dirlist($working_dir) );
    266 
    267         // Remove working directory
    268         $wp_filesystem->delete($working_dir, true);
    269 
    270         // Force refresh of plugin update information
    271         delete_transient('update_plugins');
    272 
    273         if( empty($filelist) )
    274                 return false; //We couldnt find any files in the working dir, therefor no plugin installed? Failsafe backup.
    275 
    276         $folder = $filelist[0];
    277         $plugin = get_plugins('/' . $folder); //Ensure to pass with leading slash
    278         $pluginfiles = array_keys($plugin); //Assume the requested plugin is the first in the list
    279 
    280         return  $folder . '/' . $pluginfiles[0];
     174        include ABSPATH . 'wp-admin/includes/class-wp-upgrader.php';
     175        $upgrader = new Plugin_Upgrader();
     176        return $upgrader->upgrade($plugin);
    281177}
    282178
    283179function wp_update_theme($theme, $feedback = '') {
    284         global $wp_filesystem;
    285 
     180       
    286181        if ( !empty($feedback) )
    287182                add_filter('update_feedback', $feedback);
    288183
    289         // Is an update available?
    290         $current = get_transient( 'update_themes' );
    291         if ( !isset( $current->response[ $theme ] ) )
    292                 return new WP_Error('up_to_date', __('The theme is at the latest version.'));
    293 
    294         $r = $current->response[ $theme ];
    295 
    296         $themes = get_themes();
    297         foreach ( (array) $themes as $this_theme ) {
    298                 if ( $this_theme['Stylesheet'] == $theme ) {
    299                         $theme_directory = preg_replace('!^/themes/!i', '', $this_theme['Stylesheet Dir']);
    300                         break;
    301                 }
    302         }
    303         unset($themes);
    304 
    305         if ( empty($theme_directory) )
    306                 return new WP_Error('theme_non_existant', __('Theme does not exist.'));
    307 
    308         // Is a filesystem accessor setup?
    309         if ( ! $wp_filesystem || ! is_object($wp_filesystem) )
    310                 WP_Filesystem();
    311 
    312         if ( ! is_object($wp_filesystem) )
    313                 return new WP_Error('fs_unavailable', __('Could not access filesystem.'));
    314 
    315         if ( $wp_filesystem->errors->get_error_code() )
    316                 return new WP_Error('fs_error', __('Filesystem error'), $wp_filesystem->errors);
    317 
    318         //Get the base plugin folder
    319         $themes_dir = $wp_filesystem->wp_themes_dir();
    320         if ( empty($themes_dir) )
    321                 return new WP_Error('fs_no_themes_dir', __('Unable to locate WordPress Theme directory.'));
    322 
    323         //And the same for the Content directory.
    324         $content_dir = $wp_filesystem->wp_content_dir();
    325         if( empty($content_dir) )
    326                 return new WP_Error('fs_no_content_dir', __('Unable to locate WordPress Content directory (wp-content).'));
    327 
    328         $themes_dir = trailingslashit( $themes_dir );
    329         $content_dir = trailingslashit( $content_dir );
    330 
    331         if ( empty($r->package) )
    332                 return new WP_Error('no_package', __('Upgrade package not available.'));
    333 
    334         // Download the package
    335         apply_filters('update_feedback', sprintf(__('Downloading update from %s'), $r['package']));
    336         $download_file = download_url($r['package']);
    337 
    338         if ( is_wp_error($download_file) )
    339                 return new WP_Error('download_failed', __('Download failed.'), $download_file->get_error_message());
    340 
    341         $working_dir = $content_dir . 'upgrade/' . basename($theme_directory);
    342 
    343         // Clean up working directory
    344         if ( $wp_filesystem->is_dir($working_dir) )
    345                 $wp_filesystem->delete($working_dir, true);
    346 
    347         apply_filters('update_feedback', __('Unpacking the update'));
    348         // Unzip package to working directory
    349         $result = unzip_file($download_file, $working_dir);
    350 
    351         // Once extracted, delete the package
    352         unlink($download_file);
    353 
    354         if ( is_wp_error($result) ) {
    355                 $wp_filesystem->delete($working_dir, true);
    356                 return $result;
    357         }
    358 
    359         //TODO: Is theme currently active? If so, set default theme
    360         /*
    361         if ( is_plugin_active($plugin) ) {
    362                 //Deactivate the plugin silently, Prevent deactivation hooks from running.
    363                 apply_filters('update_feedback', __('Deactivating the plugin'));
    364                 deactivate_plugins($plugin, true);
    365         }*/
    366 
    367         // Remove the existing plugin.
    368         apply_filters('update_feedback', __('Removing the old version of the theme'));
    369         $deleted = $wp_filesystem->delete($themes_dir . $theme_directory, true);
    370 
    371         if ( ! $deleted ) {
    372                 $wp_filesystem->delete($working_dir, true);
    373                 return new WP_Error('delete_failed', __('Could not remove the old plugin'));
    374         }
    375 
    376         apply_filters('update_feedback', __('Installing the latest version'));
    377         // Copy new version of plugin into place.
    378         $result = copy_dir($working_dir, $themes_dir);
    379         if ( is_wp_error($result) ) {
    380                 $wp_filesystem->delete($working_dir, true);
    381                 return $result;
    382         }
    383 
    384         //Get a list of the directories in the working directory before we delete it, We need to know the new folder for the plugin
    385         //$filelist = array_keys( $wp_filesystem->dirlist($working_dir) );
    386 
    387         // Remove working directory
    388         $wp_filesystem->delete($working_dir, true);
    389 
    390         // Force refresh of plugin update information
    391         delete_transient('update_themes');
    392 
    393         /*if( empty($filelist) )
    394                 return false; //We couldnt find any files in the working dir, therefor no plugin installed? Failsafe backup.
    395 
    396         $folder = $filelist[0];
    397         $plugin = get_plugins('/' . $folder); //Ensure to pass with leading slash
    398         $pluginfiles = array_keys($plugin); //Assume the requested plugin is the first in the list
    399 
    400         return  $folder . '/' . $pluginfiles[0];*/
     184        include ABSPATH . 'wp-admin/includes/class-wp-upgrader.php';
     185        $upgrader = new Theme_Upgrader();
     186        return $upgrader->upgrade($theme);
    401187}
    402188
    403189
    404190function wp_update_core($current, $feedback = '') {
    405         global $wp_filesystem;
    406 
    407         @set_time_limit( 300 );
    408 
     191       
    409192        if ( !empty($feedback) )
    410193                add_filter('update_feedback', $feedback);
    411194
    412         // Is an update available?
    413         if ( !isset( $current->response ) || $current->response == 'latest' )
    414                 return new WP_Error('up_to_date', __('WordPress is at the latest version.'));
     195        include ABSPATH . 'wp-admin/includes/class-wp-upgrader.php';
     196        $upgrader = new Core_Upgrader();
     197        return $upgrader->upgrade($current);
    415198
    416         // Is a filesystem accessor setup?
    417         if ( ! $wp_filesystem || ! is_object($wp_filesystem) )
    418                 WP_Filesystem();
    419 
    420         if ( ! is_object($wp_filesystem) )
    421                 return new WP_Error('fs_unavailable', __('Could not access filesystem.'));
    422 
    423         if ( $wp_filesystem->errors->get_error_code() )
    424                 return new WP_Error('fs_error', __('Filesystem error'), $wp_filesystem->errors);
    425 
    426         // Get the base WP folder
    427         $wp_dir = $wp_filesystem->abspath();
    428         if ( empty($wp_dir) )
    429                 return new WP_Error('fs_no_wp_dir', __('Unable to locate WordPress directory.'));
    430 
    431         // And the same for the Content directory.
    432         $content_dir = $wp_filesystem->wp_content_dir();
    433         if( empty($content_dir) )
    434                 return new WP_Error('fs_no_content_dir', __('Unable to locate WordPress Content directory (wp-content).'));
    435 
    436         $wp_dir = trailingslashit( $wp_dir );
    437         $content_dir = trailingslashit( $content_dir );
    438 
    439         // Get the URL to the zip file
    440         $package = $current->package;
    441 
    442         // Download the package
    443         apply_filters('update_feedback', sprintf(__('Downloading update from %s'), $package));
    444         $download_file = download_url($package);
    445 
    446         if ( is_wp_error($download_file) )
    447                 return new WP_Error('download_failed', __('Download failed.'), $download_file->get_error_message());
    448 
    449         $working_dir = $content_dir . 'upgrade/core';
    450         // Clean up working directory
    451         if ( $wp_filesystem->is_dir($working_dir) ) {
    452                 $wp_filesystem->delete($working_dir, true);
    453         }
    454 
    455         apply_filters('update_feedback', __('Unpacking the core update'));
    456         // Unzip package to working directory
    457         $result = unzip_file($download_file, $working_dir);
    458         // Once extracted, delete the package
    459         unlink($download_file);
    460 
    461         if ( is_wp_error($result) ) {
    462                 $wp_filesystem->delete($working_dir, true);
    463                 return $result;
    464         }
    465 
    466         // Copy update-core.php from the new version into place.
    467         if ( !$wp_filesystem->copy($working_dir . '/wordpress/wp-admin/includes/update-core.php', $wp_dir . 'wp-admin/includes/update-core.php', true) ) {
    468                 $wp_filesystem->delete($working_dir, true);
    469                 return new WP_Error('copy_failed', __('Could not copy files'));
    470         }
    471         $wp_filesystem->chmod($wp_dir . 'wp-admin/includes/update-core.php', FS_CHMOD_FILE);
    472 
    473         require(ABSPATH . 'wp-admin/includes/update-core.php');
    474 
    475         return update_core($working_dir, $wp_dir);
    476199}
    477200
    478201function maintenance_nag() {
  • wp-includes/update.php

     
    112112
    113113        $new_option = new stdClass;
    114114        $new_option->last_checked = time();
    115         $timeout = 'load-plugins.php' == current_filter() ? 360 : 43200; //Check for updated every 60 minutes if hitting the themes page, Else, check every 12 hours
     115        $timeout = 'load-plugins.php' == current_filter() ? 3600 : 43200; //Check for updated every 60 minutes if hitting the themes page, Else, check every 12 hours
    116116        $time_not_changed = isset( $current->last_checked ) && $timeout > ( time() - $current->last_checked );
    117117
    118118        $plugin_changed = false;
     
    195195
    196196        $new_option = new stdClass;
    197197        $new_option->last_checked = time( );
    198         $timeout = 'load-themes.php' == current_filter() ? 360 : 43200; //Check for updated every 60 minutes if hitting the themes page, Else, check every 12 hours
     198        $timeout = 'load-themes.php' == current_filter() ? 3600 : 43200; //Check for updated every 60 minutes if hitting the themes page, Else, check every 12 hours
    199199        $time_not_changed = isset( $current_theme->last_checked ) && $timeout > ( time( ) - $current_theme->last_checked );
    200200
    201201        if( $time_not_changed )