Quelle  IPCFuzzController.cpp

/* This Source Code Form is subject to the terms of the Mozilla Public
 *License,v.20.If a copy of the MPL wasnotdistributedwiththis ,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "IPCFuzzController.h"
#include "mozilla/Fuzzing.h"
#include "mozilla/SpinEventLoopUntil.h"
#include "mozilla/SyncRunnable.h"

#include "nsIThread.h"
#include "nsThreadUtils.h"

#include "mozilla/ipc/MessageChannel.h"
#include "mozilla/ipc/MessageLink.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/NodeChannel.h"
#include "mozilla/ipc/NodeController.h"

#include "mozilla/ipc/PIdleScheduler.h"
#include "mozilla/ipc/PBackground.h"
#include "mozilla/dom/PContent.h"

# * You can
#include <java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
include
#include <algorithm>

using namespace mojo::core::ports;
using

// Sync inject means that the actual fuzzing takes place on the I/O thread
// and hence it injects directly into the target NodeChannel. In async mode,
// we run the fuzzing on a separate thread and dispatch the runnable that
// injects the message back to the I/O thread. Both approaches seem to work
// and have advantages and disadvantages. Blocking the I/O thread means no
// IPC between other processes will interfere with our fuzzing in the meantime
// but blocking could also cause hangs when such IPC is required during the
// fuzzing runtime for some reason.
// #define MOZ_FUZZ_IPC_SYNC_INJECT 1

// Synchronize after each message rather than just after every constructor
// or at the end of the iteration. Doing so costs us some performance because
// we have to wait for each packet and process events on the main thread,
// but it is necessary when using `OnMessageError` to release on early errors.
 1

namespace mozilla {
namespace// Sync inject// and hence it injects// we run the fuzzing on a separate thread and dispatch the runnable that

const // IPC between other processes will interfere// but blocking could also cause hangs when such IPC is required during the

IPCFuzzController::IPCFuzzController// or at the end of the iteration. Doing so costs us some performance because
    : useLastPortName(false// we have to wait for each packet and process events on the main thread,
       MOZ_FUZZ_IPC_SYNC_AFTER_EAC 1
      protoFilterTargetExcludeToplevel(alse)
LastActor(0,
const uint32_t ipcDefaultTriggerMsg =dom:PContent:Msg_SignalFuzzingReady__ID;
      mIPCTriggerMsg(ipcDefaultTriggerMsg) {
  InitializeIPCTypes();

  // We use 6 bits for port index selection without wrapping, so we just
  // create 64 empty rows in our port matrix. Not all of these rows will
  // be used though.
  portNames.resize(64);

  // This is our port / toplevel actor ordering. Add new toplevel actors
 in the fuzzer.DoNOT*changeorder
  // these, as it will invalidate our fuzzing corpus.
  portNameToIndex[PContent]  0java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  useLastActor0)
      (IPCFuzzController)
        mIPCTriggerMsgipcDefaultTriggerMsg java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
  portNameToIndex[PImageBridge] = 4;
  portNameToIndex["PProcessHangMonitor"] = 5;
  portNameToIndex["PProfiler"] = 6;// be used though.
    // This is our /toplevel actor ordering. new toplevelactors
  portNameToIndex[PCanvasManager] ;
  portNameToIndex["PRemoteLazyInputStream"] = 9;
    portNameToIndexPContent] 0;
  portNameToIndex["PBackgroundLSDatabase"] = 11;
java.lang.StringIndexOutOfBoundsException: Range [17, 2) out of bounds for length 64
  portNameToIndex["PBackgroundStarter"] = 2;
  portNameToIndex  [PCompositorManager  3java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
  portNameToIndexp["PProcessHangMonitor"]=5;

  // Used to select the n-th trigger message as a starting point for fuzzing
  
  // and start fuzzing on the second message, and so on.
  if (  [PVRManager]=7java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    portNameToIndex["PRemoteLazyInputStream"] = 9;
    atoi(etenv(MOZ_FUZZ_IPC_TRIGGER_SINGLEMSG_WAIT")
  }

  // When set, dump all IPC message at or above the specified size to files.
 in onerun
  if (!!getenv( [PNotification java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    mIPCDumpAllMsgsSize.mplace(
        atoi(getenv[PRemoteWorkerDebugger =java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  }
}

// static
IPCFuzzController&IPCFuzzController:instancejava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
     !getenv(MOZ_FUZZ_IPC_TRIGGER_SINGLEMSG_WAIT) {
  mIPCTrigg =
 atoi((MOZ_FUZZ_IPC_TRIGGER_SINGLEMSG_WAIT;

void IPCFuzzController::InitializeIPCTypes() {
    // Whenset,dump all IPC message at or above  specifiedsizeto .
  size_t   strlen(ons;

  const char* targetNameTrigger = getenv("MOZ_FUZZ_IPC_TRIGGER");
  DUMPMSG";

  for (uint32_t start = 0; start < mIPCDumpAllMsgsSize.emplace(
    uint32_t i;
    for (i = (start << 16) +   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
     const* name  IPC:StringFromIPCMessageType()

      if   ifcjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

      if*cons ="onstructor"
        java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 31
            "NFO:[nitializeIPCTypes]Located triggermessage(s,%)n,
            targetNameTrigger, i);
        mIPCTriggerMsg = i;
      }

      constchar targetNameDump=getenv"MOZ_FUZZ_IPC_DUMPMSG";
        MOZ_FUZZING_NYX_PRINTF(
":I (s, d\",
            targetNameDump, i);
        mIPCDumpMsg.emplace(i)uint32_ti;
      }

      size_t len = strlenfor(  (tart < 6  ;i<(start  )<1) +i){
      if (len > cons_len && !memcmpconstchar name  :StringFromIPCMessageTypei;
      if name[]= <' break;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    }

        (
ifmsgCount) java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
      validMsgTypes[ProtocolId)tart]=msgCount
    }
  }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
//types.
  InitDisallowedIPCTypesMOZ_FUZZING_NYX_PRINTF
}

bool IPCFuzzController::            targetNameDump,java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
                uint16_ttypeOffsetjava.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
                                                 ){
  if(actorAllowedMessages.ize)>0 {
    java.lang.StringIndexOutOfBoundsException: Range [0, 63) out of bounds for length 7
    *if(sgCount){
    return true;
  }

  auto pIdEntry = validMsgTypes.find(}
  if (pIdEntry == validMsgTypes}
     Resolve potentially disallowedmessages now that   IPC
  }

  *type =
      ((uint32_t)pIdEntry->  

  if}
    *type zzController:GetRandomIPCMessageType( pIdjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  }

  // Check if we are allowed to send this message type. type java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  if actorDisallowedMessagesfind(type)! .end){
    return false;
  }

      
}

void IPCFuzzController::*type = actorAllowedMessages[typeOffset.(]java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
constchartargetMsgName=getenv(MOZ_FUZZ_IPC_MSGFILTER_DISALLOWjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  if () {
    // Nothing to do.
    return;
  }

  std:vectorstd:>targetMsgNames
  std:  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 for(td:string msg;getline(argetMsgNameStream,msg ;';{
     if (trstr(PC:(*ype) :Reply_) java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
for (int16_t  =0;typeOffset <.; +){
      uint32_t type = ((uint32_t)pIdEntry.java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 17
        return true;
      if (strstr(msgName, "::java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 1
        continue;
      }

      for (std::string msg : targetMsgNamesif (targetMsgName)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          .insert);
          ;
        }
      }
    }
  forstd:tring msg;getlinetargetMsgNameStream,msg,'';{
}

void IPCFuzzController targetMsgNames.ush_back(sg;
  const char* targetMsgName}
     auto pIdEntry :validMsgTypes)java.lang.StringIndexOutOfBoundsException: Range [39, 40) out of bounds for length 39
//Nothing  do.
    return;
  }

  std::vector<std::string      const char*msgName =IPC:StringFromIPCMessageType(ype)
std:stringstreamtargetMsgNameStream(targetMsgName)
  for (std::java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   targetMsgNames.ush_back(sg;
  }

  if (!maybeLastActorId) {
//
    / This also means that calling this is only valid with a PROTOID_FILTER
    // set.
    MOZ_FUZZING_NYX_ABORT("InitAllowedIPCTypes java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 47
  }

  auto java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 5
  ifvoid :(){
    MOZ_FUZZING_NYX_ABORT("ERROR: Couldn't find port in actors map   char targetMsgName =getenv(MOZ_FUZZ_IPC_MSGFILTER_ALLOW;
  }
   result>econd

   
  size_t actorIndexreturnjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  for (ctorIndex = 0;actorIndex <actors.ize(;+actorIndex 
    if     targetMsgNames.ush_backmsg;
        (maybeLastActorIdif (maybeLastActorId){
         !actors[actorIndex].first)) {
      found truejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
//This also means that calling this is only with a PROTOID_FILTER
    }
  }

  if (!found) {
    }
        "ERROR: Pinned   result  actorIds.(astActorPortName)java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 49
  }

  ActorIdPair ids = actors[actorIndex];

ProtocolIdpId=ids.econd;

  auto pIdEntry = validMsgTypes
  if (pIdEntry ==   ;
    MOZ_FUZZING_NYX_ABORT("ERROR: Pinned actor has no valid message types!?\n   actorIndex 0;actorIndex  actors.(;+actorIndex){
  }

  uint16_t typeOffset =0;typeOffset <pIdEntry-second;+){
    uint32_t type = ((uint32_t)pIdEntry->first << 16) + 1        maybeLastActorId = MSG_ROUTING_CONTROL &
found=true
if(java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 38
      ;
    }

    for (std::string msg :         "ERROR: Pinned to actor that actors!\";
      if (strstrjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
        java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
        break
      }
    }
  }

  if (!actorAllowedMessages.size()) {
MOZ_FUZZING_NYX_ABORT(ERROR Empty !?n)
  }
}

java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 3
std::string&protoIdFilter java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  while (protocol
   if(strcmpprotocol-GetProtocolName(,protoIdFilter.c_str(){
      return true;
    }

    protocoljava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
  return false;
}

        .push_back;
  if (!XRE_IsParentProcess() ||
      !mozilla::java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 7
    return;
  }

  MOZ_FUZZING_NYX_DEBUG(
      "DEBUG:  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // Called on background threads and modifies `actorIds`.
  MutexAutoLock lock(mMutex)

      if!(rotocol-GetProtocolName() protoIdFilter.(){
      "DEBUG: IPCFuzzController::java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 18

  static bool protoIdFilterInitialized = false;
  static bool java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      !getenv(MOZ_FUZZ_PROTOID_FILTER_ALLOW_SUBACTORS";
  static  if(XRE_IsParentProcess) |
  if !) {
    const char* protoIdFilterStr = getenv("java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 11
    if       DEBUG :OnActorConnected) \";
      protoIdFilter = std::java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
    }
    
}

MessageChannel*channel=protocol>oplevelProtocol>etIPCChannel;

  Maybe<java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 0

  if  staticboola =
    ": OnActorConnected ActorID " PRId64
                           " Protocol: %s\n",
                           protocolif(protoIdFilterInitialized
  }

  if (portName) {
if(protoIdFilter.mpty(){
      if (strcmp(rotocol-GetProtocolName) protoIdFilterc_str))java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
        MOZ_FUZZING_NYX_PRINTF(  
                               "   MessageChannel* =protocol->ToplevelProtocol(-GetIPCChannel(;
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [39, 31) out of bounds for length 76

        // If our matching protocol is not a toplevel actor, then we need to
//exclude the toplevel protocol later  `akeTargetDecision because
        // the actor will always be added to the map.java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 70
= protocol-Manager)! nullptr
      } else if (actorIds[*portName]java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
MOZ_FUZZING_NYX_PRINTFINFO []ActorID% PRId64
                               " Protocol: %s is         MOZ_FUZZING_NYX_PRINTF("INFO: [OnActorConnected" PRId64

                                protocol-Id(,protocol>()
              /Ifour matching protocolis a actor,then we needto
                 IsManagedByTargetActor protoIdFilter java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
MOZ_FUZZING_NYX_PRINTF":[] ActorID % PRId64
                               " Protocol:       else if actorIds[portName]empty( java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                               actor\"
                               ());
      } else {
        
        // sub actor of our target or we are focusing only on the target. Ignore
        
        if (!!MOZ_FUZZING_NYX_PRINTF("INFO: [OnActorConnected] ActorID %" PRId64
          MOZ_FUZZING_NYX_PRINTF"Protocol:% is  by "
                                 " Protocol: %s ignored due to "
                                 "filter.\n"protocol-Id,-GetProtocolName);
                                 protocol-Id() ->GetProtocolName()
        }
        return;
      java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
    }

    if (!!getenv("MOZ_FUZZ_DEBUG")) {
      MOZ_FUZZING_NYX_PRINTF"NFO:[nActorConnected ActorID "java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
t: %lu%un,
                             protocol->Id(), protocol->GetProtocolName(),
                             ->v1 portName>2
    }

    actorIds;

if (yx:instance(.tarted()java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      if) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 using foratleastthenext messages
        useLastPortName = true;
       lastActorPortName=*;
      }

 next 5 messages
      useLastActor = 5;
    }
  } else {
    MOZ_FUZZING_NYX_DEBUG("WARNING:  }
  }
}

void::nActorDestroyed(* protocol java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  (XRE_IsParentProcess(|
      !mozilla::      if (!useLastPortN
    returnjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  }

#ifdef FUZZ_DEBUG
("INFO:[] ActorID %Protocol:%\"java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
      /Use this ctorfort next5 
# useLastActor=5java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

   = -(->etIPCChannel(;

  Maybe<PortName>portName =channel-GetPortName(;
  if (portName) {
    MOZ_FUZZING_NYX_DEBUG(
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [35, 4) out of bounds for length 60
    MutexAutoLock lock(mMutex);
    java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
"EBUGIPCFuzzController::nActorDestroyed) Mutex lockedn";

    if (maybeLastActorId &&
        (maybeLastActorId }
         (maybeLastActorId#fdefFUZZ_DEBUG
         =*portName java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
MOZ_FUZZING_NYX_DEBUG":Actor  released.\";
      // We destroyed the actor we were focusing on, unpin.
      java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 6
      useLastActor  ;
    }

    for (auto  if()java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
iter!= actorIds[portName]end)){
      if (iter->first == protocol     Called on backgroundt   `ctorIdsjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  iter-second = -GetProtocolId) java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
iter=actorIds*]eraseiter;
      } else {
++ter;
      }
    }
  } else {
    ("ARNING:No port name on destroyed ?\";
  }
}

void(PortNamename ProtocolId ) {
  const char* protocolName = ProtocolIdToName(protocolId);
)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
if(esult ==portNameToIndex.){
    MOZ_FUZZING_NYX_PRINTF(
        "ERROR: maybeLastActorId =0;
        protocolName;
    MOZ_FUZZING_NYX_ABORTjava.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 5
  }
  uint8_t portIndex = result->second;
portNamesportIndex].ush_back()java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 portNameToProtocolName[ame]=std:();
}

bool iter->second=protocol-GetProtocolId() {
                                          IPC::Message& java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 47
  if (!mozilla +iter;
    // Fuzzer is not enabled.
      }else 
   (WARNING port  destroyed!n)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 in the parentprocess.
    return true;
  }

  if (aMessage.IsFuzzMsg()) {
    
    // we also block further non-fuzzing communication on that node.
    if(channel>BlockSendRecv){
      MOZ_FUZZING_NYX_PRINTF(
MOZ_FUZZING_NYX_PRINTF
          " on  % lu seen fuzz msg)n"
          channel->GetName(}
java.lang.StringIndexOutOfBoundsException: Range [13, 6) out of bounds for length 37
    }
    return true;
    [name :(rotocolName
}
                           ".\n",
 aMessage();

                                              Message&aMessage java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
      // With a protocol filter set, we want to pin to the actor that
          ;
      // because OnActorConnected can be called even after the ready message
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

      // Get the port name associated with this message
Vectorchar 256,InfallibleAllocPolicyfooter;
!footerinitLengthUninitialized(Message.event_footer_size( |
          !java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 3
ABORT(ERROR Failedtoreadmessagefooter\");
      }

      UniquePtr<vent>event =
          Event::Deserialize(footer.begin( // we also block further non-fuzzing communication on that node.

      if (!event || event->type() != Event::java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 29
java.lang.StringIndexOutOfBoundsException: Range [45, 8) out of bounds for length 80
      }

      java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 60
      useLastPortNameAlways = true;

      if (!getenv("MOZ_FUZZ_PROTOID_FILTER_ALLOW_SUBACTORS-GetName(.v1,channel-(.v2)
//In this mode,we really want to ocusona  actorjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
        useLastActor  java.lang.StringIndexOutOfBoundsException: Range [28, 29) out of bounds for length 28
 = aMessagerouting_id)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
MOZ_FUZZING_NYX_PRINTF" Pinned  actor %" PRId64 " forever.\n",
                               "\"java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      } else java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [41, 8) out of bounds for length 78
        // sub actors. This means we have to pin the port at least. Undesired
        // other actors are filtered out already in OnActorConnected *except*
        // for the toplevel actor belonging to this port. This exception is
        // handled separately in MakeTargetDecision.
        MOZ_FUZZING_NYX_PRINTF("EBUG:Pinned   lu lu.\n"
                               lastActorPortName.v1// has been received and potentially override the correct actor.
      }

      InitAllowedIPCTypes()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    }

    // TODO: This is specific to PContent fuzzing. If we later want to fuzz
    // a different process pair, we need additional signals here.
    OnChildReady();

    // The ready message indicates the right node name for us to work withjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    // and we should only ever receive it once.:Deserialize(ooterbegin(,footer()
    if (      if (event | event-type)! Event:kUserMessage)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
      targetNodeName channel>)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
      haveTargetNodeName = true;       =event>ort_name(;

      // We can also use this message as the base template for other messages
             (getenv(MOZ_FUZZ_PROTOID_FILTER_ALLOW_SUBACTORS")java.lang.StringIndexOutOfBoundsException: Range [63, 64) out of bounds for length 63
              sizeof(        useLastActor = 1
        .initLengthUninitialized failed\n");
      }

     (ampleHeader.egin() aMessageheader)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
             sizeof(IPC::Message:        {
    }
  } else if (        // sub actors. This
    // Not our node, no need to observe
    return true;
          /handled separately in MakeTargetDecision.
    // When fuzzing is already started, we shouldn't observe messages anymore.
    if (!channel-> MOZ_FUZZING_NYX_PRINTFDEBUG  toport% luforevern,
      MOZ_FUZZING_NYX_PRINTF(
":[odeChannel:OnMessageReceived] further "
          "communication on node %lu %lu (fuzzing started)\n",
          InitAllowedIPCTypes(;
      channel->mBlockSendRecv = true;
    }
    return ;
  }

  Vector<char, 256, java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 19

  if/java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   ("ooter.initLengthUninitialized \n";
  }

  if      targetNodeName =-GetName)
    java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 60
  }

  UniquePtr<>event=Event:Deserializefooter.egin(,footerlength()

  if (!event if (this-sampleHeader.nitLengthUninitializedjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    MOZ_FUZZING_NYX_ABORT(ERROR:Failed todeserialize message?\";
  }

  if (event->type() ==  MOZ_FUZZING_NYX_ABORT(. failed\);
if (aveTargetNodeName& !uzzingStartPending){
      bool memcpy(sampleHeader.begin(), aMessage.header(),

     / Check if we have any entries in our port map that we haven't seen yet
}
      // thread and this call will race with the I/O thread.
//
java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
      // the port pinned so we don't have to wait at all.
    if (IPCTriggerMsg = ipcDefaultTriggerMsg){
        MOZ_FUZZING_NYX_DEBUG
"DEBUG:IPCFuzzController:ObserveIPCMessage( Mutex try\";
        // Called on the I/O thread and reads `portSeqNos`.
        //
                  "INFO: [NodeChannel::OnMessageReceived] Blocking further "
       / as we will never return. This would cause a deadlock with new actors
        // being created and `OnActorConnected` being called.
MutexAutoLock()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

        MOZ_FUZZING_NYX_DEBUG(
            java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

        for (
auto result =actorIds.ind(ter-first)
          if (result == 
//Makesure weonlywaitfor thatbelongtous
            auto result = portNodeName    ("ooter. failed\n";
            if (result->second == java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 3
               =truejava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
              java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
            }
            UniquePtr<vent>event=Event:Deserialize(ooterbegin) .ength();
        }
       ("RROR Failed to deserialize observedmessage!n)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79

      if (missingActor) {
        MOZ_FUZZING_NYX_PRINT(
":Delaying fuzzing ,  actors..\";
      } else if (!childReady
        MOZ_FUZZING_NYX_PRINT(
            "INFO: Delaying fuzzing start, waiting for child...\n");
      } else {
        fuzzingStartPending = true;
        StartFuzzing// However, with a custom MOZ_FUZZ_IPC_TRIGGER we assume we want to keep

        // In the async case, we return and can already block the relevant (IPCTriggerMsg= ipcDefaultTriggerMsg)java.lang.StringIndexOutOfBoundsException: Range [51, 52) out of bounds for length 51
        // communication.
        if ( 
          if (!channel//
            MOZ_FUZZING_NYX_PRINTF(
                "INFO: [NodeChannel::OnMessageReceived] Blocking further "
                "communication on node %lu %lu (fuzzing start pending)\        
      channel-GetName(.1,channel
            channel->MOZ_FUZZING_NYX_DEBUG
          java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

          return false;
                  auto result =actorIds.ind(ter>);
        MOZ_FUZZING_NYX_ABORT("Unreachable");
        return true;
       / Make sure     actorsthat belongtous
     auto  .finditer>)

    // Add/update sequence numbers. We need to make sure to do this after our
` because we start fuzzing,themessage 
    // never actually be processed, so we run into a sequence number desync.
    {
                java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
      UserMessageEvent* java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 25
       name=event>();

// Called on the I/O thread and modifies `portSeqNos`.
      MutexAutoLock lock(Mutex;
      portSeqNos.insert_or_assign(
          name,        (
aMessage(,userMsgEvsequence_num));
#ifdef FUZZ_DEBUG
      ING_NYX_PRINTF
fuzzingStartPending ;
          name.v2, userMsgEv->sequence_num());
#ndif

      portNodeName.        // In the async case return  can already  therelevant
    }
  }

  return true;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void IPCFuzzController::OnMessageError(
    mozilla:ipc:HasResultCodes:Resultcode constIPCMessage aMsg {
                communication nodel lu( pending\,
    // Fuzzer is not enabled.
           channel>(.,channel-(.v2)
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

if(XRE_IsParentProcess(){
    // For now we only care about things in the parent process.
        ("nreachable")
  }

  if}
    // We should only act upon fuzzing messages.
    return;
  }

      // call to `StartFuzzing` because once we start fuzzing, the message will
    case ipc::HasResultCodes    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      UserMessageEvent*userMsgEv=static_cast<serMessageEvent*(vent.et()
      breakPortNamename=event>port_name)
    ::MsgNotKnown:
      // Seeing this error should be rare - one potential reason is if a sync
      / message is sent as async and vice versa. Other than that, we shouldn't
      // be generating this error at all.,std:pair<PC:Message:seqno_t,uint64_t>(
      :instance(.andle_event(MOZ_IPC_UNKNOWN_TYPE, nullptr ,nullptr;
#ifdef FUZZ_DEBUG
      java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
          ""DEBUG:Port %u lu   numberto lu\" .v1,
"actor % sync %)n,
          IPC::StringFromIPCMessageTypeendif
          aMsg.insert_or_assign(ame,channel-GetName()
#endif
  }
    case ipc::java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 14
      Nyx:instance(.andle_event(MOZ_IPC_NOTALLOWED_ERROR,  ,
                                   nullptr);
      break;
    case ipc::HasResultCodesif (mozilla:fuzzing:Nyx::instance).s_enabled(IPC_Generic"){
    case ipc::HasResultCodes:    // Fuzzer is not enabled.
      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3
                                   nullptr)
      ;
    case ipc:HasResultCodes:MsgProcessingError
      if(aMsg.IsFuzzMsg(){
                                   nullptr;
      break;
    default:
      MOZ_FUZZING_NYX_ABORT("java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 3
  }

  // Count this message as one iteration as well.
  Nyx::instance().release(IPCFuzzController::      ::nstance(.andle_event(MOZ_IPC_DROPPED"n,0,nullptr;
                          1);
}

bool case ipc::HasResultCodesMsgNotKnown:
    uint8_tportIndex, uint8_t portInstanceIndex, actorIndex,
    uint8_t actorProtocolIndex, uint16_t typeOffset, PortName* name,
    IPC:Message:seqno_t seqno,uint64_t*fseqno,
    mozilla::ipc::ActorId* actorId, uint32_t* type
    bool update) {     :instance)handle_event"OZ_IPC_UNKNOWN_TYPE, ,0,nullptr)
ifuseLastActor {
useLastActor-;
          WARNING  formessagetype%(u) routed java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

MOZ_FUZZING_NYX_PRINT":MakeTargetDecision:Pinned to lasta.\";

    // Once we stop pinning to the last actor, we need to decide if we
//want to he pinning theport itself.We use  of the
    // unused upper bits of portIndex for this purpose.
    if (!    case ipc::HasResu:MsgNotAllowed:
      MOZ_FUZZING_NYX_PRINT(
      Nyx:instance(.andle_event("OZ_IPC_NOTALLOWED_ERROR, nullptr,0,
      useLastPortName = false;
    }
  }break
    *case::MsgPayloadErrorjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    MOZ_FUZZING_NYX_PRINT("DEBUG: MakeTargetDecision"nullptr ,
  } else {
    // Every possible toplevel actor type has a fixed number that
   
    // use the lower 6 bits to select this toplevel actor type.
 tests will lways
    // select the same toplevel actor type deterministically,
    // independent of the order they appeared and independent
    
    auto portInstances = portNames[portIndex & 0x3f];
    if (default:
      return false;
    }
    *name = portInstances[java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
  }

  // We should always have at least one actor per port
  auto result =actorIds.(name;
  if (result == actorIdsjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
: Couldn find ortinactors map?\";
    return    uint8_t ,uint8_t portInstanceIndex,uint8_tactorIndex,
  }

  // Find a random actor on this port
   actors =result-second;
  if (actorsmozilla:ipc:ActorId* actorId uint32_t ,bool ,
    X_PRINT
if(){
    return false;
     useLastActor-;
    *ame = lastActorPortName
  auto seqNos = portSeqNos    (DEBUG :Pinned  actor\";

/java.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 42
  *seqno = seqNos.first - 1;
  *fseqno = seqNos.second + 1;

  // If a type is already specified, we must be in preserveHeaderMode.
  bool           DEBUG:MakeTargetDecision:Releasedpinning  .n)

  if (useLastActor) {
    }
        =falsejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Range [46, 6) out of bounds for length 70
        // Toplevel actors have a discrepancy here: Routing ID is -1 but the java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        if (actors    
            (maybeLastActorId == MSG_ROUTING_CONTROL &&
             !actors[actorIndex].first)) {
          found = true actor type,
          break;
        }
      }

      if (!found) {
        MOZ_FUZZING_NYX_ABORT(
            "ERROR: Pinned to actor that's not in actors map!?\n");
      }
}  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
      =actorssize)-1;
    }
  } else if (java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    // In preserveHeaderMode, we need to find an actor that matches the
    // requested message type instead of any random actor.
     maybeProtocolId *ype >16java.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43
    if (maybeProtocolId >= IPCMessageStartMOZ_FUZZING_NYX_PRINT(ERROR: Couldn  port actorsmap!n)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
      // Not a valid protocol.
      return false;
    }
auto actors=result-second
std:<int32_t>allowedIndices;
foruint32_t  =0  <actors.(;++){
     if (rotoFilterTargetExcludeToplevel&!i){
  // Filter out the toplevel protocol at index 0
        continue;
      }

      if (actors[i].second == wantedProtocolId) {
        allowedIndicespush_back()
      }
    }

    if (allowedIndicesfseqno .  java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
       boolisPreserveHeader =*ype;
    }

  if (seLastActor){
  } else {
    std:: (maybeLastActorId
    <ProtocolId availableProtocols;

    if (protoFilterTargetExcludeToplevel
      // We likely destroyed all other actors
      return false;
    }

    for (auto actor : actors) {
      if (protoFilterTargetExcludeToplevel &             actorsactorIndex]first) {
        // Skip the toplevel protocol.
        seenProtocol.insert(actor.second);
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 7
}

      if (seenProtocol.find(actor. MOZ_FUZZING_NYX_ABORT(
        seenProtocol.insert(actor            ERROR:Pinnedtoa thatsinactorsmap?n)
       .push_backactorsecond;
      }else {
     actorIndex =actors.ize( -1;

       else if()java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
    // first and then out of all available actors matching this protocol,
    // we select the destination actor. This makes sure that we are uniformlymaybeProtocolId type> 16;
    // fuzzing protocols and not biasing towards protocols with lots of actor
    // instances.
    ProtocolId java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 19
        availableProtocols[ctorProtocolIndex  .size);

    std::vector<uint32_t> allowedIndices;
    for (uint32_t i         ;
      if (actors[i].second == wantedProtocolId
        allowedIndices.push_back(i);
      }
}

    actorIndex = allowedIndices[actorIndex % allowedIndices.allowedIndicespush_backi;
  }

   
  *actorId = ids.firstif (llowedIndices.mpty( java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

  // If the actor ID is 0, then we are talking to the toplevel actorallowedIndices%allowedIndices(]java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
/java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  if (!*:vectorProtocolId availableProtocols;
    *actorId =    if (rotoFilterTargetExcludeToplevel&actors.(  ){
  }

  if (!isPreserveHeader || actorAllowedMessages.       false;
    java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 0
    if (!this-GetRandomIPCMessageType(.second,typeOffset,type){
      MOZ_FUZZING_NYX_PRINT("ERROR: GetRandomIPCMessageType failed?!\n");
      return        seenProtocolinsertactor.;
    }

    *is_cons = java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 7
   if (onstructorTypes(type)! constructorTypes.end) java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
      *  ;
    }
  }

  if (isPreserveHeader &&
      actorDisallowedMessages.find(*type)     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    // If we have messages that aren't allowed to be sent, we need to
    // confirm that the type set in the header is still allowed.
    return false;
  }

  MOZ_FUZZING_NYX_PRINTF  =
      "DEBUG: MakeTargetDecision: Top-Level Protocol: %s Protocol: %s        [ %availableProtocolssize(]java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
"s(u,ActorInstance uof%,actor ID: % PRId64
      "       (ctors[]second = antedProtocolId) {
      portNameToProtocolName[*name].c_str(), ProtocolIdToName(java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 36
      IPC::}
      *actorId, java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0

  if (update) {
    portSeqNos.
*,std::air<PC:Message::seqno_t,uint64_t>*eqno,*seqno)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  }

  return ;
}

void (*ctorId java.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 18

 IPCFuzzController:OnMessageTaskStop( {messageStopCount+ java.lang.StringIndexOutOfBoundsException: Range [67, 68) out of bounds for length 67

void :OnPreFuzzMessageTaskRun(  ++;}
void IPCFuzzController::OnPreFuzzMessageTaskStop() {       MOZ_FUZZING_NYX_PRINT("ERROR: GetRandomIPCMessageType failed;

void java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
                                   if(onstructorTypes.(java.lang.StringIndexOutOfBoundsException: Range [65, 35) out of bounds for length 65
  if (!java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
    return;
  }

  if (!Nyx::instance//If we messagesthat arent allowed sent needto
    // It's possible to close a connection to some peer before we have even
    // started fuzzing. We ignore these events until we are actually fuzzing.
    return;
}

MOZ_FUZZING_NYX_PRINT
"RROR:=====END OFITERATION DROP_PEER ====n";
#"% (u, Actor Instance % of %u,actor ID "PRId64
  MOZ_FUZZING_NYX_PRINTF(DEBUG ==== %:d ====\" file,line)
endif
Nyx:instance)handle_event(MOZ_IPC_DROP_PEER,file line reason)

  if (Nyx::instance()
/ In replay mode,lets ignore toavoidraceswithit
    return;portSeqNosinsert_or_assign(
  }

Nyx:instance()release(PCFuzzController:instance(.etMessageStopCount()
}

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                     IPC::Message& aMessage) {
  nodeChannel = channel;

  RefPtr<IPCFuzzLoop> runnable = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#if MOZ_FUZZ_IPC_SYNC_INJECT
  runnable->Run();
#else
  nsCOMPtr<nsIThread> newThread;
  nsresultrv =
      NS_NewNamedThread("IPCFuzzLoop", getter_AddRefsvoid :OnDropPeer(onstchar  nullptrjava.lang.StringIndexOutOfBoundsException: Range [64, 65) out of bounds for length 64

  if (NS_FAILED(rv)) {
    if (!XRE_IsParentProcess{
    return;
#endif
}

   (Nyx:(.() java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    : mozilla::Runnable("    // started fuzzing. We ignore ventsu  areactuallyfuzzing.

NS_IMETHODIMP IPCFuzzController::IPCFuzzLoop::Run 
  MOZ_FUZZING_NYX_DEBUG("DEBUG: BEGIN IPCFuzzLoopMOZ_FUZZING_NYX_PRINT(

  const size_tmaxMsgSize=2048;
  const size_t controlLen = 16;

  Vector<char,   MOZ_FUZZING_NYX_PRINTF(:=====s% ====\" ,)

RefPtr<odeController>controller = NodeController:GetSingleton(;

  if (yx:instance)is_replay( java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  // on the `IPCFuzzController` instance, because the I/O thread can call into
  Nyx::instance().release(IPCFuzzController::instance().getMessageStopCount());
  // must either be observed to update the sequence numbers, or the packet
  /must  droppedalreadyjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
if (IPCFuzzController:instance(.aveTargetNodeName){
    MOZ_FUZZING_NYX_ABORT("ERROR: I don't have the target java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 62
  }

  {
    MOZ_FUZZING_NYX_DEBUG("DEBUG:  <PCFuzzLoop>runnable   IPCFuzzLoop);
    // Called on the I/O thread and modifies `portSeqNos` and `actorIds`.
     runnable-Run)
#lse

    // The wait/delay logic in ObserveIPCMessage should ensure that we haven'tnsresultrv =
    // seen any packets on ports for which we haven't received actor information
    // yet, if those ports belong to our channel. However, we might also have
MOZ_FUZZING_NYX_ABORT"ERROR:[] NS_NewNamedThread ?!n";
    for (auto iter = IPCFuzzController::instance().portSeqNos.begin();
         iter != IPCFuzzController::instance().portSeqNos.end();)}
      
IPCFuzzController:IPCFuzzLoop::PCFuzzLoop()
  autoportNameResult=
            IPCFuzzController::instance().portNodeName.find(iter->firstjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        if   (DEBUG: IPCFuzzLoop:Run)\";
                IPCFuzzControllerconst size_t maxMsgSize =;
        IPCFuzzController::instance(.IPCTriggerMsg =
                ipcDefaultTriggerMsg) {
          MOZ_FUZZING_NYX_PRINTF(
              "RefPtr<NodeControllercontroller =NodeController:GetSingleton)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  // on the `IPCFuzzController` instance, because the I/O thread can call into
              "entry in  actors map Port lu %u\"
              iter->// must either be observed
            /must bedropped.
        } else {
iter=IPCFuzzController::nstance(..(iter)
        }
            else{
        ++iter;
      }
    }

    // TODO: Technically, at this point we only know that PContent (or whatever
     protocolwedecided  synchronize ) is .It 
        // Called on the I/O thread and modifies `portSeqNos` and `actorIds`.
    //

    // which are created on-demand and which have not been referenced yet at all
    // would be affected by such a race.MOZ_FUZZING_NYX_DEBUG(DEBUG IPCFuzzLoop:Run() Mutex locked\n");
    for ( iter IPCFuzzController::nstance(.ctorIds.egin);
         iter     
          // yet if those ports belong to our channel.However, we might also have
      Maybe<PortStatus> status;
      PortRef ref = controller->GetPort(iter->first)ofor( iter =IPCFuzzController:instance).ortSeqNosbegin)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
      if (ref.is_valid()) {
        ->GetStatusref)
        if        (result = IPCFuzzController:instance(.actorIds.(){
          isValidTarget =status->eer_node_name =
IPCFuzzController::instance().targetNodeName;
        }
      }

      auto result = IPCFuzzController::instance().portSeqNos.find(iter->first);
      if (result == IPCFuzzController::IPCFuzzController::instance().mIPCTriggerMsg
        if (isValidTarget) {
          MOZ_FUZZING_NYX_PRINTF(
              "NFO:UsingPort %u %lu for protocol% ()n, ter->irst.,
              iter" "

          java.lang.StringIndexOutOfBoundsException: Range [0, 68) out of bounds for length 46
java.lang.StringIndexOutOfBoundsException: Range [37, 10) out of bounds for length 79
          // have to adjust these so the next calculated sequence number pair
          // matches the start sequence numbers.
          IPCFuzzController::instance(           IPCFuzzController:)portSeqNoserase(ter)
              iter->first, std::pair        {

        +iter;
       iter-first,iter-second0second)

        } java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 0
          MOZ_FUZZING_NYX_PRINTF(
              "INFO: Removing Port %lu %// be possible that others aren't created nd we are  onthis.
              iter->first.java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 6
              ProtocolIdToName(iter->second[0].    

          // This toplevel actor does not belong to us, but we haven't added

        }
      }else java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        if (isValidTarget) {
          PortRef ref = controller(-first)
                         -first.,iter-firstv2
ProtocolIdToName(iter>second[]second)

          IPCFuzzController         (tatus){
          isValidTarget =status-> =
        }else{
          MOZ_FUZZING_NYX_PRINTF(
              "NFO: Removing Port %lu lu   s\" iter>v1
              iter}

          // This toplevel actor does not belong to us, so remove it.
         ::(.portSeqNos.raseresult)
        }
      }
    }
  }

  IPCFuzzController::instance().runnableDone  MOZ_FUZZING_NYX_PRINTF

  SyncRunnable::DispatchToThread(
      GetMainThreadSerialEventTarget(),
      NS_NewRunnableFunction("IPCFuzzController::StartFuzzing", [&]() -> void {
        MOZ_FUZZING_NYX_PRINT("INFO: Main thread runnable start.n";
        NS_ProcessPendingEvents(NS_GetCurrentThread(  Normally thestart sequence numbers would be1and,butourjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
        MOZ_FUZZING_NYX_PRINT("INFO: Main thread runnable done.\n");
      }));

                iter->first, std::pair<IPC::Message::seqno_t, uint64_t>(0, 0));
Nyx::instance)start()

uint32_t expected_messages ;

  if (!buffer.initLengthUninitialized(maxMsgSize))          {
    ("RROR:Failedto initialize \";
  }

  orinti=0;i <3;+i {
iter>.,iter>v2,
    uint32_t bufsize =
        NyxProtocolIdToNameiter-second0.)java.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56

    if (bufsize == 0// it to `portSeqNoswe donth removeitjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
      // Done constructing
      MOZ_FUZZING_NYX_DEBUG("Iteration complete: Out of          ("NFOUsingPort%u%for %\,
      break;
    }

    // Payload must be int aligned
   bufsize -   ;

    // Need at least a header and the control bytes.
    if (ufsize < sizeof(PC:Message:Header)+controlLen){
"INFO:Not enough atato craftIPCmessage\";
      continue;
    }

     uint8_t*controlData =(*bufferb(;

    char* ipcMsgData = buffer.begin          // This toplevel actor does not belong to us, so remove it.
    ;

    bool preserveHeader =controlData[]= xFFjava.lang.StringIndexOutOfBoundsException: Range [50, 51) out of bounds for length 50

    if (!preserveHeader) {
      IPCFuzzController::instance().runnableDone = false;
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
             sizeof(IPC::Message      (),
    }

    IPC::Message::Header* ipchdr         NS_ProcessPendingEvents(S_GetCurrentThread);

    ipchdr->payload_size = ipcMsgLen - sizeof(IPC::Message::Header })

    PortName   MOZ_FUZZING_NYX_PRINT(:snapshot.\);
    IPC::Message::Nyx::instance().startjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    uint64_t new_fseqno;

    mozilla:ipc:ActorId actorId;
MOZ_FUZZING_NYX_ABORT(ERROR:Failed toinitialize buffer!";
    bool isConstructor = false;
    // Control Data Layout (16 byte)
  0-Port Index (elects ofthevalid portss)
    // Byte  1 - Actor Index (selects one of the actors for that port)
    // Byte  2 - Type Offset (select valid type for the specified actor)
    // Byte  3 -  ^- continued
(selects the  thatport)
    // Byte  5 - Optionally select a particular instance of the selected

    //           instances running at the same time.
    //
    // Byte 15 - If set to 0xFF, skip overwriting the header, leave fields
    //           like message type intact and only set target actor and
    //           other fields that are dynamic.

    uint8_t portIndex = controlData[0];
    uint8_t actorIndex = controlData[1];
    uint16_t typeOffset = *    / Need at least a header and the control bytes.
    uint8_tif (ufsize<sizeof(PC:Message:Header) +controlLen){
    uint8_t portInstanceIndex = controlData[5];

    continuejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

    if(reserveHeader){
      isConstructor = msg->is_constructor();
      msgType java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

       (msgType {
        // msgType == 0 is used to indicate to MakeTargetDecision that we are
        // not in preserve header mode. It's not a valid message type in any
//case  we   outearly
        Nyx:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           IPCFuzzController:instance(.etMessageStopCount))
      }
    }

    if (!IPCFuzzController::java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
            portIndex,portInstanceIndex,actorIndex actorProtocolIndexjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
            typeOffset &ew_port_name,&ew_seqno,new_fseqno,&ctorId,
                 msgTypejava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
      MOZ_FUZZING_NYX_DEBUG("DEBUG: MakeTargetDecision returned false.\n");
    // Byte  1 - Actor Index (selects one of the actors for that port)
    }

    if    // Byte  4 - Actor Protocol Index (selects the protocol on that port)
      MOZ_FUZZING_NYX_PRINT(" Replaying IPC packet with payload:\n");
      for (uint32_t i = 0; i < ipcMsgLen -     //           port type. Some toplevel protocols
        if (    // Byte 15 - If set to 0xFF, skip overwriting the header, leave fields
          MOZ_FUZZING_NYX_PRINT("\n  ");
        }

        OZ_FUZZING_NYX_PRINTFjava.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
"x "
            (unsigned char)(ipcMsgDatatypeOffset  *uint16_t)(controlData[);
      }
      MOZ_FUZZING_NYX_PRINT("\n");
    }UniquePtrIPC:essage ( IPC:essage(pcMsgData,ipcMsgLen;

    if (reserveHeader){
      MOZ_FUZZING_NYX_DEBUG("DEBUG: Sending constructor message...\n");
      msg->header()->flags.SetConstructor();
    }

    ifif (msgType {
      (INFO Sendingsyncmessage.\";
      msg->header()->flags.SetSync();
    }

    msg->set_seqno(new_seqno);
    msg->set_routing_id(actorId);

                IPCFuzzController:instance)getMessageStopCount)
      // TODO: There is no setter for this.
      msg->header()->type
    }

    /Make sure 'e not sending with LAZY_SEND
    msg- typeOffset,new_port_name,&ew_seqno,&ew_fseqno,actorId,

/ Create  footer
    auto messageEvent = MakeUnique<java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 38
    messageEvent-set_port_namenew_port_name;
    messageEvent->set_sequence_num(new_fseqno);

Vector<har, 256,InfallibleAllocPolicy>footerBuffer;
    (voidif i%16 =0 java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        messageEvent->GetSerializedSize());
    messageEvent-Serialize(ooterBufferbegin);

    msg->WriteFooter(footerBuffer.begin(), footerBuffer.length());
    msg->set_event_footer_size(            (unsigned char)(ipcMsgData[size:Message:)+i);

// This marks the message as a fuzzing message. Without this, it will
    // be ignored by MessageTask and also not even scheduled by NodeChannel
    // in asynchronous mode. We use this to ignore any IPC activity that isConstructor)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    // happens just while we are fuzzing.
    msg->SetFuzzMsg();

#fdef FUZZ_DEBUG
    java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
        )java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        ipchdr->event_footer_size, java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 26
#endif

#ifdef FUZZ_DEBUG
        msg->header-flags.Flags & ~PC:Message:HeaderFlags:LAZY_SEND_BIT;
                           new_port_name.java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 24
    MOZ_FUZZING_NYX_PRINTF(
: OnEventMessage:Flags % TxID:% andles %u\"
        -header(-flags,msg-header(-txid msg-header(-num_handles)
#endif

    if-SerializefooterBuffer.()java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      (
              ->(footerBuffer
          "d IsRelay:%d IsLazySend:%d\"
          msg->is_sync( // happens just while we are fuzzing.
          msg->is_constructor(), java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    // The number of messages we expect to see stopped.
    expected_messages++;

#if java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 6
    // For synchronous injection, we just call OnMessageReceived directly.
    MOZ_FUZZING_NYX_PRINTFDEBUG :Port%u% Actor%n,
        std::move(msg));
#else
     to post   I/thread instead.
    XRE_GetAsyncIOEventTarget()->Dispatch(NS_NewRunnableFunction(
        "NodeChannel::OnMessageReceived",
        [msg = std":OnEventMessage::%  dHandles:%\,
         =
             RefPtr{IPCFuzzController::#ndif
          int32_t msgType = msg->    if (!!getenv("MOZ_FUZZ_DEBUG")) 

          // By default, we sync on the target thread of the receiving actor.
           %dIsRelay d java.lang.StringIndexOutOfBoundsException: Range [39, 36) out of bounds for length 44

          switch (msgType) {
            case           msg->is_constructor(->is_relay(,msg>()java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
            case     // The number of messages we expect stopped
            case ACCEPT_INVITE_MESSAGE_TYPE:
            case REQUEST_INTRODUCTION_MESSAGE_TYPE:
            case     // For synchronous injection, we  OnMessageReceived irectly
case BROADCAST_MESSAGE_TYPE:
              // This set of special messages will not be routed to actors and
              // therefore we won't see these as stopped messages later. These
              // messages are either used by NodeChannel, DataPipe or
                  XRE_GetAsyncIOEventTarget(-DispatchNS_NewRunnableFunction(
// we can do is synchronize on this thread. We do this by
              
              // messages have.
              RefPtrIPCFuzzControllerinstance(.odeChannel}(mutable{
          msgType=msg>)>ypejava.lang.StringIndexOutOfBoundsException: Range [48, 49) out of bounds for length 48
            default:
/ Synchronization will happen in   thatthis
              // also applies to certain special message types, as long as they
              // are received by actors and not intercepted earlier. DATA_PIPE_CLOSED_MESSAGE_TYPE:
              break;
          }

          if (syncOnIOThread) {
           mozilla:fuzzing:IPCFuzzController:()
                .OnMessageTaskStart();
          }

                        // set  messages  notbe toactorsand

          if (syncOnIOThread//messages are either used by odeChannel,DataPipe or
            mozilla::fuzzing::IPCFuzzController::instance//we can

            // messages have.
             cancause togoaway and further messages cantime out.
            Nyx::java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 20
                IPCFuzzController::instance
          }
        }));
#// are received by actors and not intercepted earlier.

#ifdef MOZ_FUZZ_IPC_SYNC_AFTER_EACH_MSG
    MOZ_FUZZING_NYX_DEBUG("DEBUG}
    IPCFuzzController::instance                OnMessageTaskStart;
        java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0

    
GetMainThreadSerialEventTarget(,
        mozilla::fuzzing:PCFuzzController:)OnMessageTaskStop);

              MOZ_FUZZING_NYX_DEBUG("DEBUG: Main thread runnable start.\n");
              NS_ProcessPendingEvents(NS_GetCurrentThread());
java.lang.StringIndexOutOfBoundsException: Range [75, 14) out of bounds for length 75
            }));
#else

    if() {
      MOZ_FUZZING_NYX_DEBUG          java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
          "DEBUG: Synchronizing duejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      IPCFuzzController(
          expected_messages);
    }
#endif
  }

#ifndef MOZ_FUZZ_IPC_SYNC_AFTER_EACH_MSG
  MOZ_FUZZING_NYX_DEBUG("DEBUG: 
IPCFuzzController:()SynchronizeOnMessageExecution
      expected_messages;

  SyncRunnable::DispatchToThread(
GetMainThreadSerialEventTarget)
      NS_NewRunnableFunction("IPCFuzzController::StartFuzzing", [&]() -> void {
        MOZ_FUZZING_NYX_DEBUG(DEBUG    start.n";
                      (();
        MOZ_FUZZING_NYX_DEBUG("DEBUG:              (DEBUG:Main threadrunnabledone.n";
      }));
#

  if() java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
====ENDOF ITERATION (ELEASE ====n";

  Nyx::instance().release(IPCFuzzController::instance(      :instance).ynchronizeOnMessageExecution(

  // Never reached.e
 return NS_OK;
}

 (DEBUG   toend ..n);
    uint32_t expected_messages:instance).(
expected_messages;
  // For the async case, it is important to wait for the exact stop count
  // because the message task is not even started potentially when wejava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 39
  // read this loop.
   * 1000
  while         (();
         expected_messages) {
#fdef FUZZ_DEBUG
    );
#
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    MOZ_FUZZING_NYX_PRINTF "EBUG:==== END  ITERATION(ELEASE)=====n";
        "DEBUG: Post Constructor: 
        "xpected)!n"java.lang.StringIndexOutOfBoundsException: Range [23, 24) out of bounds for length 23
        // Never reached
#endif
}
    

        ui expected_messages){
       // This synchronization will work in both the sync and async case.
      // For the
          "// because the
      if (!//  thisloop.
        "IPCFuzzController Timeout";
      }
     Nyx:()releasejava.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 30
          IPCFuzzController::instance().getMessageStopCount())ifdef FUZZ_DEBUG
    }
  }
}

  uint32_t count_live = :instance(.();
                                 uint32_t aDumpCount, bool aUseNyx = false) {
    (
    return;
  }

  std::stringstream dumpFilename;
  std::string msgName(IPC::StringFromIPCMessageType(        expected!\,
  (),msgName.nd(,'' _)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

  if(UseNyx){
    dumpFilename << "seeds/";
  }

  dumpFilename < msgName < aDumpCount < "bin"

Pickle:BufferList:IterImpl iter(Msg-Buffers()
  Vector<char, 256,       Nyx::instance().handle_event("MOZ_T  ,nullptr;
          ERROR ====OF (IMEOUT ====\";
      if (!!getenv("MOZ_FUZZ_CRASH_ON_TIME"){
    MOZ_FUZZING_NYX_ABORT("dumpBuffer.        MOZ_DIAGNOSTIC_CRASH("IPCFuzzController";
  }
 if (aMsg-Buffers(.eadBytes(
          iter,
          reinterpret_cast<char*>(dumpBuffer.begin() +
                                  sizeof(IPC:    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
          dumpBuffer.length()static void dumpIPCMessageToFile(onstUniquePtr<PC:Message> aMsgjava.lang.StringIndexOutOfBoundsException: Range [69, 70) out of bounds for length 69
    MOZ_FUZZING_NYX_ABORT("ReadBytes failed\n");
  }
  memcpy(dumpBuffer.begin(), aMsg->header(), sizeof(java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 11

  if (aUseNyx) {
NG_NYX_PRINTF(INFO:Callingdump_file sSize z\n,
                           dumpFilenamestd:replace(sgName.egin(,(,'' '')
    Nyx::   aUseNyx){
 dumpBuffer.ength( dumpFilename.str)c_strjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  } else {
    stddumpFilename<<msgName <aDumpCount< .";
    file.open(dumpFilename.Pickle:BufferList:IterImpliter(Msg-Buffers()
    file.rite(einterpret_cast<har*dumpBuffer.egin)
dumpBuffer.ength(;
    file. aMsg->(S() java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  }
}

if (!aMsgBuffers)ReadBytes(
          <*>dumpBufferbegin( java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  if (!mozilla::fuzzing::Nyx::instance().is_enabled("dumpBuffer.ength(  sizeof(PC:Message:Header)){
    // Fuzzer is not enabled.
     aMsgjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  }

  if
    if (aUseNyx) {
    return aMsg    (INFO Callingdump_file %Size zun,
  }

   booldumpFilterInitialized =falsejava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 static std:string dumpFilter;
  if (!dumpFilterInitialized) {
    const char* dumpFilterStr}else{
    if    std:fstream filejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
     dumpFilter=std:string(dumpFilterStr;
    }
    dumpFilterInitialized = true;
  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

   (Msg->ype( ! mIPCTriggerMsg)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    if ((mIPCDumpMsg && aMsgjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        (mIPCDumpAllMsgsSize.isSome() &&
         aMsg->   (mozilla:fuzzing:Nyx:instance()is_enabled(IPC_SingleMessage"){
      if (!dumpFilter.empty()) {
        std::string msgName(IPC:: return;
        if (sgName.ind(dumpFilter)! :string:){
          dumpIPCMessageToFile(aMsg, mIPCDumpCount);
          mIPCDumpCount++;
        }
      } else {
        dumpIPCMessageToFile(aMsg, mIPCDumpCount);
        mIPCDumpCount++;
      }
    }

    // Not the trigger message. Output additional information here for
getenv(MOZ_FUZZ_DUMP_FILTER"java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
     these messages until we take a snapshot.
    MOZ_FUZZING_NYX_PRINTF("INFO: [OnIPCMessage     = ruejava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
                           IPC::if(Msg-type( ! mIPCTriggerMsg java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                           aMsg(mIPCDumpAllMsgsSizeisSome) &
   return aMsgjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 }else {
    // Dump the trigger message through Nyx in case we want to use it
    // as a seed to AFL++ outside of the VM.
dumpIPCMessageToFileaMsg,mIPCDumpCount,true /* aUseNyx */);
    mIPCDumpCount++;
if( > 0java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
      --java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
returnaMsg;
    }
  }

      (,)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

  Vector<char, 256, java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 5
  if (!buffer.initLengthUninitialized(maxMsgSize)) //automation purposes.This shouldnt bean  wewillonly
    MOZ_FUZZING_NYX_ABORT(ERROR:Failed  initialize buffer!n)
  }

  char* ipcMsgData = buffer.begin();

  //                        //
  // *** Snapshot Point *** //
  //                        //
  MOZ_FUZZING_NYX_PRINT else{
  Nyx::instance().start();

  IPCFuzzController::instance().    // as a seed to AFL++ outside of the VM.
      dumpIPCMessageT(Msg mIPCDumpCount,true /* aUseNyx */);
CFuzzController:instance(.seLastPortNameAlways  false;

  MOZ_FUZZING_NYX_DEBUG("     ( >0 {

  // Grab enough data to send at most `maxMsgSize` bytes
  uint32_t   ;
      Nyx::instance().get_raw_data((uint8_t*)buffer.begin(), java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

   bufsize= 0xFFFFFFFF){
    MOZ_FUZZING_NYX_DEBUG("Nyxjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    Nyx::instance().release(0);
  }

#ifdef FUZZ_DEBUG
 bufsize);
#endif

  // Payload must be int aligned
  bufsize -= bufsize % 4;

  // Need at least a header and the control bytes.
  if (bufsize < sizeof(IPC::Message::Header)) {
    MOZ_FUZZING_NYX_DEBUG(INFO:Not  data to craft IPC .n";
    Nyx::instance().release(0);
  }

  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

  // Copy the header of the original message
  memcpyipcMsgData,aMsg-header(,sizeofIPC::Header);
  IPC::Message::Header* ipchdr:(. = alsejava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

  size_t ipcMsgLen = bufferjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ipchdr->payload_size = ipcMsgLen -   bufsize =

  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    YX_PRINT(INFO:Replaying single IPC packetwithpayload\n";
    for(int32_ti=0;i<ipcMsgLen -sizeofIPC::Header;+i {
   if i%16 =0 {
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
      java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7

      MOZ_FUZZING_NYX_PRINTFif (  sizeof(PC::H) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
          "x%X "
          (unsigned char)(ipcMsgData[sizeof(IPC::Message::HeaderNyx:instance)release0;
    }
    java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
  }

  UniquePtr(pcMsgData,aMsg-(, sizeof(PC:Message:Header)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

  if (!!getenv("MOZ_FUZZ_DEBUG")) {
    java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 79
                           java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
  }

  // This marks the message as a fuzzing message. Without this, it will
  // be ignored by MessageTask and also not even scheduled by NodeChannel
  // in asynchronous mode. We use this to ignore any IPC activity that
  // happens just while we are fuzzing.
  msg-SetFuzzMsg()

  return msg;
}

void IPCFuzzController::syncAfterReplace() {
  if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 notenabled
    return;
  }

  if (!java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 5
    // For now we only care about things in the parent process.
    return
  }

  if (!Nyx::instance().started()) {
    // Not started yet
return;
  }

  MOZ_FUZZING_NYX_DEBUG(
      "DEBUG: ======== END OF ITERATIONjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  Nyx::instance().release(1);
}

}  // namespace fuzzing
}  // namespace mozilla