Beiträge von Jossi

  • Plugin lässt sich nicht installieren, Fehler -203

    Hi,
    Ich habe eine frage zu dem Torbutton 1.0.4.01 Pluginn (Programm zur Verschhlüsselung der eigenen Kennung)
    Ich benutze die Version 2.0.0.14
    Immer wenn ich versuche es zu installieren kommt die Fehlermeldung.

    Mozzila konnte das Ad-on von flogender Adresse nicht installieren

    http://www.blablablaa
    Grund: Bei der Installation ist ein unbekannter Fehler aufgetreten. Schauen sie in der Fehler Konsole für weitere Informationen nach -203

    * Write the Extensions List
    * Param needsRestart
    * true if the application needs to restart again, false otherwise.
    */
    _updateExtensionsManifest: function(needsRestart) {
    // When an operation is performed that requires a component re-registration
    // (extension enabled/disabled, installed, uninstalled), we must write the
    // set of paths where extensions live so that the startup system can determine
    // where additional components, preferences, chrome manifests etc live.
    //
    // To do this we obtain a list of active extensions and themes and write
    // these to the extensions.ini file in the profile directory.
    var validExtensions = this._getActiveItems(nsIUpdateItem.TYPE_EXTENSION +
    nsIUpdateItem.TYPE_LOCALE +
    nsIUpdateItem.TYPE_PLUGIN);
    var validThemes = this._getActiveItems(nsIUpdateItem.TYPE_THEME);

    var extensionsLocationsFile = getFile(KEY_PROFILEDIR, [FILE_EXTENSION_MANIFEST]);
    var fos = openSafeFileOutputStream(extensionsLocationsFile);

    var extensionSectionHeader = "[ExtensionDirs]\r\n";
    fos.write(extensionSectionHeader, extensionSectionHeader.length);
    for (var i = 0; i < validExtensions.length; ++i) {
    var e = validExtensions[i];
    var itemLocation = e.location.getItemLocation(e.id).QueryInterface(nsILocalFile);
    var descriptor = getAbsoluteDescriptor(itemLocation);
    var line = "Extension" + i + "=" + descriptor + "\r\n";
    fos.write(line, line.length);
    }

    var themeSectionHeader = "[ThemeDirs]\r\n";
    fos.write(themeSectionHeader, themeSectionHeader.length);
    for (i = 0; i < validThemes.length; ++i) {
    var e = validThemes[i];
    var itemLocation = e.location.getItemLocation(e.id).QueryInterface(nsILocalFile);
    var descriptor = getAbsoluteDescriptor(itemLocation);
    var line = "Extension" + i + "=" + descriptor + "\r\n";
    fos.write(line, line.length);
    }

    closeSafeFileOutputStream(fos);

    // Now refresh the compatibility manifest.
    this._extensionListChanged = needsRestart;
    },

    /**
    * Say whether or not the Extension List has changed (and thus whether or not
    * the system will have to restart the next time it is started).
    * Param val
    * true if the Extension List has changed, false otherwise.
    * @returns |val|
    */
    set _extensionListChanged(val) {
    // When an extension has an operation perform on it (e.g. install, upgrade,
    // disable, etc.) we are responsible for creating the .autoreg file and
    // nsAppRunner is responsible for removing it on restart. At some point it
    // may make sense to be able to cancel a registration but for now we only
    // create the file.
    try {
    var autoregFile = getFile(KEY_PROFILEDIR, [FILE_AUTOREG]);
    if (val && !autoregFile.exists())
    autoregFile.create(nsILocalFile.NORMAL_FILE_TYPE, PERMS_FILE);
    }
    catch (e) {
    }
    return val;
    },

    /**
    * Gathers data about an item specified by the supplied Install Manifest
    * and determines whether or not it can be installed as-is. It makes this
    * determination by validating the item's GUID, Version, and determining
    * if it is compatible with this application.
    * Param installManifest
    * A nsIRDFDataSource representing the Install Manifest of the
    * item to be installed.
    * @return A JS Object with the following properties:
    * "id" The GUID of the Item being installed.
    * "version" The Version string of the Item being installed.
    * "name" The Name of the Item being installed.
    * "type" The nsIUpdateItem type of the Item being installed.
    * "targetApps" An array of TargetApplication Info Objects
    * with "id", "minVersion" and "maxVersion" properties,
    * representing applications targeted by this item.
    * "error" The result code:
    * INSTALLERROR_SUCCESS
    * no error, item can be installed
    * INSTALLERROR_INVALID_GUID
    * error, GUID is not well-formed
    * INSTALLERROR_INVALID_VERSION
    * error, Version is not well-formed
    * INSTALLERROR_INCOMPATIBLE_VERSION
    * error, item is not compatible with this version
    * of the application.
    * INSTALLERROR_INCOMPATIBLE_PLATFORM
    * error, item is not compatible with the operating
    * system or ABI the application was built for.
    * INSTALLERROR_BLOCKLISTED
    * error, item is blocklisted
    */
    _getInstallData: function(installManifest) {
    var installData = { id : "",
    version : "",
    name : "",
    type : 0,
    error : INSTALLERROR_SUCCESS,
    targetApps : [],
    currentApp : null };

    // Fetch properties from the Install Manifest
    installData.id = getManifestProperty(installManifest, "id");
    installData.version = getManifestProperty(installManifest, "version");
    installData.name = getManifestProperty(installManifest, "name");
    installData.type = getAddonTypeFromInstallManifest(installManifest);
    installData.updateURL= getManifestProperty(installManifest, "updateURL");

    /**
    * Reads a property off a Target Application resource
    * Param resource
    * The RDF Resource for a Target Application
    * Param property
    * The property (less EM_NS) to read
    * @returns The string literal value of the property.
    */
    function readTAProperty(resource, property) {
    return stringData(installManifest.GetTarget(resource, EM_R(property), true));
    }

    var targetApps = installManifest.GetTargets(gInstallManifestRoot,
    EM_R("targetApplication"),
    true);
    while (targetApps.hasMoreElements()) {
    var targetApp = targetApps.getNext();
    if (targetApp instanceof Components.interfaces.nsIRDFResource) {
    try {
    var data = { id : readTAProperty(targetApp, "id"),
    minVersion: readTAProperty(targetApp, "minVersion"),
    maxVersion: readTAProperty(targetApp, "maxVersion") };
    installData.targetApps.push(data);
    if (data.id == gApp.ID)
    installData.currentApp = data;
    }
    catch (e) {
    continue;
    }
    }
    }

    // If the item specifies one or more target platforms, make sure our OS/ABI
    // combination is in the list - otherwise, refuse to install the item.
    var targetPlatforms = null;
    try {
    targetPlatforms = installManifest.GetTargets(gInstallManifestRoot,
    EM_R("targetPlatform"),
    true);
    } catch(e) {
    // No targetPlatform nodes, continue.
    }
    if (targetPlatforms != null && targetPlatforms.hasMoreElements()) {
    var foundMatchingOS = false;
    var foundMatchingOSAndABI = false;
    var requireABICompatibility = false;
    while (targetPlatforms.hasMoreElements()) {
    var targetPlatform = stringData(targetPlatforms.getNext());
    var os = targetPlatform.split("_")[0];
    var index = targetPlatform.indexOf("_");
    var abi = index != -1 ? targetPlatform.substr(index + 1) : null;
    if (os == gOSTarget) {
    foundMatchingOS = true;
    // The presence of any ABI part after our OS means ABI is important.
    if (abi != null) {
    requireABICompatibility = true;
    // If we don't know our ABI, we can't be compatible
    if (abi == gXPCOMABI && abi != UNKNOWN_XPCOM_ABI) {
    foundMatchingOSAndABI = true;
    break;
    }
    }
    }
    }
    if (!foundMatchingOS || (requireABICompatibility && !foundMatchingOSAndABI)) {
    installData.error = INSTALLERROR_INCOMPATIBLE_PLATFORM;
    return installData;
    }
    }

    // Validate the Item ID
    if (!gIDTest.test(installData.id)) {
    installData.error = INSTALLERROR_INVALID_GUID;
    return installData;
    }

    // Check the target application range specified by the extension metadata.
    if (gCheckCompatibility &&
    !this.datasource.isCompatible(installManifest, gInstallManifestRoot, undefined))
    installData.error = INSTALLERROR_INCOMPATIBLE_VERSION;

    // Check if the item is blocklisted.
    if (this.datasource.isBlocklisted(installData.id, installData.version,
    undefined, undefined))
    installData.error = INSTALLERROR_BLOCKLISTED;

    return installData;
    },

    /**
    * Installs an item from a XPI/JAR file.
    * This is the main entry point into the Install system from outside code
    * (e.g. XPInstall).
    * Param aXPIFile
    * The file to install from.
    * Param aInstallLocationKey
    * The name of the Install Location where this item should be
    * installed.
    */
    installItemFromFile: function(xpiFile, installLocationKey) {
    this.installItemFromFileInternal(xpiFile, installLocationKey, null);
    },

    /**
    * Installs an item from a XPI/JAR file.
    * Param aXPIFile
    * The file to install from.
    * Param aInstallLocationKey
    * The name of the Install Location where this item should be
    * installed.
    * Param aInstallManifest
    * An updated Install Manifest from the Version Update check.
    * Can be null when invoked from callers other than the Version
    * Update check.
    */
    installItemFromFileInternal: function(aXPIFile, aInstallLocationKey, aInstallManifest) {
    var em = this;
    /**
    * Gets the Install Location for an Item.
    * Param itemID
    * The GUID of the item to find an Install Location for.
    * @return An object implementing nsIInstallLocation which represents the
    * location where the specified item should be installed.
    * This can be:
    * 1. an object that corresponds to the location key supplied to
    * |installItemFromFileInternal|,
    * 2. the default install location (the App Profile Extensions Folder)
    * if no location key was supplied, or the location key supplied
    * was not in the set of registered locations
    * 3. null, if the location selected by 1 or 2 above does not support
    * installs from XPI/JAR files, or that location is not writable
    * with the current access privileges.
    */
    function getInstallLocation(itemID) {
    // Here I use "upgrade" to mean "install a different version of an item".
    var installLocation = em.getInstallLocation(itemID);
    if (!installLocation) {
    // This is not an "upgrade", since we don't have any location data for the
    // extension ID specified - that is, it's not in our database.

    // Caller supplied a key to a registered location, use that location
    // for the installation
    installLocation = InstallLocations.get(aInstallLocationKey);
    if (installLocation) {
    // If the specified location does not have a common metadata location
    // (e.g. extensions have no common root, or other location specified
    // by the location implementation) - e.g. for a Registry Key enumeration
    // location - we cannot install or upgrade using a XPI file, probably
    // because these application types will be handling upgrading themselves.
    // Just bail.
    if (!installLocation.location) {
    LOG("Install Location \"" + installLocation.name + "\" does not support " +
    "installation of items from XPI/JAR files. You must manage " +
    "installation and update of these items yourself.");
    installLocation = null;
    }
    }
    else {
    // In the absence of a preferred install location, just default to
    // the App-Profile
    installLocation = InstallLocations.get(KEY_APP_PROFILE);
    }
    }
    else {
    // This is an "upgrade", but not through the Update System, because the
    // Update code will not let an extension with an incompatible target
    // app version range through to this point. This is an "upgrade" in the
    // sense that the user found a different version of an installed extension
    // and installed it through the web interface, so we have metadata.

    // If the location is different, return the preferred location rather than
    // the location of the currently installed version, because we may be in
    // the situation where an item is being installed into the global app
    // dir when there's a version in the profile dir.
    if (installLocation.name != aInstallLocationKey)
    installLocation = InstallLocations.get(aInstallLocationKey);
    }
    if (!installLocation.canAccess) {
    LOG("Install Location\"" + installLocation.name + "\" cannot be written " +
    "to with your access privileges. Installation will not proceed.");
    installLocation = null;
    }
    return installLocation;
    }

    /**
    * Stages a XPI file in the default item location specified by other
    * applications when they registered with XulRunner if the item's
    * install manifest specified compatibility with them.
    */
    function stageXPIForOtherApps(xpiFile, installData) {
    for (var i = 0; i < installData.targetApps.length; ++i) {
    var targetApp = installData.targetApps[i];
    if (targetApp.id != gApp.ID) {
    /* XXXben uncomment when this works!
    var settingsThingy = Components.classes[]
    .getService(Components.interfaces.nsIXULRunnerSettingsThingy);
    try {
    var appPrefix = "SOFTWARE\\Mozilla\\XULRunner\\Applications\\";
    var branch = settingsThingy.getBranch(appPrefix + targetApp.id);
    var path = branch.getProperty("ExtensionsLocation");
    var destination = Components.classes["@http://mozilla.org/file/local;1"]
    .createInstance(nsILocalFile);
    destination.initWithPath(path);
    xpiFile.copyTo(file, xpiFile.leafName);
    }
    catch (e) {
    }
    */
    }
    }
    }

    /**
    * Extracts and then starts the install for extensions / themes contained
    * within a xpi.
    */
    function installMultiXPI(xpiFile, installData) {
    var fileURL = getURIFromFile(xpiFile).QueryInterface(nsIURL);
    if (fileURL.fileExtension.toLowerCase() != "xpi") {
    LOG("Invalid File Extension: Item: \"" + fileURL.fileName + "\" has an " +
    "invalid file extension. Only xpi file extensions are allowed for " +
    "multiple item packages.");
    var bundle = BundleManager.getBundle(URI_EXTENSIONS_PROPERTIES);
    showMessage("invalidFileExtTitle", [],
    "invalidFileExtMessage", [installData.name,
    fileURL.fileExtension,
    bundle.GetStringFromName("type-" + installData.type)]);
    return;

    ( Hab nur n Teil kopiert, zugross)

    Wäre toll wenn jemand mir helfen könnte.