includes/packages.inc

   1 <?php
   2 /**********************************************************************
   3     Copyright (C) FrontAccounting, LLC.
   4         Released under the terms of the GNU General Public License, GPL,
   5         as published by the Free Software Foundation, either version 3
   6         of the License, or (at your option) any later version.
   7     This program is distributed in the hope that it will be useful,
   8     but WITHOUT ANY WARRANTY; without even the implied warranty of
   9     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  10     See the License here <http://www.gnu.org/licenses/gpl-3.0.html>.
  11 ***********************************************************************/
  12 include_once($path_to_root. "/includes/archive.inc");
  13 include_once($path_to_root. "/includes/remote_url.inc");
  14 include_once($path_to_root. "/includes/hooks.inc");
  15
  16 define('PKG_CACHE_PATH', $path_to_root.'/modules/_cache');
  17 define('PUBKEY_PATH', $path_to_root);
  18 define('REPO_URL', 'http://'.$repo_auth['login'].':'.$repo_auth['pass'].'@'.$repo_auth['host'].'/'.$repo_auth['branch']);
  19 //
  20 // FrontAccounting package class
  21 //
  22 class package extends gzip_file {
  23         function package($filename, $basedir=null)
  24         {
  25                 global $path_to_root;
  26
  27                 if (!$basedir) {
  28                         $basedir = PKG_CACHE_PATH.'/'.substr(basename($filename), 0, -4);
  29                         if (file_exists($basedir)) {
  30 //                              flush_dir($basedir, true);
  31                         } else
  32                         mkdir($basedir);
  33                 }
  34                 $this->archive($filename);
  35                 $this->set_options(array('basedir'=> $basedir));
  36                 $this->options['type'] = "pkg";
  37         }
  38         //
  39         //      Used by archive class. Use create_archive() instead.
  40         //
  41         function create_pkg()
  42         {
  43                 return $this->create_gzip();
  44         }
  45         //
  46         //      Install package and clean temp directory.
  47         //
  48         function install()
  49         {
  50                 global $path_to_root;
  51
  52                 $success = true;
  53
  54                 $this->set_options(array('overwrite' => 1));
  55                 $this->extract_files(); // extract package in cache directory
  56                 $cachepath = $this->options['basedir'];
  57                 $ctrl = get_control_file("$cachepath/_init/config");
  58
  59                 $targetdir = $path_to_root.'/'.$ctrl['InstallPath'];
  60
  61                 if (!is_dir($targetdir))
  62                         mkdir($targetdir);
  63
  64                 $dpackage = new package("$cachepath/_data", $targetdir);
  65                 $dpackage->set_options(array('overwrite' => 1));
  66
  67                 $flist = $dpackage->extract_files(true);
  68                 if (count($dpackage->error)) {
  69                         $this->error = array_merge($this->error, $dpackage->error);
  70                         return false;
  71                 }
  72                 copy_files($flist, $targetdir, "$cachepath/_back");
  73
  74                 $dpackage->extract_files(); //install package in target directory
  75
  76                 $install = hook_invoke($ctrl['Package'], 'install_extension', $dummy);
  77                 $success &= $install===null || $install;
  78                 $success &= count($dpackage->error) == 0;
  79                 $this->error = array_merge($this->error, $dpackage->error);
  80                 return $success;
  81         }
  82         //
  83         //      Removing package related sources
  84         //
  85         function uninstall()
  86         {
  87                 global $path_to_root;
  88
  89                 $success = true;
  90
  91                 $cachepath = $this->options['basedir'];
  92                 $ctrl = get_control_file("$cachepath/_init/config");
  93
  94                 $targetdir = $path_to_root.'/'.$ctrl['InstallPath'];
  95
  96                 $dpackage = new package("$cachepath/_data", $targetdir);
  97
  98                 $flist = $dpackage->extract_files(true);
  99
 100                 $success &= copy_files($flist, "$cachepath/_back", $targetdir, true);
 101
 102                 if (strpos($ctrl['InstallPath'], 'modules/') === 0) { // flush module directory
 103                         flush_dir($targetdir, true);
 104                         rmdir($targetdir);
 105                 }
 106
 107                 $uninstall = hook_invoke($ctrl['Package'], 'uninstall_extension', $dummy);
 108                 $success &= $uninstall===null || $uninstall;
 109
 110                 return $success;
 111         }
 112         //
 113         //      Purge all package related configuration and data.
 114         //
 115         function purge()
 116         {
 117                 return true;
 118         }
 119
 120 }
 121 //
 122 // Changes field value read from control file (single, or multiline) into
 123 // arrays of subfields if needed.
 124 //
 125 function ufmt_property($key, $value)
 126 {
 127         // indexes used in output arrays
 128         $sub_fields = array(
 129 //              'MenuTabs' => array('url', 'access', 'tab_id', 'title', 'section'),
 130 //              'MenuEntries' => array('url', 'access', 'tab_id', 'title'),
 131         );
 132         if (!isset($sub_fields[$key]))
 133                 return $value==='' ? null : $value;
 134
 135         $prop = array();
 136
 137         if (!is_array($value))
 138                 $value = array($value);
 139         foreach($value as $line) {
 140                 $indexes = $sub_fields[$key];
 141                 $ret = array();
 142                 preg_match_all('/(["])(?:\\\\?+.)*?\1|[^"\s][\S]*/', $line, $match);
 143                 foreach($match[0] as $n => $subf) {
 144                         if ($match[1][$n])
 145                                 $val = strtr(substr($subf, 1, -1),
 146                                         array('\\"'=>'"'));
 147                 else
 148                                 $val = $subf;
 149                         if (count($indexes))
 150                                 $ret[array_shift($indexes)] = $val;
 151                         else
 152                                 $ret[] = $val;
 153                 }
 154                 if (count($ret))
 155                         $prop[] = $ret;
 156         }
 157         return $prop;
 158 }
 159 //=============================================================================
 160 //
 161 // Retrieve control file and return as associative array
 162 //      $index is name of field used as key in result array, or null for numeric keys
 163 //
 164 function get_control_file($file, $index = false) {
 165
 166         $list = gzopen($file, 'rb');
 167         if (!$list) return null;
 168
 169         $repo = $pkg = array();
 170         $key = false; $value = '';
 171         $line = '';
 172         do {
 173                 $line = rtrim($line);
 174                 if ($line && ctype_space($line[0])) { // continuation of multiline property
 175                         if (strlen(ltrim($line))) {
 176                                 if ($value !== '' && !is_array($value))
 177                                         $value = array($value);
 178                                 $value[] = ltrim($line);
 179                                 continue;
 180                         }
 181                 }
 182                 if ($key) { // save previous property if any
 183                         $pkg[$key] = ufmt_property($key, $value);
 184                 }
 185                 if (!strlen($line)) { // end of section
 186                         if (count($pkg)) {
 187                                 if ($index !== true) {
 188                                         if ($index === false) break;
 189                                         if (!isset($pkg[$index])) {
 190                                                 display_error(sprintf(_("No key field '%s' in file '%s'"), $index, $file));
 191                                                 return null;
 192                                         }
 193                                         $repo[$pkg[$index]] = $pkg;
 194                                 } else
 195                                         $repo[] = $pkg;
 196                         }
 197                         $pkg = array();
 198                         $key = null; $value = '';
 199                         continue;
 200                 } elseif (preg_match('/([^:]*):\s*(.*)/', $line, $m)) {
 201                         $key = $m[1]; $value = $m[2];
 202                         if (!strlen($key)) {
 203                                 display_error("Empty key in line $line");
 204                                 return null;
 205                         }
 206                 } else {
 207                         display_error("File parse error in line $line");
 208                         return null;
 209                 }
 210
 211         } while ((($line = fgets($list))!==false) || $key);
 212         fclose($list);
 213
 214         return $index === false ? $pkg : $repo;
 215 }
 216 //
 217 //      Save configuration data to control file.
 218 //
 219 function save_control_file($fname, $list, $zip=false)
 220 {
 221         $file = $zip ?  gzopen($fname, 'wb') : fopen($fname, 'wb');
 222         foreach($list as $section) {
 223                 foreach($section as $key => $value) {
 224                         if (is_array($value)) { // multiline value
 225                                 if (is_array(reset($value))) { // lines have subfields
 226                                         foreach($value as $i => $line) {
 227                 // Subfields containing white spaces or double quotes are doublequoted
 228                 // with " escaped with backslash.
 229                                                 foreach($line as $n => $subfield)
 230                                                         if (preg_match('/[\s"]/', $subfield)) {
 231                                                                 $value[$i][$n] =
 232                                                                         '"'.strtr($subfield, array('"'=>'\\"')).'"';
 233                                                         }
 234                                                 // Subfields are separated by white space.
 235                                                 $value[$i] = implode(' ', $value[$i]);
 236                                         }
 237                                 }
 238                                 // array elements on subsequent lines starting with white space
 239                                 $value = implode("\n ", $value);
 240                         }
 241                         $zip ? gzwrite($file, "$key: $value\n") : fwrite($file, "$key: $value\n");
 242                 }
 243                 $zip ? gzwrite($file, "\n"): fwrite($file, "\n");
 244         }
 245         $zip ? gzclose($file) : fclose($file);
 246 }
 247 //
 248 //      Retrieve text field in localized version or default one
 249 //      when the localized is not avaialable.
 250 //
 251 function pkg_prop($pkg, $property, $lang=false)
 252 {
 253
 254         if ($lang && isset($pkg[$property.'-'.user_language()]))
 255                 $prop = @$pkg[$pname];
 256         else
 257                 $prop = @$pkg[$property];
 258
 259         return is_array($prop) ? implode("\n ",$prop): $prop;
 260 }
 261 //
 262 //      Retrieve list of packages from repository and return as table ($pkgname==null),
 263 //      or find $pkgname package in repository and optionaly download
 264 //
 265 //      $type is type/s of package
 266 //  $filter is optional field selection array in form field=>newkey
 267 //              or (0=>field1, 1=>field2...)
 268 //  $outkey - field used as a key in package list. If null 'Package' field is used.
 269 //
 270 function get_pkg_or_list($type = null, $pkgname = null, $filter=array(), $outkey=null, $download=true) {
 271
 272         global $path_to_root, $repo_auth;
 273
 274         // first download local copy of repo release file
 275         // and check remote signature with local copy of public key
 276         //
 277         $loclist = PKG_CACHE_PATH.'/Release.gz';
 278
 279         if (isset($type) && !is_array($type)) {
 280                 $type = array($type);
 281         }
 282         $refresh = true;
 283         do{
 284                 if (!file_exists($loclist)) {
 285                         url_copy(REPO_URL.'/Release.gz', $loclist);
 286                         $refresh = false;
 287                 }
 288                 $sig = url_get_contents(REPO_URL.'/Release.sig');
 289                 $data = file_get_contents($loclist);
 290                 $cert = file_get_contents(PUBKEY_PATH.'/FA.pem');
 291                 if (!openssl_verify($data, $sig, $cert)) {
 292                         if ($refresh) {
 293                                 if (!@unlink($loclist))
 294                                 {
 295                                         display_error(sprintf(_("Cannot delete outdated '%s' file."), $loclist));
 296                                         return null;
 297                                 }
 298                         } else {
 299                                 display_error(_('Release file in repository is invalid, or public key is outdated.'));
 300                                 return null;
 301                         }
 302                 } else
 303                         $refresh = false;
 304         } while($refresh);
 305
 306         $Release = get_control_file($loclist, 'Filename');
 307         // download and check all indexes containing given package types
 308         // then complete package list or seek for pkg
 309         $Packages = array();
 310         foreach($Release as $fname => $parms) {
 311                 if ($type && !count(array_intersect(explode(' ', $parms['Type']), $type))) {
 312                         unset($Release[$fname]); continue; // no packages of selected type in this index
 313                 }
 314                 if ($Release[$fname]['Version'] != $repo_auth['branch']) {
 315                         display_warning(_('Repository version does not match application version.')); // ?
 316                 }
 317                 $remoteindex = REPO_URL.'/'.$fname;
 318                 $locindex = PKG_CACHE_PATH.'/'.$fname;
 319                 $refresh = true;
 320                 do{
 321                         if (!file_exists($locindex)) {
 322                                 url_copy($remoteindex, $locindex);
 323                                 $refresh = false;
 324                         }
 325                         if ($parms['SHA1sum'] != sha1_file($locindex)) {        // check subdir index consistency
 326                                 if ($refresh) {
 327                                         if (!@unlink($locindex)) {
 328                                                 display_error(sprintf(_("Cannot delete outdated '%s' file."), $locindex));
 329                                                 return null;
 330                                         }
 331                                 } else {
 332                                         display_error(sprintf( _("Security alert: broken index file in repository '%s'. Please inform repository administrator about this issue."),
 333                                                 $fname));
 334                                         return null;
 335                                 }
 336                         } else
 337                                 $refresh = false;
 338                 } while($refresh);
 339
 340                  // scan subdir list and select packages of given type
 341                 $pkglist = get_control_file($locindex, 'Package');
 342                 foreach($pkglist as $name => $pkg) {
 343                         $pkgfullname = REPO_URL.'/'.$parms['Path']."/".$pkg['Filename'].'.pkg';
 344                         if (!isset($type) || in_array($pkg['Type'], $type)) {
 345                                 if (empty($filter))
 346                                         $p = $pkg;
 347                                 else {
 348                                         foreach($filter as $field => $key) {
 349                                                 if (is_numeric($field))
 350                                                         $p[$field] = @$pkg[$field];
 351                                                 else
 352                                                         $p[$key] = @$pkg[$field];
 353                                         }
 354                                 }
 355                                 if ($pkgname == null) {
 356                                         $Packages[$outkey ? $outkey : $name] = $p;
 357                                 } elseif ($pkgname == $pkg['Package']) {
 358                                         //download package to temp directory
 359                                         if ($download) {
 360                                                 $locname = "$path_to_root/tmp/".$pkg['Filename'].'.pkg';
 361                                                 url_copy($pkgfullname, $locname);
 362                                                  // checking sha1 hash is expensive proces, so chekc the package
 363                                                  // consistency just before downloading
 364                                                 if ($pkg['SHA1sum'] != sha1_file($locname)) {
 365                                                         display_error(sprintf( _("Security alert: broken package '%s' in repository. Please inform repository administrator about this issue."),
 366                                                                 $pkgfullname));
 367                                                         return null;
 368                                                 }
 369                                         }
 370                                         return $p;
 371                                 }
 372                         }
 373                 }
 374         }
 375
 376         return $Packages;
 377 }
 378
 379 function get_package($pkgname, $type = null)
 380 {
 381         return get_pkg_or_list($type, $pkgname);
 382 }
 383 /*
 384         Returns full name of installed package, or null if package is not installed.
 385 */
 386 function installed_package($package)
 387 {
 388         $cache = opendir(PKG_CACHE_PATH);
 389
 390         while ($file = @readdir($cache)) {
 391                 if (!is_dir(PKG_CACHE_PATH.'/'.$file))
 392                         continue;
 393                 if (strpos($file, $package.'-') === 0)
 394                         return $file;
 395         }
 396         @closedir($cache);
 397
 398         return null;
 399 }
 400 /*
 401         Remove package from system
 402 */
 403 function uninstall_package($name)
 404 {
 405         $name = installed_package($name);
 406         if (!$name) return true; // not installed
 407         $pkg = new package($name.'.pkg');
 408         $pkg->uninstall();
 409         if($name) {
 410                 flush_dir(PKG_CACHE_PATH.'/'.$name, true);
 411                 rmdir(PKG_CACHE_PATH.'/'.$name);
 412         }
 413         return count($pkg->error)==0;
 414 }
 415
 416 //---------------------------------------------------------------------------------------
 417 //
 418 //      Return merged list of available and installed languages in inform of local
 419 // configuration array supplemented with installed versions information.
 420 //
 421 function get_languages_list()
 422 {
 423         global $installed_languages;
 424
 425         $pkgs = get_pkg_or_list('language', null, array(
 426                                 'Package' => 'package',
 427                                 'Version' => 'available',
 428                                 'Name' => 'name',
 429                                 'Language' => 'code',
 430                                 'Encoding' => 'encoding',
 431                                 'RTLDir' => 'rtl',
 432                                 'Description' => 'Descr',
 433                                 'InstallPath' => 'path'
 434                         ));
 435
 436         // add/update languages already installed
 437         //
 438         foreach($installed_languages as $id => $l) {
 439                 $list = array_search_keys($l['code'], $pkgs, 'code');   // get all packages with this code
 440                 foreach ($list as $name) {
 441                         if ($l['encoding'] == $pkgs[$name]['encoding']) {       // if the same encoding
 442                                 $pkgs[$name]['version'] = @$l['version'];               // set installed version
 443                                 $pkgs[$name]['local_id'] = $id;         // index in installed_languages
 444                                 continue 2;
 445                         }
 446                 }
 447                 $l['local_id'] = $id;
 448                 if (!isset($l['package']) || $l['package'] == '' || !isset($pkgs[$l['package']]))
 449                         $pkgs[] = $l;
 450                 else
 451                         $pkgs[$l['package']] = array_merge($pkgs[$l['package']], $l);
 452         }
 453         ksort($pkgs);
 454         return $pkgs;
 455 }
 456 //---------------------------------------------------------------------------------------
 457 //
 458 //      Return merged list of available and installed extensions as a local
 459 // configuration array supplemented with installed versions information.
 460 //
 461 function get_extensions_list($type = null)
 462 {
 463         global $path_to_root;
 464
 465         if (isset($type) || !is_array($type)) {
 466                 $type = array($type);
 467         }
 468
 469         $pkgs = get_pkg_or_list($type, null, array(
 470                                 'Package' => 'package',
 471                                 'Version' => 'available',
 472                                 'Name' => 'name',
 473                                 'Description' => 'Descr',
 474                                 'Type' => 'type',
 475                                 'DefaultStatus'=> 'active',
 476 //                              'MenuTabs' => 'tabs',
 477 //                              'MenuEntries' => 'entries',
 478                                 'Encoding' => 'encoding',
 479 //                              'AccessExtensions' => 'acc_file',
 480                                 'InstallPath' => 'path'
 481                         ));
 482
 483         // lookup for local extensions
 484         $path = $path_to_root.'/modules/';
 485         $loc = array();
 486         $moddir = opendir($path);
 487
 488         while(false != ($fname = readdir($moddir)))
 489         {
 490                 if(!in_array($fname, array('.','..','CVS','_cache')) && is_dir($path.$fname))
 491                 {
 492                         if (!isset($pkgs[$fname]))
 493                                 $pkgs[$fname] = array(
 494                                         'package' => $fname,
 495                                         'name' => $fname,
 496                                         'version' => '',
 497                                         'available' => '',
 498                                         'type' => 'extension',
 499                                         'path' => 'modules/'.$fname,
 500                                         'active' => false
 501                                         );
 502                 }
 503         }
 504
 505         // add/update extensions already installed
 506         //
 507         $installed = get_company_extensions();
 508         foreach($installed as $extno => $ext) {
 509                 if (!in_array($ext['type'], $type)) continue;
 510                 $ext['local_id'] = $extno;
 511 //              if (!isset($pkgs[$ext['package']]) || $ext['package'] == '')
 512 //                      $pkgs[] = $ext;
 513 //              else
 514                         $pkgs[$ext['package']] = array_merge($pkgs[$ext['package']], $ext);
 515         }
 516         ksort($pkgs);
 517         return $pkgs;
 518 }
 519 //
 520 // Return merged list of available and installed extensions as a local
 521 // configuration array supplemented with installed versions information.
 522 //
 523 function get_themes_list()
 524 {
 525         $pkgs = get_pkg_or_list('theme', null, array(
 526                                 'Package' => 'package',
 527                                 'Version' => 'available',
 528                                 'Name' => 'name',
 529                                 'Description' => 'Descr'
 530                         ));
 531
 532         // add/update extensions already installed
 533         //
 534         $local = get_company_extensions();
 535
 536         foreach($local as $extno => $ext) {
 537                 if (isset($pkgs[@$ext['package']])) {
 538                         $ext['local_id'] = $extno;
 539                         $pkgs[$ext['package']] = array_merge($pkgs[$ext['package']], $ext);
 540                 }
 541         }
 542         // TODO: Add other themes from themes directory
 543
 544         ksort($pkgs);
 545         return $pkgs;
 546 }
 547 //---------------------------------------------------------------------------------------
 548 //
 549 //      Return merged list of available and installed COAs as a local
 550 // configuration array supplemented with installed versions information.
 551 //
 552 function get_charts_list()
 553 {
 554         $pkgs = get_pkg_or_list('chart', null, array(
 555                                 'Package' => 'package',
 556                                 'Version' => 'available',
 557                                 'Name' => 'name',
 558                                 'Description' => 'Descr',
 559                                 'Type' => 'type',
 560                                 'InstallPath' => 'path',
 561                                 'Encoding' => 'encoding',
 562                                 'SqlScript' => 'sql'
 563                         ));
 564
 565         // add/update default charts
 566         //
 567         $local = get_company_extensions();
 568
 569         foreach($local as $extno => $ext) {
 570                 if ($ext['type'] != 'chart') continue;
 571                 $ext['local_id'] = $extno;
 572                 if (!isset($pkgs[$ext['package']]) || $ext['package'] == '')
 573                         $pkgs[] = $ext;
 574                 else
 575                         $pkgs[$ext['package']] = array_merge($pkgs[$ext['package']], $ext);
 576         }
 577         ksort($pkgs);
 578         return $pkgs;
 579 }
 580 //---------------------------------------------------------------------------------------------
 581 //      Install/update package from repository
 582 //
 583 function install_language($pkg_name)
 584 {
 585         global $path_to_root, $installed_languages, $Ajax;
 586
 587         $pkg = get_pkg_or_list('language', $pkg_name);
 588
 589         if ($pkg) {
 590                 $i = array_search_key($pkg['Language'], $installed_languages, 'code');
 591                 if ($i === null)
 592                         $i = count($installed_languages);
 593                 else {  // remove another already installed package for this language
 594                         $old_pkg = @$installed_languages[$i]['package'];
 595                         if ($old_pkg && ($pkg['Package'] != $old_pkg))
 596                                 uninstall_package($old_pkg);
 597                 }
 598
 599                 $package = new package("$path_to_root/tmp/".$pkg['Filename'].'.pkg');
 600                 if ($package->install()) {
 601                         $lang = array(
 602                                 'name' => $pkg['Name'],
 603                                 'package' => $pkg['Package'],
 604                                 'code' => $pkg['Language'],
 605                                 'encoding' => $pkg['Encoding'],
 606                                 'version' => $pkg['Version'],
 607                                 'path' => $pkg['InstallPath']
 608                         );
 609                         if ($pkg['RTLDir']=='yes')
 610                                 $lang['rtl'] = true;
 611                         $installed_languages[$i] = $lang;
 612                         write_lang($installed_languages);
 613                         unlink("$path_to_root/tmp/".$pkg['Filename'].'.pkg');
 614                         $Ajax->activate('lang_tbl');
 615                 } else {
 616                         display_error(implode('<br>', $package->error));
 617                         return false;
 618                 }
 619         } else {
 620                 display_error(sprintf(_("Package '%s' not found."), $pkg_name));
 621                 return false;
 622         }
 623         return true;
 624 }
 625 //---------------------------------------------------------------------------------------------
 626 //      Install/update extension or theme package from repository
 627 //
 628 function install_extension($pkg_name)
 629 {
 630         global $path_to_root, $installed_extensions, $next_extension_id, $Ajax;
 631
 632         $pkg = get_pkg_or_list(array('extension', 'theme', 'chart'), $pkg_name);
 633         if ($pkg) {
 634                 $package = new package("$path_to_root/tmp/".$pkg['Filename'].'.pkg');
 635                 $local_exts = get_company_extensions();
 636                 if ($package->install()) {
 637                         $ext_id = array_search_key($pkg['Package'], $local_exts, 'package');
 638                         if ($ext_id === null)
 639                                 $ext_id = $next_extension_id++;
 640                         else {  // remove another already installed package for this language
 641                                 $old_pkg = $installed_extensions[$ext_id]['package'];
 642                                 if ($old_pkg)
 643                                         uninstall_package($old_pkg);
 644                         }
 645                         $ext = array(
 646                                 'name' => $pkg['Name'],
 647                                 'package' => $pkg['Package'],
 648                                 'version' => $pkg['Version'],
 649                                 'type' => $pkg['Type'],
 650                                 'active' => true,
 651                                 'path' => $pkg['InstallPath'],
 652                         );
 653 //                      if (isset($pkg['MenuTabs']))
 654 //                              $ext['tabs'] = $pkg['MenuTabs'];
 655 //                      if (isset($pkg['MenuEntries']))
 656 //                              $ext['entries'] = $pkg['MenuEntries'];
 657 //                      if (isset($pkg['AccessExtensions']))
 658 //                              $ext['acc_file'] = $pkg['AccessExtensions'];
 659                         if (isset($pkg['SqlScript']))
 660                                 $ext['sql'] = $pkg['SqlScript'];
 661                         $local_exts[$ext_id] = $ext;
 662                         $ret = update_extensions($local_exts);
 663                         unlink("$path_to_root/tmp/".$pkg['Filename'].'.pkg');
 664                         $Ajax->activate('ext_tbl');
 665                         return $ret;
 666                 } else {
 667                         display_error(implode('<br>', $package->error));
 668                         return false;
 669                 }
 670         } else {
 671                 display_error(sprintf(_("Package '%s' not found."), $pkg_name));
 672                 return false;
 673         }
 674         return true;
 675 }
 676 /*
 677         Returns true if newer package version is available
 678 */
 679 function check_pkg_upgrade($current, $available)
 680 {
 681         preg_match_all('/[\d]+/', $available, $aver);
 682         if (!count($aver[0]))
 683                 return false;
 684         preg_match_all('/[\d]+/', $current, $cver);
 685         if (!count($cver[0]))
 686                 return true;
 687         foreach($aver[0] as $n => $ver)
 688                 if ($ver>@$cver[0][$n])
 689                         return true;
 690         return false;
 691 }
 692
 693 //
 694 //      Returns package info from index file
 695 //
 696 function get_package_info($pkg, $type=null, $filter=array(), $outkey=null, $download=true) {
 697         return get_pkg_or_list($type, $pkg, $filter, null, false);
 698 }
 699
 700 ?>