Proyectos de Subversion Iphone Microlearning

// Copyright 2019 Google

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//      http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

#import <Foundation/Foundation.h>

#include "Crashlytics/Crashlytics/Handlers/FIRCLSException.h"

#import "Crashlytics/Crashlytics/Private/FIRExceptionModel_Private.h"

#import "Crashlytics/Crashlytics/Private/FIRStackFrame_Private.h"

#include "Crashlytics/Crashlytics/Components/FIRCLSApplication.h"

#include "Crashlytics/Crashlytics/Components/FIRCLSContext.h"

#include "Crashlytics/Crashlytics/Components/FIRCLSGlobals.h"

#include "Crashlytics/Crashlytics/Components/FIRCLSProcess.h"

#import "Crashlytics/Crashlytics/Components/FIRCLSUserLogging.h"

#include "Crashlytics/Crashlytics/Handlers/FIRCLSHandler.h"

#include "Crashlytics/Crashlytics/Helpers/FIRCLSFile.h"

#import "Crashlytics/Crashlytics/Helpers/FIRCLSLogger.h"

#import "Crashlytics/Crashlytics/Helpers/FIRCLSUtility.h"

#import "Crashlytics/Crashlytics/Controllers/FIRCLSReportManager_Private.h"

#import "Crashlytics/Crashlytics/Models/FIRCLSExecutionIdentifierModel.h"

#import "Crashlytics/Crashlytics/Models/FIRCLSFileManager.h"

#import "Crashlytics/Crashlytics/Models/FIRCLSInternalReport.h"

#include "Crashlytics/Crashlytics/Operations/Symbolication/FIRCLSDemangleOperation.h"

// C++/Objective-C exception handling

#include <cxxabi.h>

#include <exception>

#include <string>

#include <typeinfo>

#if !TARGET_OS_IPHONE

#import <AppKit/NSApplication.h>

#import <objc/runtime.h>

#endif

#pragma mark Prototypes

static void FIRCLSTerminateHandler(void);

#if !TARGET_OS_IPHONE

void FIRCLSNSApplicationReportException(id self, SEL cmd, NSException *exception);

typedef void (*NSApplicationReportExceptionFunction)(id, SEL, NSException *);

static BOOL FIRCLSIsNSApplicationCrashOnExceptionsEnabled(void);

static NSApplicationReportExceptionFunction FIRCLSOriginalNSExceptionReportExceptionFunction(void);

static Method FIRCLSGetNSApplicationReportExceptionMethod(void);

#endif

#pragma mark - API

void FIRCLSExceptionInitialize(FIRCLSExceptionReadOnlyContext *roContext,

                               FIRCLSExceptionWritableContext *rwContext) {

  if (!FIRCLSUnlinkIfExists(roContext->path)) {

    FIRCLSSDKLog("Unable to reset the exception file %s\n", strerror(errno));

  }

  roContext->originalTerminateHandler = std::set_terminate(FIRCLSTerminateHandler);

#if !TARGET_OS_IPHONE

  // If FIRCLSApplicationSharedInstance is null, we don't need this

  if (FIRCLSIsNSApplicationCrashOnExceptionsEnabled() && FIRCLSApplicationSharedInstance()) {

    Method m = FIRCLSGetNSApplicationReportExceptionMethod();

    roContext->originalNSApplicationReportException =

        (void *)method_setImplementation(m, (IMP)FIRCLSNSApplicationReportException);

  }

#endif

  rwContext->customExceptionCount = 0;

}

void FIRCLSExceptionRecordModel(FIRExceptionModel *exceptionModel) {

  const char *name = [[exceptionModel.name copy] UTF8String];

  const char *reason = [[exceptionModel.reason copy] UTF8String] ?: "";

  FIRCLSExceptionRecord(FIRCLSExceptionTypeCustom, name, reason, [exceptionModel.stackTrace copy]);

}

NSString *FIRCLSExceptionRecordOnDemandModel(FIRExceptionModel *exceptionModel,

                                             int previousRecordedOnDemandExceptions,

                                             int previousDroppedOnDemandExceptions) {

  const char *name = [[exceptionModel.name copy] UTF8String];

  const char *reason = [[exceptionModel.reason copy] UTF8String] ?: "";

  return FIRCLSExceptionRecordOnDemand(FIRCLSExceptionTypeCustom, name, reason,

                                       [exceptionModel.stackTrace copy], exceptionModel.isFatal,

                                       previousRecordedOnDemandExceptions,

                                       previousDroppedOnDemandExceptions);

}

void FIRCLSExceptionRecordNSException(NSException *exception) {

  FIRCLSSDKLog("Recording an NSException\n");

  NSArray *returnAddresses = [exception callStackReturnAddresses];

  NSString *name = [exception name];

  NSString *reason = [exception reason] ?: @"";

  // It's tempting to try to make use of callStackSymbols here.  But, the output

  // of that function is not intended to be machine-readible.  We could parse it,

  // but that isn't really worthwhile, considering that address-based symbolication

  // needs to work anyways.

  // package our frames up into the appropriate format

  NSMutableArray *frames = [NSMutableArray new];

  for (NSNumber *address in returnAddresses) {

    [frames addObject:[FIRStackFrame stackFrameWithAddress:[address unsignedIntegerValue]]];

  }

  FIRCLSExceptionRecord(FIRCLSExceptionTypeObjectiveC, [name UTF8String], [reason UTF8String],

                        frames);

}

static void FIRCLSExceptionRecordFrame(FIRCLSFile *file, FIRStackFrame *frame) {

  FIRCLSFileWriteHashStart(file);

  FIRCLSFileWriteHashEntryUint64(file, "pc", [frame address]);

  NSString *string = [frame symbol];

  if (string) {

    FIRCLSFileWriteHashEntryHexEncodedString(file, "symbol", [string UTF8String]);

  }

  FIRCLSFileWriteHashEntryUint64(file, "offset", [frame offset]);

  string = [frame library];

  if (string) {

    FIRCLSFileWriteHashEntryHexEncodedString(file, "library", [string UTF8String]);

  }

  string = [frame fileName];

  if (string) {

    FIRCLSFileWriteHashEntryHexEncodedString(file, "file", [string UTF8String]);

  }

  FIRCLSFileWriteHashEntryUint64(file, "line", [frame lineNumber]);

  FIRCLSFileWriteHashEnd(file);

}

static bool FIRCLSExceptionIsNative(FIRCLSExceptionType type) {

  return type == FIRCLSExceptionTypeObjectiveC || type == FIRCLSExceptionTypeCpp;

}

static const char *FIRCLSExceptionNameForType(FIRCLSExceptionType type) {

  switch (type) {

    case FIRCLSExceptionTypeObjectiveC:

      return "objective-c";

    case FIRCLSExceptionTypeCpp:

      return "c++";

    case FIRCLSExceptionTypeCustom:

      return "custom";

    default:

      break;

  }

  return "unknown";

}

void FIRCLSExceptionWrite(FIRCLSFile *file,

                          FIRCLSExceptionType type,

                          const char *name,

                          const char *reason,

                          NSArray<FIRStackFrame *> *frames) {

  FIRCLSFileWriteSectionStart(file, "exception");

  FIRCLSFileWriteHashStart(file);

  FIRCLSFileWriteHashEntryString(file, "type", FIRCLSExceptionNameForType(type));

  FIRCLSFileWriteHashEntryHexEncodedString(file, "name", name);

  FIRCLSFileWriteHashEntryHexEncodedString(file, "reason", reason);

  FIRCLSFileWriteHashEntryUint64(file, "time", time(NULL));

  if ([frames count]) {

    FIRCLSFileWriteHashKey(file, "frames");

    FIRCLSFileWriteArrayStart(file);

    for (FIRStackFrame *frame in frames) {

      FIRCLSExceptionRecordFrame(file, frame);

    }

    FIRCLSFileWriteArrayEnd(file);

  }

  FIRCLSFileWriteHashEnd(file);

  FIRCLSFileWriteSectionEnd(file);

}

void FIRCLSExceptionRecord(FIRCLSExceptionType type,

                           const char *name,

                           const char *reason,

                           NSArray<FIRStackFrame *> *frames) {

  if (!FIRCLSContextIsInitialized()) {

    return;

  }

  bool native = FIRCLSExceptionIsNative(type);

  FIRCLSSDKLog("Recording an exception structure (%d)\n", native);

  // exceptions can happen on multiple threads at the same time

  if (native) {

    dispatch_sync(_firclsExceptionQueue, ^{

      const char *path = _firclsContext.readonly->exception.path;

      FIRCLSFile file;

      if (!FIRCLSFileInitWithPath(&file, path, false)) {

        FIRCLSSDKLog("Unable to open exception file\n");

        return;

      }

      FIRCLSExceptionWrite(&file, type, name, reason, frames);

      // We only want to do this work if we have the expectation that we'll actually crash

      FIRCLSHandler(&file, mach_thread_self(), NULL);

      FIRCLSFileClose(&file);

    });

  } else {

    FIRCLSUserLoggingWriteAndCheckABFiles(

        &_firclsContext.readonly->logging.customExceptionStorage,

        &_firclsContext.writable->logging.activeCustomExceptionPath, ^(FIRCLSFile *file) {

          FIRCLSExceptionWrite(file, type, name, reason, frames);

        });

  }

  FIRCLSSDKLog("Finished recording an exception structure\n");

}

// Prepares a new active report for on-demand delivery and returns the path to the report.

// Should only be used for platforms in which exceptions do not crash the app (flutter, Unity, etc).

NSString *FIRCLSExceptionRecordOnDemand(FIRCLSExceptionType type,

                                        const char *name,

                                        const char *reason,

                                        NSArray<FIRStackFrame *> *frames,

                                        BOOL fatal,

                                        int previousRecordedOnDemandExceptions,

                                        int previousDroppedOnDemandExceptions) {

  if (!FIRCLSContextIsInitialized()) {

    return nil;

  }

  FIRCLSSDKLog("Recording an exception structure on demand\n");

  FIRCLSFileManager *fileManager = [[FIRCLSFileManager alloc] init];

  // Create paths for new report.

  NSString *currentReportPath =

      [NSString stringWithUTF8String:_firclsContext.readonly->initialReportPath];

  NSString *newReportID = [[[FIRCLSExecutionIdentifierModel alloc] init] executionID];

  NSString *newReportPath = [fileManager.activePath stringByAppendingPathComponent:newReportID];

  NSString *customFatalIndicatorFilePath =

      [newReportPath stringByAppendingPathComponent:FIRCLSCustomFatalIndicatorFile];

  NSString *newKVPath =

      [newReportPath stringByAppendingPathComponent:FIRCLSReportInternalIncrementalKVFile];

  // Create new report and copy into it the current state of custom keys and log and the sdk.log,

  // binary_images.clsrecord, and metadata.clsrecord files.

  NSError *error = nil;

  BOOL copied = [fileManager.underlyingFileManager copyItemAtPath:currentReportPath

                                                           toPath:newReportPath

                                                            error:&error];

  if (error || !copied) {

    FIRCLSSDKLog("Unable to create a new report to record on-demand exeption.");

    return nil;

  }

  // Once the report is copied, remove non-fatal events from current report.

  if ([fileManager

          fileExistsAtPath:[NSString stringWithUTF8String:_firclsContext.readonly->logging

                                                              .customExceptionStorage.aPath]]) {

    [fileManager

        removeItemAtPath:[NSString stringWithUTF8String:_firclsContext.readonly->logging

                                                            .customExceptionStorage.aPath]];

  }

  if ([fileManager

          fileExistsAtPath:[NSString stringWithUTF8String:_firclsContext.readonly->logging

                                                              .customExceptionStorage.bPath]]) {

    [fileManager

        removeItemAtPath:[NSString stringWithUTF8String:_firclsContext.readonly->logging

                                                            .customExceptionStorage.bPath]];

  }

  *_firclsContext.readonly->logging.customExceptionStorage.entryCount = 0;

  _firclsContext.writable->exception.customExceptionCount = 0;

  // Record how many on-demand exceptions occurred before this one as well as how many were dropped.

  FIRCLSFile kvFile;

  if (!FIRCLSFileInitWithPath(&kvFile, [newKVPath UTF8String], true)) {

    FIRCLSSDKLogError("Unable to open k-v file\n");

    return nil;

  }

  FIRCLSFileWriteSectionStart(&kvFile, "kv");

  FIRCLSFileWriteHashStart(&kvFile);

  FIRCLSFileWriteHashEntryHexEncodedString(&kvFile, "key",

                                           [FIRCLSOnDemandRecordedExceptionsKey UTF8String]);

  FIRCLSFileWriteHashEntryHexEncodedString(

      &kvFile, "value",

      [[[NSNumber numberWithInt:previousRecordedOnDemandExceptions] stringValue] UTF8String]);

  FIRCLSFileWriteHashEnd(&kvFile);

  FIRCLSFileWriteSectionEnd(&kvFile);

  FIRCLSFileWriteSectionStart(&kvFile, "kv");

  FIRCLSFileWriteHashStart(&kvFile);

  FIRCLSFileWriteHashEntryHexEncodedString(&kvFile, "key",

                                           [FIRCLSOnDemandDroppedExceptionsKey UTF8String]);

  FIRCLSFileWriteHashEntryHexEncodedString(

      &kvFile, "value",

      [[[NSNumber numberWithInt:previousDroppedOnDemandExceptions] stringValue] UTF8String]);

  FIRCLSFileWriteHashEnd(&kvFile);

  FIRCLSFileWriteSectionEnd(&kvFile);

  FIRCLSFileClose(&kvFile);

  // If the event was fatal, write out an empty file to indicate that the report contains a fatal

  // event. This is used to report events to Analytics for CFU calculations.

  if (fatal && ![fileManager createFileAtPath:customFatalIndicatorFilePath

                                     contents:nil

                                   attributes:nil]) {

    FIRCLSSDKLog("Unable to create custom exception file. On demand exception will not be logged "

                 "with analytics.");

  }

  // Write out the exception in the new report.

  const char *newActiveCustomExceptionPath =

      fatal ? [[newReportPath stringByAppendingPathComponent:FIRCLSReportExceptionFile] UTF8String]

            : [[newReportPath stringByAppendingPathComponent:FIRCLSReportCustomExceptionAFile]

                  UTF8String];

  FIRCLSFile file;

  if (!FIRCLSFileInitWithPath(&file, newActiveCustomExceptionPath, true)) {

    FIRCLSSDKLog("Unable to open log file for on demand custom exception\n");

    return nil;

  }

  FIRCLSExceptionWrite(&file, type, name, reason, frames);

  FIRCLSHandler(&file, mach_thread_self(), NULL);

  FIRCLSFileClose(&file);

  // Return the path to the new report.

  FIRCLSSDKLog("Finished recording on demand exception structure\n");

  return newReportPath;

}

// Ignore this message here, because we know that this call will not leak.

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Winvalid-noreturn"

void FIRCLSExceptionRaiseTestObjCException(void) {

  [NSException raise:@"CrashlyticsTestException"

              format:@"This is an Objective-C exception used for testing."];

}

void FIRCLSExceptionRaiseTestCppException(void) {

  throw "Crashlytics C++ Test Exception";

}

#pragma clang diagnostic pop

static const char *FIRCLSExceptionDemangle(const char *symbol) {

  return [[FIRCLSDemangleOperation demangleCppSymbol:symbol] UTF8String];

}

static void FIRCLSCatchAndRecordActiveException(std::type_info *typeInfo) {

  if (!FIRCLSIsValidPointer(typeInfo)) {

    FIRCLSSDKLog("Error: invalid parameter\n");

    return;

  }

  const char *name = typeInfo->name();

  FIRCLSSDKLog("Recording exception of type '%s'\n", name);

  // This is a funny technique to get the exception object. The inner @try

  // has the ability to capture NSException-derived objects. It seems that

  // c++ trys can do that in some cases, but I was warned by the WWDC labs

  // that there are cases where that will not work (like for NSException subclasses).

  try {

    @try {

      // This could potentially cause a call to std::terminate() if there is actually no active

      // exception.

      throw;

    } @catch (NSException *exception) {

#if TARGET_OS_IPHONE

      FIRCLSExceptionRecordNSException(exception);

#else

      // There's no need to record this here, because we're going to get

      // the value forward to us by AppKit

      FIRCLSSDKLog("Skipping ObjC exception at this point\n");

#endif

    }

  } catch (const char *exc) {

    FIRCLSExceptionRecord(FIRCLSExceptionTypeCpp, "const char *", exc, nil);

  } catch (const std::string &exc) {

    FIRCLSExceptionRecord(FIRCLSExceptionTypeCpp, "std::string", exc.c_str(), nil);

  } catch (const std::exception &exc) {

    FIRCLSExceptionRecord(FIRCLSExceptionTypeCpp, FIRCLSExceptionDemangle(name), exc.what(), nil);

  } catch (const std::exception *exc) {

    FIRCLSExceptionRecord(FIRCLSExceptionTypeCpp, FIRCLSExceptionDemangle(name), exc->what(), nil);

  } catch (const std::bad_alloc &exc) {

    // it is especially important to avoid demangling in this case, because the expetation at this

    // point is that all allocations could fail

    FIRCLSExceptionRecord(FIRCLSExceptionTypeCpp, "std::bad_alloc", exc.what(), nil);

  } catch (...) {

    FIRCLSExceptionRecord(FIRCLSExceptionTypeCpp, FIRCLSExceptionDemangle(name), "", nil);

  }

}

#pragma mark - Handlers

static void FIRCLSTerminateHandler(void) {

  FIRCLSSDKLog("C++ terminate handler invoked\n");

  void (*handler)(void) = _firclsContext.readonly->exception.originalTerminateHandler;

  if (handler == FIRCLSTerminateHandler) {

    FIRCLSSDKLog("Error: original handler was set recursively\n");

    handler = NULL;

  }

  // Restore pre-existing handler, if any. Do this early, so that

  // if std::terminate is called while we are executing here, we do not recurse.

  if (handler) {

    FIRCLSSDKLog("restoring pre-existing handler\n");

    // To prevent infinite recursion in this function, check that we aren't resetting the terminate

    // handler to the same function again, which would be this function in the event that we can't

    // actually change the handler during a terminate.

    if (std::set_terminate(handler) == handler) {

      FIRCLSSDKLog("handler has already been restored, aborting\n");

      abort();

    }

  }

  // we can use typeInfo to record the type of the exception,

  // but we must use a catch to get the value

  std::type_info *typeInfo = __cxxabiv1::__cxa_current_exception_type();

  if (typeInfo) {

    FIRCLSCatchAndRecordActiveException(typeInfo);

  } else {

    FIRCLSSDKLog("no active exception\n");

  }

  // only do this if there was a pre-existing handler

  if (handler) {

    FIRCLSSDKLog("invoking pre-existing handler\n");

    handler();

  }

  FIRCLSSDKLog("aborting\n");

  abort();

}

void FIRCLSExceptionCheckHandlers(void *delegate) {

#if !TARGET_OS_IPHONE

  // Check this on OS X all the time, even if the debugger is attached. This is a common

  // source of errors, so we want to be extra verbose in this case.

  if (FIRCLSApplicationSharedInstance()) {

    if (!FIRCLSIsNSApplicationCrashOnExceptionsEnabled()) {

      FIRCLSWarningLog(@"Warning: NSApplicationCrashOnExceptions is not set. This will "

                       @"result in poor top-level uncaught exception reporting.");

    }

  }

#endif

  if (_firclsContext.readonly->debuggerAttached) {

    return;

  }

  void *ptr = NULL;

  ptr = (void *)std::get_terminate();

  if (ptr != FIRCLSTerminateHandler) {

    FIRCLSLookupFunctionPointer(ptr, ^(const char *name, const char *lib) {

      FIRCLSWarningLog(@"Warning: std::get_terminate is '%s' in '%s'", name, lib);

    });

  }

#if TARGET_OS_IPHONE

  ptr = (void *)NSGetUncaughtExceptionHandler();

  if (ptr) {

    FIRCLSLookupFunctionPointer(ptr, ^(const char *name, const char *lib) {

      FIRCLSWarningLog(@"Warning: NSUncaughtExceptionHandler is '%s' in '%s'", name, lib);

    });

  }

#else

  if (FIRCLSApplicationSharedInstance() && FIRCLSIsNSApplicationCrashOnExceptionsEnabled()) {

    // In this case, we *might* be able to intercept exceptions. But, verify we've still

    // swizzled the method.

    Method m = FIRCLSGetNSApplicationReportExceptionMethod();

    if (method_getImplementation(m) != (IMP)FIRCLSNSApplicationReportException) {

      FIRCLSWarningLog(

          @"Warning: top-level NSApplication-reported exceptions cannot be intercepted");

    }

  }

#endif

}

#pragma mark - AppKit Handling

#if !TARGET_OS_IPHONE

static BOOL FIRCLSIsNSApplicationCrashOnExceptionsEnabled(void) {

  return [[NSUserDefaults standardUserDefaults] boolForKey:@"NSApplicationCrashOnExceptions"];

}

static Method FIRCLSGetNSApplicationReportExceptionMethod(void) {

  return class_getInstanceMethod(NSClassFromString(@"NSApplication"), @selector(reportException:));

}

static NSApplicationReportExceptionFunction FIRCLSOriginalNSExceptionReportExceptionFunction(void) {

  return (NSApplicationReportExceptionFunction)

      _firclsContext.readonly->exception.originalNSApplicationReportException;

}

void FIRCLSNSApplicationReportException(id self, SEL cmd, NSException *exception) {

  FIRCLSExceptionRecordNSException(exception);

  // Call the original implementation

  FIRCLSOriginalNSExceptionReportExceptionFunction()(self, cmd, exception);

}

#endif