1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 package org.openoffice.setup.Installer; 29 30 import org.openoffice.setup.InstallData; 31 import org.openoffice.setup.InstallerHelper.SolarisHelper; 32 import org.openoffice.setup.ResourceManager; 33 import org.openoffice.setup.SetupData.PackageDescription; 34 import org.openoffice.setup.Util.Converter; 35 import org.openoffice.setup.Util.ExecuteProcess; 36 import org.openoffice.setup.Util.Informer; 37 import org.openoffice.setup.Util.LogManager; 38 import org.openoffice.setup.Util.SystemManager; 39 import java.io.File; 40 import java.util.HashMap; 41 import java.util.Vector; 42 43 public class SolarisInstaller extends Installer { 44 45 SolarisHelper helper = new SolarisHelper(); 46 47 public SolarisInstaller() { 48 super(); 49 } 50 51 public void defineDatabasePath() { 52 53 InstallData data = InstallData.getInstance(); 54 String oldDatabasePath = data.getDatabasePath(); 55 data.setDatabasePath(null); 56 57 // Determining the database path (only for user installation). 58 // Important if a user installation is done into an existing 59 // user installation -> this methode can only be called after 60 // determination of installation directory. 61 62 if ( data.isUserInstallation() ) { 63 String databasePath = helper.getSolarisDatabasePath(data); // the file does not need to exist! 64 data.setDatabasePath(databasePath); 65 66 // If this is a new path to the database, then this database was 67 // not analyzed before (when going back in installation wizard) 68 if ( ! databasePath.equals(oldDatabasePath) ) { 69 data.setDatabaseAnalyzed(false); 70 data.setDatabaseQueried(false); 71 } 72 } 73 } 74 75 public void preInstallationOngoing() { 76 // an admin file has to be created for user and for root installation 77 InstallData data = InstallData.getInstance(); 78 79 if ( data.isInstallationMode()) { 80 boolean makeRelocatableAdminFile = true; 81 boolean removeDepends = true; 82 helper.createAdminFile(makeRelocatableAdminFile, removeDepends); 83 helper.createAdminFile(makeRelocatableAdminFile, ! removeDepends); 84 helper.createAdminFile(! makeRelocatableAdminFile, removeDepends); 85 helper.createAdminFile(! makeRelocatableAdminFile, ! removeDepends); 86 } 87 88 if ( data.isUserInstallation() ) { 89 // LD_PRELOAD_32 needs to be set for user installation 90 helper.setEnvironmentForUserInstall(); 91 // Solaris 10 needs to have local temp directory for pkgadd 92 // createLocalTempDir(); 93 } 94 } 95 96 public void postInstallationOngoing() { 97 InstallData data = InstallData.getInstance(); 98 // if ( data.isUserInstallation() ) { 99 // Solaris 10 needs to have local temp directory for pkgadd 100 // removeLocalTempDir(); 101 // } 102 103 helper.removeSolarisLockFile(); 104 } 105 106 public void postInstall(PackageDescription packageData) { 107 InstallData data = InstallData.getInstance(); 108 109 if ( ! data.isAbortedInstallation() ) { 110 data.setStillRunning(true); 111 // Collecting information about installed packages 112 // Creating a list containing pairs of package names and rpm file names 113 // that has to be used during uninstallation. 114 helper.saveModulesLogFile(data); 115 data.setStillRunning(false); 116 } 117 } 118 119 public void postUninstallationOngoing() { 120 helper.removeSolarisLockFile(); 121 } 122 123 public String getChangeInstallDir(PackageDescription packageData) { 124 String installDir = null; 125 String packageName = packageData.getPackageName(); 126 127 if ( packageName != null ) { 128 String pkgCommand = "pkginfo -r" + " " + packageName; 129 String[] pkgCommandArray = new String[3]; 130 pkgCommandArray[0] = "pkginfo"; 131 pkgCommandArray[1] = "-r"; 132 pkgCommandArray[2] = packageName; 133 Vector returnVector = new Vector(); 134 Vector returnErrorVector = new Vector(); 135 int returnValue = ExecuteProcess.executeProcessReturnVector(pkgCommandArray, returnVector, returnErrorVector); 136 String returnString = (String) returnVector.get(0); 137 138 String log = pkgCommand + "<br><b>Returns: " + returnString + "</b><br>"; 139 LogManager.addCommandsLogfileComment(log); 140 141 installDir = returnString; 142 } 143 144 return installDir; 145 } 146 147 public void installPackage(PackageDescription packageData) { 148 InstallData data = InstallData.getInstance(); 149 150 String log = "<br><b>Package: " + packageData.getName() + "</b>"; 151 LogManager.addCommandsLogfileComment(log); 152 153 String rootDir = data.getInstallDir(); 154 String packagePath = data.getPackagePath(); 155 156 if (( packageData.getPkgSubdir() != null ) && ( ! packageData.getPkgSubdir().equals("") )) { 157 File completePackageFile = new File(packagePath, packageData.getPkgSubdir()); 158 packagePath = completePackageFile.getPath(); 159 } 160 161 String packageName = packageData.getPackageName(); 162 163 if (( packageName.equals("")) || ( packageName == null )) { 164 log = "<b>No package name specified. Nothing to do</b>"; 165 LogManager.addCommandsLogfileComment(log); 166 } else { 167 log = "<b>Package Name: " + packageName + "</b>"; 168 LogManager.addCommandsLogfileComment(log); 169 170 File completePackage = new File(packagePath, packageName); 171 172 if ( completePackage.exists() ) { 173 174 String pkgCommand = ""; 175 String[] pkgCommandArray; 176 String adminFileName = ""; 177 Vector returnVector = new Vector(); 178 Vector returnErrorVector = new Vector(); 179 int returnValue; 180 181 // is package relocatable or not? 182 if ( packageData.isRelocatable() ) { 183 adminFileName = data.getAdminFileNameReloc(); 184 } else { 185 adminFileName = data.getAdminFileNameNoReloc(); 186 } 187 188 if ( data.isUserInstallation() ) { 189 HashMap env = data.getShellEnvironment(); 190 String[] envStringArray = Converter.convertHashmapToStringArray(env); 191 pkgCommand = "/usr/sbin/pkgadd -n -d " + packagePath + " -R " + 192 rootDir + " -a " + adminFileName + " " + packageName; 193 pkgCommandArray = new String[9]; 194 pkgCommandArray[0] = "/usr/sbin/pkgadd"; 195 pkgCommandArray[1] = "-n"; 196 pkgCommandArray[2] = "-d"; 197 pkgCommandArray[3] = packagePath; 198 pkgCommandArray[4] = "-R"; 199 pkgCommandArray[5] = rootDir; 200 pkgCommandArray[6] = "-a"; 201 pkgCommandArray[7] = adminFileName; 202 pkgCommandArray[8] = packageName; 203 returnValue = ExecuteProcess.executeProcessReturnVectorEnv(pkgCommandArray, envStringArray, returnVector, returnErrorVector); 204 } else { 205 // shifting of the installation root (-R) is only wanted for user installation 206 pkgCommand = "/usr/sbin/pkgadd -n -d " + packagePath + 207 " -a " + adminFileName + " " + packageName; 208 pkgCommandArray = new String[7]; 209 pkgCommandArray[0] = "/usr/sbin/pkgadd"; 210 pkgCommandArray[1] = "-n"; 211 pkgCommandArray[2] = "-d"; 212 pkgCommandArray[3] = packagePath; 213 pkgCommandArray[4] = "-a"; 214 pkgCommandArray[5] = adminFileName; 215 pkgCommandArray[6] = packageName; 216 returnValue = ExecuteProcess.executeProcessReturnVector(pkgCommandArray, returnVector, returnErrorVector); 217 } 218 219 if ( returnValue == 0 ) { 220 log = pkgCommand + "<br><b>Returns: " + returnValue + " Successful installation</b><br>"; 221 LogManager.addCommandsLogfileComment(log); 222 } else { // an error occured during installation 223 if ( packageData.installCanFail() ) { 224 log = pkgCommand + "<br><b>Returns: " + returnValue + " Problem during installation. Can be ignored.</b><br>"; 225 LogManager.addCommandsLogfileComment(log); 226 } else { 227 log = pkgCommand + "<br><b>Returns: " + returnValue + " Error during installation</b><br>"; 228 LogManager.addCommandsLogfileComment(log); 229 System.err.println("Error during installation:"); 230 for (int i = 0; i < returnErrorVector.size(); i++) { 231 LogManager.addCommandsLogfileComment((String)returnErrorVector.get(i)); 232 System.err.println(returnErrorVector.get(i)); 233 } 234 data.setIsErrorInstallation(true); 235 } 236 } 237 } 238 else { 239 log = "<b>Error: Did not find package " + packageName + "</b><br>"; 240 System.err.println(log); 241 String message = ResourceManager.getString("String_File_Not_Found") + ": " + packageName; 242 String title = ResourceManager.getString("String_Error"); 243 Informer.showErrorMessage(message, title); 244 LogManager.addCommandsLogfileComment(log); 245 data.setIsErrorInstallation(true); 246 } 247 } 248 } 249 250 public void uninstallPackage(PackageDescription packageData) { 251 InstallData data = InstallData.getInstance(); 252 253 String log = "<br><b>Package: " + packageData.getName() + "</b>"; 254 LogManager.addCommandsLogfileComment(log); 255 256 String installRoot = data.getInstallDir(); 257 String packageName = packageData.getPackageName(); 258 String adminFileName = ""; 259 260 // is package relocatable or not? 261 if ( packageData.isRelocatable() ) { 262 if ( packageData.ignoreDependsForUninstall() ) { // Force removal of older packages during installation 263 adminFileName = data.getAdminFileNameRelocNoDepends(); 264 } else { 265 adminFileName = data.getAdminFileNameReloc(); 266 } 267 } else { 268 if ( packageData.ignoreDependsForUninstall() ) { // Force removal of older packages during installation 269 adminFileName = data.getAdminFileNameNoRelocNoDepends(); 270 } else { 271 adminFileName = data.getAdminFileNameNoReloc(); 272 } 273 } 274 275 String pkgCommand = ""; 276 String[] pkgCommandArray; 277 int returnValue; 278 Vector returnVector = new Vector(); 279 Vector returnErrorVector = new Vector(); 280 281 if ( data.isUserInstallation() ) { 282 pkgCommand = "/usr/sbin/pkgrm -n " + "-R " + installRoot + " -a " + adminFileName + " " + packageName; 283 pkgCommandArray = new String[7]; 284 pkgCommandArray[0] = "/usr/sbin/pkgrm"; 285 pkgCommandArray[1] = "-n"; 286 pkgCommandArray[2] = "-R"; 287 pkgCommandArray[3] = installRoot; 288 pkgCommandArray[4] = "-a"; 289 pkgCommandArray[5] = adminFileName; 290 pkgCommandArray[6] = packageName; 291 HashMap env = data.getShellEnvironment(); 292 String[] envStringArray = Converter.convertHashmapToStringArray(env); 293 // SystemManager.dumpStringArray(envStringArray); 294 returnValue = ExecuteProcess.executeProcessReturnVectorEnv(pkgCommandArray, envStringArray, returnVector, returnErrorVector); 295 } else { 296 // shifting of the installation root (-R) is only wanted for user installation 297 pkgCommand = "/usr/sbin/pkgrm -n " + "-a " + adminFileName + " " + packageName; 298 pkgCommandArray = new String[5]; 299 pkgCommandArray[0] = "/usr/sbin/pkgrm"; 300 pkgCommandArray[1] = "-n"; 301 pkgCommandArray[2] = "-a"; 302 pkgCommandArray[3] = adminFileName; 303 pkgCommandArray[4] = packageName; 304 returnValue = ExecuteProcess.executeProcessReturnVector(pkgCommandArray, returnVector, returnErrorVector); 305 } 306 307 if ( returnValue == 0 ) { 308 log = pkgCommand + "<br><b>Returns: " + returnValue + " Successful uninstallation</b><br>"; 309 LogManager.addCommandsLogfileComment(log); 310 } else { // an error occured during installation 311 if ( packageData.uninstallCanFail() ) { 312 log = pkgCommand + "<br><b>Returns: " + returnValue + " Problem during uninstallation. Can be ignored.</b><br>"; 313 LogManager.addCommandsLogfileComment(log); 314 } else { 315 log = pkgCommand + "<br><b>Returns: " + returnValue + " Error during uninstallation</b><br>"; 316 LogManager.addCommandsLogfileComment(log); 317 System.err.println("Error during uninstallation:"); 318 for (int i = 0; i < returnErrorVector.size(); i++) { 319 LogManager.addCommandsLogfileComment((String)returnErrorVector.get(i)); 320 System.err.println(returnErrorVector.get(i)); 321 } 322 data.setIsErrorInstallation(true); 323 } 324 } 325 } 326 327 public boolean isPackageNameInstalledClassic(String packageName, InstallData installData) { 328 String rootString = ""; 329 String rootPath = null; 330 String pkgCommand; 331 String[] pkgCommandArray; 332 boolean useLocalRoot = false; 333 boolean isInstalled = false; 334 335 if (installData.isUserInstallation()) { 336 rootPath = installData.getDatabasePath(); 337 } 338 339 if (( rootPath != null ) && (! rootPath.equals("null"))) { 340 rootString = "-R"; 341 useLocalRoot = true; 342 } 343 344 if (useLocalRoot) { 345 pkgCommand = "pkginfo " + rootString + " " + rootPath + " " + packageName; 346 pkgCommandArray = new String[4]; 347 pkgCommandArray[0] = "pkginfo"; 348 pkgCommandArray[1] = rootString; 349 pkgCommandArray[2] = rootPath; 350 pkgCommandArray[3] = packageName; 351 } else { 352 pkgCommand = "pkginfo " + packageName; 353 pkgCommandArray = new String[2]; 354 pkgCommandArray[0] = "pkginfo"; 355 pkgCommandArray[1] = packageName; 356 } 357 358 // Vector returnVector = new Vector(); 359 int returnValue = ExecuteProcess.executeProcessReturnValue(pkgCommandArray); 360 361 if ( returnValue == 0 ) { 362 isInstalled = true; 363 String log = pkgCommand + "<br><b>Returns: " + returnValue + " Package is installed" + "</b><br>"; 364 LogManager.addCommandsLogfileComment(log); 365 } else { 366 String log = pkgCommand + "<br><b>Returns: " + returnValue + " Package is not installed" + "</b><br>"; 367 LogManager.addCommandsLogfileComment(log); 368 } 369 370 return isInstalled; 371 } 372 373 private void queryAllDatabase(InstallData installData) { 374 375 String rootString = ""; 376 String rootPath = null; 377 String pkgCommand; 378 String[] pkgCommandArray; 379 boolean useLocalRoot = false; 380 HashMap map = new HashMap();; 381 382 if (installData.isUserInstallation()) { 383 rootPath = installData.getDatabasePath(); 384 } 385 386 if (( rootPath != null ) && (! rootPath.equals("null"))) { 387 rootString = "-R"; 388 useLocalRoot = true; 389 } 390 391 if (useLocalRoot) { 392 pkgCommand = "pkginfo " + rootString + " " + rootPath; 393 pkgCommandArray = new String[4]; 394 pkgCommandArray[0] = "pkginfo"; 395 pkgCommandArray[1] = "-x"; 396 pkgCommandArray[2] = rootString; 397 pkgCommandArray[3] = rootPath; 398 } else { 399 pkgCommand = "pkginfo -x"; 400 pkgCommandArray = new String[2]; 401 pkgCommandArray[0] = "pkginfo"; 402 pkgCommandArray[1] = "-x"; 403 } 404 405 Vector returnVector = new Vector(); 406 Vector returnErrorVector = new Vector(); 407 int returnValue = ExecuteProcess.executeProcessReturnVector(pkgCommandArray, returnVector, returnErrorVector); 408 409 String log = pkgCommand + "<br><b>Returns: " + returnValue + "</b><br>"; 410 LogManager.addCommandsLogfileComment(log); 411 String value = "1"; 412 413 if ( ! returnVector.isEmpty()) { 414 for (int i = 0; i < returnVector.size(); i++) { 415 String onePackage = (String)returnVector.get(i); 416 int pos1 = onePackage.indexOf(" "); 417 String key = onePackage.substring(0, pos1); 418 map.put(key, value); 419 } 420 } 421 422 installData.setDatabaseQueried(true); 423 installData.setDatabaseMap(map); 424 425 } 426 427 public boolean isPackageNameInstalled(String packageName, InstallData installData) { 428 429 boolean isInstalled = false; 430 431 HashMap map = null; 432 if ( ! installData.databaseQueried() ) { 433 queryAllDatabase(installData); 434 } 435 436 map = installData.getDatabaseMap(); 437 438 if ( map.containsKey(packageName)) { 439 isInstalled = true; 440 } 441 442 return isInstalled; 443 } 444 445 public boolean isPackageInstalled(PackageDescription packageData, InstallData installData) { 446 boolean isInstalled = false; 447 448 String packageName = packageData.getPackageName(); 449 450 if ( packageName.equals("")) { 451 packageName = null; 452 } 453 454 if ( packageName != null ) { 455 isInstalled = isPackageNameInstalled(packageName, installData); 456 } 457 458 return isInstalled; 459 } 460 461 public boolean isInstallSetPackageOlder(PackageDescription packageData, InstallData installData) { 462 boolean installSetPackageIsOlder = false; 463 boolean checkIfInstalledIsOlder = false; 464 installSetPackageIsOlder = findOlderPackage(packageData, installData, checkIfInstalledIsOlder); 465 return installSetPackageIsOlder; 466 } 467 468 public boolean isInstalledPackageOlder(PackageDescription packageData, InstallData installData) { 469 boolean installedPackageIsOlder = false; 470 boolean checkIfInstalledIsOlder = true; 471 installedPackageIsOlder = findOlderPackage(packageData, installData, checkIfInstalledIsOlder); 472 return installedPackageIsOlder; 473 } 474 475 private boolean findOlderPackage(PackageDescription packageData, InstallData installData, boolean checkIfInstalledIsOlder) { 476 477 boolean firstPackageIsOlder = false; 478 String packageName = packageData.getPackageName(); 479 String log; 480 481 if ( packageName.equals("")) { 482 packageName = null; 483 } 484 485 if ( packageName != null ) { 486 String rootString = ""; 487 String rootPath = null; 488 String pkgCommand; 489 String[] pkgCommandArray; 490 boolean useLocalRoot = false; 491 492 if (installData.isUserInstallation()) { 493 rootPath = installData.getDatabasePath(); 494 } 495 496 if (( rootPath != null ) && (! rootPath.equals("null"))) { 497 rootString = "-R"; 498 useLocalRoot = true; 499 } 500 501 if (useLocalRoot) { 502 // String pkgCommand = "pkginfo -l" + rootString + " " + rootPath + " " + packageName + " | grep VERSION:"; 503 pkgCommand = "pkginfo -x " + rootString + " " + rootPath + " " + packageName; 504 pkgCommandArray = new String[5]; 505 pkgCommandArray[0] = "pkginfo"; 506 pkgCommandArray[1] = "-x"; 507 pkgCommandArray[2] = rootString; 508 pkgCommandArray[3] = rootPath; 509 pkgCommandArray[4] = packageName; 510 511 } else { 512 // String pkgCommand = "pkginfo -l" + rootString + " " + rootPath + " " + packageName + " | grep VERSION:"; 513 pkgCommand = "pkginfo -x " + packageName; 514 pkgCommandArray = new String[3]; 515 pkgCommandArray[0] = "pkginfo"; 516 pkgCommandArray[1] = "-x"; 517 pkgCommandArray[2] = packageName; 518 } 519 520 Vector returnVector = new Vector(); 521 Vector returnErrorVector = new Vector(); 522 523 int returnValue = ExecuteProcess.executeProcessReturnVector(pkgCommandArray, returnVector, returnErrorVector); 524 525 log = pkgCommand + "<br><b>Returns:</b>"; 526 LogManager.addCommandsLogfileComment(log); 527 for (int i = 0; i < returnVector.size(); i++) { 528 log = "<b>" + returnVector.get(i) + "</b>"; 529 LogManager.addCommandsLogfileComment(log); 530 } 531 532 // log = "<br>"; 533 // LogManager.addCommandsLogfileComment(log); 534 535 String installedPackageVersion = helper.getVersionString(returnVector); 536 String newPackageVersion = packageData.getPkgVersion(); 537 538 if ( ! installData.installedProductMinorSet() ) { 539 int productMinor = helper.getInstalledMinor(installedPackageVersion); 540 installData.setInstalledProductMinor(productMinor); 541 installData.setInstalledProductMinorSet(true); 542 } 543 544 if (( installedPackageVersion != null ) && ( newPackageVersion != null )) { 545 if ( checkIfInstalledIsOlder ) { 546 firstPackageIsOlder = helper.comparePackageVersions(installedPackageVersion, newPackageVersion); 547 } else { 548 firstPackageIsOlder = helper.comparePackageVersions(newPackageVersion, installedPackageVersion); 549 } 550 } 551 } 552 553 if ( checkIfInstalledIsOlder ) { 554 if ( firstPackageIsOlder ) { 555 log = "<b>-> Installed package is older</b><br>"; 556 LogManager.addCommandsLogfileComment(log); 557 } else { 558 log = "<b>-> Installed package is not older</b><br>"; 559 LogManager.addCommandsLogfileComment(log); 560 } 561 } else { 562 if ( firstPackageIsOlder ) { 563 log = "<b>-> Package in installation set is older</b><br>"; 564 LogManager.addCommandsLogfileComment(log); 565 } else { 566 log = "<b>-> Package in installation set is not older</b><br>"; 567 LogManager.addCommandsLogfileComment(log); 568 } 569 } 570 571 return firstPackageIsOlder; 572 } 573 574 } 575