Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/Sources/formale Sprachen/C/Firefox/xpcom/build/ (Browser von der Mozilla Stiftung Version 136.0.1^©) Datei vom 10.2.2025 mit Größe 7 kB

Quelle Omnijar.cpp Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "Omnijar.h"

#include "nsDirectoryService.h"
#include "nsDirectoryServiceDefs.h"
#include "mozilla/GeckoArgs.h"
#include "mozilla/ipc/ProcessChild.h"
#include "nsIFile.h"
#include "nsZipArchive.h"
#include "nsNetUtil.h"

namespace mozilla {

StaticRefPtr<nsIFile> Omnijar::sPath[2];
StaticRefPtr<nsZipArchive> Omnijar::sReader[2];
StaticRefPtr<nsZipArchive> Omnijar::sOuterReader[2];
bool Omnijar::sInitialized = false;
bool Omnijar::sIsUnified = false;

static const char* sProp[2] = {NS_GRE_DIR, NS_XPCOM_CURRENT_PROCESS_DIR};

#define SPROP(Type) ((Type == mozilla::Omnijar::GRE) ? sProp[GRE] : sProp[APP])

void Omnijar::CleanUpOne(Type aType) {
  if (sReader[aType]) {
    sReader[aType] = nullptr;
  }
  if (sOuterReader[aType]) {
    sOuterReader[aType] = nullptr;
  }
  sPath[aType] = nullptr;
}

nsresult Omnijar::InitOne(nsIFile* aPath, Type aType) {
  constexpr auto kOmnijarName = nsLiteralCString{MOZ_STRINGIFY(OMNIJAR_NAME)};
  nsCOMPtr<nsIFile> file;
  if (aPath) {
    file = aPath;
  } else {
    nsCOMPtr<nsIFile> dir;
    MOZ_TRY(nsDirectoryService::gService->Get(SPROP(aType), NS_GET_IID(nsIFile),
                                              getter_AddRefs(dir)));
    MOZ_TRY(dir->Clone(getter_AddRefs(file)));
    MOZ_TRY(file->AppendNative(kOmnijarName));
  }

  bool isFile = false;
  if (NS_FAILED(file->IsFile(&isFile)) || !isFile) {
    // If we're not using an omni.jar for GRE, and we don't have an
    // omni.jar for APP, check if both directories are the same.
    if ((aType == APP) && (!sPath[GRE])) {
      nsCOMPtr<nsIFile> greDir, appDir;
      bool equals;
      nsDirectoryService::gService->Get(sProp[GRE], NS_GET_IID(nsIFile),
                                        getter_AddRefs(greDir));
      nsDirectoryService::gService->Get(sProp[APP], NS_GET_IID(nsIFile),
                                        getter_AddRefs(appDir));
      if (NS_SUCCEEDED(greDir->Equals(appDir, &equals)) && equals) {
        sIsUnified = true;
      }
    }
    return NS_OK;
  }

  // If we're using omni.jar on both GRE and APP and their path
  // is the same, we're also in the unified case.
  bool equals;
  if ((aType == APP) && (sPath[GRE]) &&
      NS_SUCCEEDED(sPath[GRE]->Equals(file, &equals)) && equals) {
    // If we're using omni.jar on both GRE and APP and their path
    // is the same, we're in the unified case.
    sIsUnified = true;
    return NS_OK;
  }

  RefPtr<nsZipArchive> zipReader = nsZipArchive::OpenArchive(file);
  if (!zipReader) {
    // As file has been checked to exist as file above, any error indicates
    // that it is somehow corrupted internally.
    return NS_ERROR_FILE_CORRUPTED;
  }

  RefPtr<nsZipArchive> outerReader;
  RefPtr<nsZipHandle> handle;
  // If we find a wrapped OMNIJAR, unwrap it.
  if (NS_SUCCEEDED(
          nsZipHandle::Init(zipReader, kOmnijarName, getter_AddRefs(handle)))) {
    outerReader = zipReader;
    zipReader = nsZipArchive::OpenArchive(handle);
    if (!zipReader) {
      return NS_ERROR_FILE_CORRUPTED;
    }
  }

  CleanUpOne(aType);
  sReader[aType] = zipReader;
  sOuterReader[aType] = outerReader;
  sPath[aType] = file;

  return NS_OK;
}

nsresult Omnijar::FallibleInit(nsIFile* aGrePath, nsIFile* aAppPath) {
  // Even on error we do not want to come here again.
  sInitialized = true;

  // Let's always try to init both before returning any error for the benefit
  // of callers that do not handle the error at all.
  nsresult rvGRE = InitOne(aGrePath, GRE);
  nsresult rvAPP = InitOne(aAppPath, APP);
  MOZ_TRY(rvGRE);
  MOZ_TRY(rvAPP);

  return NS_OK;
}

void Omnijar::Init(nsIFile* aGrePath, nsIFile* aAppPath) {
  nsresult rv = FallibleInit(aGrePath, aAppPath);
  if (NS_FAILED(rv)) {
    MOZ_CRASH_UNSAFE_PRINTF("Omnijar::Init failed: %s",
                            mozilla::GetStaticErrorName(rv));
  }
}

void Omnijar::CleanUp() {
  CleanUpOne(GRE);
  CleanUpOne(APP);
  sInitialized = false;
}

already_AddRefed<nsZipArchive> Omnijar::GetReader(nsIFile* aPath) {
  MOZ_ASSERT(IsInitialized(), "Omnijar not initialized");

  bool equals;
  nsresult rv;

  if (sPath[GRE]) {
    rv = sPath[GRE]->Equals(aPath, &equals);
    if (NS_SUCCEEDED(rv) && equals) {
      return IsNested(GRE) ? GetOuterReader(GRE) : GetReader(GRE);
    }
  }
  if (sPath[APP]) {
    rv = sPath[APP]->Equals(aPath, &equals);
    if (NS_SUCCEEDED(rv) && equals) {
      return IsNested(APP) ? GetOuterReader(APP) : GetReader(APP);
    }
  }
  return nullptr;
}

already_AddRefed<nsZipArchive> Omnijar::GetInnerReader(
    nsIFile* aPath, const nsACString& aEntry) {
  MOZ_ASSERT(IsInitialized(), "Omnijar not initialized");

  if (!aEntry.EqualsLiteral(MOZ_STRINGIFY(OMNIJAR_NAME))) {
    return nullptr;
  }

  bool equals;
  nsresult rv;

  if (sPath[GRE]) {
    rv = sPath[GRE]->Equals(aPath, &equals);
    if (NS_SUCCEEDED(rv) && equals) {
      return IsNested(GRE) ? GetReader(GRE) : nullptr;
    }
  }
  if (sPath[APP]) {
    rv = sPath[APP]->Equals(aPath, &equals);
    if (NS_SUCCEEDED(rv) && equals) {
      return IsNested(APP) ? GetReader(APP) : nullptr;
    }
  }
  return nullptr;
}

nsresult Omnijar::GetURIString(Type aType, nsACString& aResult) {
  MOZ_ASSERT(IsInitialized(), "Omnijar not initialized");

  aResult.Truncate();

  // Return an empty string for APP in the unified case.
  if ((aType == APP) && sIsUnified) {
    return NS_OK;
  }

  nsAutoCString omniJarSpec;
  if (sPath[aType]) {
    nsresult rv = NS_GetURLSpecFromActualFile(sPath[aType], omniJarSpec);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      return rv;
    }

    aResult = "jar:";
    if (IsNested(aType)) {
      aResult += "jar:";
    }
    aResult += omniJarSpec;
    aResult += "!";
    if (IsNested(aType)) {
      aResult += "/" MOZ_STRINGIFY(OMNIJAR_NAME) "!";
    }
  } else {
    nsCOMPtr<nsIFile> dir;
    nsDirectoryService::gService->Get(SPROP(aType), NS_GET_IID(nsIFile),
                                      getter_AddRefs(dir));
    nsresult rv = NS_GetURLSpecFromActualFile(dir, aResult);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      return rv;
    }
  }
  aResult += "/";
  return NS_OK;
}

#if defined(MOZ_WIDGET_ANDROID) && defined(MOZ_DIAGNOSTIC_ASSERT_ENABLED)
#  define ANDROID_DIAGNOSTIC_CRASH_OR_EXIT(_msg) MOZ_CRASH(_msg)
#elif defined(MOZ_WIDGET_ANDROID)
#  define ANDROID_DIAGNOSTIC_CRASH_OR_EXIT(_msg) ipc::ProcessChild::QuickExit()
#else
#  define ANDROID_DIAGNOSTIC_CRASH_OR_EXIT(_msg)
#endif

void Omnijar::ChildProcessInit(int& aArgc, char** aArgv) {
  nsCOMPtr<nsIFile> greOmni, appOmni;

  // Android builds are always packaged, so if we can't find anything for
  // greOmni, then this content process is useless, so kill it immediately.
  // On release, we do this via QuickExit() because the crash volume is so
  // high. See bug 1915788.
  if (auto greOmniStr = geckoargs::sGREOmni.Get(aArgc, aArgv)) {
    if (NS_WARN_IF(NS_FAILED(
            XRE_GetFileFromPath(*greOmniStr, getter_AddRefs(greOmni))))) {
      ANDROID_DIAGNOSTIC_CRASH_OR_EXIT("XRE_GetFileFromPath failed");
      greOmni = nullptr;
    }
  } else {
    ANDROID_DIAGNOSTIC_CRASH_OR_EXIT("sGREOmni.Get failed");
  }
  if (auto appOmniStr = geckoargs::sAppOmni.Get(aArgc, aArgv)) {
    if (NS_WARN_IF(NS_FAILED(
            XRE_GetFileFromPath(*appOmniStr, getter_AddRefs(appOmni))))) {
      appOmni = nullptr;
    }
  }

  // If we're unified, then only the -greomni flag is present
  // (reflecting the state of sPath in the parent process) but that
  // path should be used for both (not nullptr, which will try to
  // invoke the directory service, which probably isn't up yet.)
  if (!appOmni) {
    appOmni = greOmni;
  }

  if (greOmni) {
    Init(greOmni, appOmni);
  } else {
    // We should never have an appOmni without a greOmni.
    MOZ_ASSERT(!appOmni);
  }
}

#undef ANDROID_DIAGNOSTIC_CRASH_OR_EXIT

} /* namespace mozilla */

quality100%

¤ Dauer der Verarbeitung: 0.2 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.