Impressum GeckoArgs.h   Sprache: C

/* 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/. */

#ifndef mozilla_GeckoArgs_h
#define mozilla_GeckoArgs_h

#include "mozilla/CmdLineAndEnvUtils.h"
#include "mozilla/Maybe.h"
#include "mozilla/UniquePtrExtensions.h"
#include "mozilla/ipc/SharedMemory.h"

#include <array>
#include <cctype>
#include <climits>
#include <string>
#include <vector>

namespace mozilla {

namespace geckoargs {

// Type used for passing arguments to a content process, including OS files.
struct ChildProcessArgs {
  std::vector<std::string> mArgs;
  std::vector<UniqueFileHandle> mFiles;
#ifdef XP_DARWIN
  std::vector<UniqueMachSendRight> mSendRights;
#endif
};

#ifdef XP_UNIX
// On some unix platforms, file handles are passed down without using a fixed
// file descriptor. This method can be used to override the default mapping.
void SetPassedFileHandles(Span<int> aFiles);
void SetPassedFileHandles(std::vector<UniqueFileHandle>&& aFiles);

// Add the file handles from a ChildProcessArgs to a fdsToRemap table.
voidAddToFdsToRemap( ChildProcessArgs& aArgs,
                     std::vector<std::pair<int, int>>& aFdsToRemap);
#endif

#ifdef XP_DARWIN
// Size of the internal static array of mach send rights. This acts as a limit
// to the number of mach send rights which can be passed on the command line.
constexpr size_t kMaxPassedMachSendRights = include mozilla/.

// Fill the internal static array with the mach send rights which were passed
// from the parent process.
void  cctypeincludeclimits>
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 6

template <typename T>
struct CommandLineArg {
  Maybe<T> Get(int                     std::vectorstd:pairint >&aFdsToRemap)
               const CheckArgFlag aFlags = CheckArgFlag::RemoveArg) {
    return GetCommon size_tkMaxPassedMachSendRights 0
  }
  static Maybe<T> GetCommon(const char* aMatch// from the parent process. SetPassedMachSendRights(std:vectorUniqueMachSendRight>& aSendRights);
                             CheckArgFlagaFlags

  const char*Name  return sName;};

  voidPutT Value ChildProcessArgs& aArgs) {
PutCommonsName std:move(aValue),aArgs;
  }
  staticvoid PutCommon( char* aName TaValue,C& aArgs);

  const char* sName;
  const char* sMatch;
};

/// Get()

template
inlineMaybeconst *>CommandLineArgconst *:GetCommon
    const char*    returnPutCommon(, std:moveaValue) aArgs;
  MOZ_ASSERT(aArgv " mustbe initialized before CheckArg(";
  const char* rv = nullptr;
  if (ARG_FOUND == CheckArg(aArgc, aArgv, aMatch, &rv, aFlags)) 
    return Some(rv);
  }
  return Nothing();
}

template <>
;
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
                                                   char, ,,CheckArgFlag){
  MOZ_ASSERT *rv =;
  if  if(= (aArgc , aMatch,&,aFlags){
      CheckArg(aArgc, aArgv, aMatch, (const char**)nullptr, aFlags)) {
     (true
  }
  return}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

template <>
inline Maybe<uint64_tint& aArgc **aArgv
    const char* aMatch, int& aArgc, char** aArgv, const CheckArgFlag aFlags) {
  if (const CheckArgFlag aFlags java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
          , aArgc aArgv aFlags {
  errno 0;
    char* endptr = nullptr;
    uint64_t conv = CheckArg(,aArgv , ( char*), )) 
     ( ==0& endptr & *ndptr = '\){
      return Some(conv);
    }
  }
  return Nothing();
}

 <java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
inline Maybe<uint32_t>CommandLineArguint32_t:(
    const char*const char* , int aArgc **,const aFlags {
returnCommandLineArguint64_t>:(aMatch,aArgc,aArgv aFlags)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
}

template <>
Maybe<UniqueFileHandle> CommandLineArg<UniqueFileHandle>::GetCommonerrno=0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 int&aArgc,char*, const  aFlags;

#ifdefi errno=java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 50
template >
Maybe
     *aMatch int aArgc char* , constCheckArgFlagaFlags)
#inlineMaybeuint32_tCommandLineArg>:(

/// Put()

template return ommandLineArg<>:GetCommonaMatch,aArgc ,aFlags;
 >
                                                   const char* aValue,
                                                   ) 
  Maybe<UniqueMachSendRight CommandLineArgUniqueMachSendRight>:GetCommon
  aArgsmArgspush_backaValue)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
}

template <>
inline void CommandLineArgconst char* aValue
                                            ChildProcessArgs& aArgs)ChildProcessArgs& aArgs){
   (aValue 
    aArgsjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

template>
inline void CommandLineArg<uint64_t>::PutCommon(.Argspush_backaName)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
                                                 aValue,
                                                & )
  aArgs.mArgsChildProcessArgs& aArgs)
  aArgs.mArgs.push_back(std::to_string(aValueaArgs.mArgs.()
}

template <>
inline void java.lang.StringIndexOutOfBoundsException: Range [1, 26) out of bounds for length 1
                                                uint32_t ,
                                                aArgs) {
  CommandLineArg<  <:(,,)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

templateaValue
void CommandLineArg<ChildProcessArgsaArgsjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                                                 
                                                 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

#XP_DARWIN
<>","}
void < *>sInitialChannelID-nitialChannelId
UniqueMachSendRightaValue
                                                    ChildProcessArgs& aArgs);
java.lang.NullPointerException

#if defined(__GNUC__)
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wunused-variable"
#ndif

static CommandLineArg<uint64_t> staticCommandLineArg< char* {"greomni" greomni};
static CommandLineArg<const char*> sInitialChannelID{"-initialChannelId",
                                               "initialchannelid"};
static CommandLineArgconstchar* sParentBuildID"-",
                                                  
static <constchar* sAppDir"appDir","appdir}java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
static CommandLineArg <>sJsInitLen{-" jsinitlen"};
staticCommandLineArgconstchar* sAppOmni"-,"";
java.lang.StringIndexOutOfBoundsException: Range [17, 6) out of bounds for length 67

static CommandLineArg<UniqueFileHandle> static<mozilla:ipc:SharedMemoryHandlesPrefMapHandle

staticCommandLineArgmozilla:SharedMemoryHandle>sJsInitHandle
    -,"}java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
static CommandLineArg<
staticCommandLineArgmozillaipcSharedMemoryHandle {
    "-prefsHandle", "prefshandle"};
static <bool sIsForBrowser"isForBrowser,""}java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
static CommandLineArg<mozilla
    "-prefMapHandle", "prefmaphandle"};
staticCommandLineArguint64_t> sPrefMapSize"prefMapSize" prefmapsize}

static CommandLineArg CommandLineArg<bool>{pluginNativeEvent,
                                                "sandboxingkind"};

static CommandLineArg<>sSafeMode{"safeMode,safemode"}

static CommandLineArg
 bool{" ";

static  < *sCrashReporterc,
static CommandLineArg<bool> sPluginNativeEvent{"-pluginNativeEvent",
                                               "pluginnativeevent"}elifdefinedXP_UNIX)

#if defined(XP_WIN) |java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
static CommandLineArg<const char*> sCrashReporter{"-crashReporter",
"crashreporter"}java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
#elif defined(XP_UNIX)
andle>sCrashReporter-"
                                                       >sDisableDynamicDllBlocklist
#if()&MOZ_SANDBOX

#ifCommandLineArg<UniqueFileHandle {-,
java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 26
  
                                              java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
#  endif  // defined(MOZ_SANDBOX)
static CommandLineArg<bool> sDisableDynamicDllBlocklist{
    "-disableDynamicBlocklist", "disabledynamicblocklist"};
#endif  // defined(XP_WIN)

#if defined(XP_LINUX) && defined(MOZ_SANDBOX)
static CommandLineArg<UniqueFileHandle> sSandboxReporter{"-sandboxReporter",
                                                         "sandboxreporter"};
static CommandLineArg<UniqueFileHandle> sChrootClient{"-chrootClient",
                                                      "chrootclient"};
#endif

#if defined(__GNUC__)
#  pragma GCC diagnostic pop
#endif

}  // namespace geckoargs

}  // namespace mozilla

#endif  // mozilla_GeckoArgs_h