firebase log level

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSByteUtility.h

@@ -0,0 +1,41 @@
+// 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>
+
+/**
+ * Returns a SHA1 Hash of the input `Data`
+ */
+NSString *FIRCLSHashNSData(NSData *data);
+/**
+ * Returns a SHA256 Hash of the input `Data`
+ */
+NSString *FIRCLS256HashNSData(NSData *data);
+/**
+ * Returns a SHA1 Hash of the input bytes
+ */
+NSString *FIRCLSHashBytes(const void *bytes, size_t length);
+/**
+ * Populates a Hex value conversion of value into outputBuffer.
+ * If value is nil, then outputBuffer is not modified.
+ */
+void FIRCLSSafeHexToString(const uint8_t *value, size_t length, char *outputBuffer);
+
+/**
+ * Iterates through the raw bytes of data in a way that is similar to
+ * `Data`'s `enumerateBytes(_ block:)`, but is safe to call from older
+ * OSes that do not support it.
+ */
+void FIRCLSEnumerateByteRangesOfNSDataUsingBlock(
+    NSData *data, void (^block)(const void *bytes, NSRange byteRange, BOOL *stop));

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSByteUtility.m

@@ -0,0 +1,120 @@
+// 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 "Crashlytics/Shared/FIRCLSByteUtility.h"
+
+#import <CommonCrypto/CommonDigest.h>
+#import <CommonCrypto/CommonHMAC.h>
+
+#pragma mark Private functions
+
+static const char FIRCLSHexMap[] = "0123456789abcdef";
+
+void FIRCLSHexFromByte(uint8_t c, char output[]) {
+  if (!output) {
+    return;
+  }
+
+  output[0] = FIRCLSHexMap[c >> 4];
+  output[1] = FIRCLSHexMap[c & 0x0f];
+}
+
+void FIRCLSSafeHexToString(const uint8_t *value, size_t length, char *outputBuffer) {
+  if (!outputBuffer) {
+    return;
+  }
+
+  memset(outputBuffer, 0, (length * 2) + 1);
+
+  if (!value) {
+    return;
+  }
+
+  for (size_t i = 0; i < length; ++i) {
+    uint8_t c = value[i];
+
+    FIRCLSHexFromByte(c, &outputBuffer[i * 2]);
+  }
+}
+
+NSString *FIRCLSNSDataPrettyDescription(NSData *data) {
+  NSString *string;
+  char *buffer;
+  size_t size;
+  NSUInteger length;
+
+  // we need 2 hex char for every byte of data, plus one more spot for a
+  // null terminator
+  length = data.length;
+  size = (length * 2) + 1;
+  buffer = malloc(sizeof(char) * size);
+
+  if (!buffer) {
+    return nil;
+  }
+
+  FIRCLSSafeHexToString(data.bytes, length, buffer);
+
+  string = [NSString stringWithUTF8String:buffer];
+
+  free(buffer);
+
+  return string;
+}
+
+#pragma mark Public functions
+
+NSString *FIRCLSHashBytes(const void *bytes, size_t length) {
+  uint8_t digest[CC_SHA1_DIGEST_LENGTH] = {0};
+  CC_SHA1(bytes, (CC_LONG)length, digest);
+
+  NSData *result = [NSData dataWithBytes:digest length:CC_SHA1_DIGEST_LENGTH];
+
+  return FIRCLSNSDataPrettyDescription(result);
+}
+
+NSString *FIRCLSHashNSData(NSData *data) {
+  return FIRCLSHashBytes(data.bytes, data.length);
+}
+
+NSString *FIRCLS256HashBytes(const void *bytes, size_t length) {
+  uint8_t digest[CC_SHA256_DIGEST_LENGTH] = {0};
+  CC_SHA256(bytes, (CC_LONG)length, digest);
+
+  NSData *result = [NSData dataWithBytes:digest length:CC_SHA256_DIGEST_LENGTH];
+
+  return FIRCLSNSDataPrettyDescription(result);
+}
+
+NSString *FIRCLS256HashNSData(NSData *data) {
+  return FIRCLS256HashBytes(data.bytes, data.length);
+}
+
+void FIRCLSEnumerateByteRangesOfNSDataUsingBlock(
+    NSData *data, void (^block)(const void *bytes, NSRange byteRange, BOOL *stop)) {
+  if ([data respondsToSelector:@selector(enumerateByteRangesUsingBlock:)]) {
+    [data enumerateByteRangesUsingBlock:^(const void *bytes, NSRange byteRange, BOOL *stop) {
+      block(bytes, byteRange, stop);
+    }];
+
+    return;
+  }
+
+  // Fall back to the less-efficient mechanism for older OSes. Safe
+  // to ignore the return value of stop, since we'll only ever
+  // call this once anyways
+  BOOL stop = NO;
+
+  block(data.bytes, NSMakeRange(0, data.length), &stop);
+}

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSConstants.h

@@ -0,0 +1,51 @@
+// 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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+FOUNDATION_EXPORT NSString *const FIRCLSDeveloperToken;
+
+// User Messages
+FOUNDATION_EXPORT NSString *const FIRCLSMissingConsumerKeyMsg;
+FOUNDATION_EXPORT NSString *const FIRCLSMissingConsumerSecretMsg;
+
+// Exceptions
+FOUNDATION_EXPORT NSString *const FIRCLSException;
+
+// Endpoints
+FOUNDATION_EXPORT NSString *const FIRCLSSettingsEndpoint;
+FOUNDATION_EXPORT NSString *const FIRCLSConfigureEndpoint;
+FOUNDATION_EXPORT NSString *const FIRCLSReportsEndpoint;
+
+// Network requests
+FOUNDATION_EXPORT NSString *const FIRCLSNetworkAccept;
+FOUNDATION_EXPORT NSString *const FIRCLSNetworkAcceptCharset;
+FOUNDATION_EXPORT NSString *const FIRCLSNetworkApplicationJson;
+FOUNDATION_EXPORT NSString *const FIRCLSNetworkAcceptLanguage;
+FOUNDATION_EXPORT NSString *const FIRCLSNetworkContentLanguage;
+FOUNDATION_EXPORT NSString *const FIRCLSNetworkCrashlyticsAPIClientDisplayVersion;
+FOUNDATION_EXPORT NSString *const FIRCLSNetworkCrashlyticsAPIClientId;
+FOUNDATION_EXPORT NSString *const FIRCLSNetworkCrashlyticsDeveloperToken;
+FOUNDATION_EXPORT NSString *const FIRCLSNetworkCrashlyticsGoogleAppId;
+FOUNDATION_EXPORT NSString *const FIRCLSNetworkCrashlyticsOrgId;
+FOUNDATION_EXPORT NSString *const FIRCLSNetworkUserAgent;
+FOUNDATION_EXPORT NSString *const FIRCLSNetworkUTF8;
+
+NSString *FIRCLSSDKGeneratorName(void);
+
+NSString *FIRCLSSDKVersion(void);
+
+NS_ASSUME_NONNULL_END

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSConstants.m

@@ -0,0 +1,56 @@
+// 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 "Crashlytics/Shared/FIRCLSConstants.h"
+#import "FirebaseCore/Extension/FirebaseCoreInternal.h"
+
+#define STR_HELPER(x) #x
+#define STR(x) STR_HELPER(x)
+
+NSString* const FIRCLSDeveloperToken = @"77f0789d8e230eccdb4b99b82dccd78d47f9b604";
+
+// User Messages
+NSString* const FIRCLSMissingConsumerKeyMsg = @"consumer key is nil or zero length";
+NSString* const FIRCLSMissingConsumerSecretMsg = @"consumer secret is nil or zero length";
+
+// Exceptions
+NSString* const FIRCLSException = @"FIRCLSException";
+
+// Endpoints
+NSString* const FIRCLSSettingsEndpoint = @"https://firebase-settings.crashlytics.com";
+NSString* const FIRCLSConfigureEndpoint = @"https://update.crashlytics.com";
+NSString* const FIRCLSReportsEndpoint = @"https://reports.crashlytics.com";
+
+// Network requests
+NSString* const FIRCLSNetworkAccept = @"Accept";
+NSString* const FIRCLSNetworkAcceptCharset = @"Accept-Charset";
+NSString* const FIRCLSNetworkApplicationJson = @"application/json";
+NSString* const FIRCLSNetworkAcceptLanguage = @"Accept-Language";
+NSString* const FIRCLSNetworkContentLanguage = @"Content-Language";
+NSString* const FIRCLSNetworkCrashlyticsAPIClientDisplayVersion =
+    @"X-Crashlytics-API-Client-Display-Version";
+NSString* const FIRCLSNetworkCrashlyticsAPIClientId = @"X-Crashlytics-API-Client-Id";
+NSString* const FIRCLSNetworkCrashlyticsDeveloperToken = @"X-Crashlytics-Developer-Token";
+NSString* const FIRCLSNetworkCrashlyticsGoogleAppId = @"X-Crashlytics-Google-App-Id";
+NSString* const FIRCLSNetworkCrashlyticsOrgId = @"X-Crashlytics-Org-Id";
+NSString* const FIRCLSNetworkUserAgent = @"User-Agent";
+NSString* const FIRCLSNetworkUTF8 = @"utf-8";
+
+NSString* FIRCLSSDKGeneratorName(void) {
+  return [NSString stringWithFormat:@"%s/%s", STR(CLS_SDK_NAME), FIRCLSSDKVersion().UTF8String];
+}
+
+NSString* FIRCLSSDKVersion(void) {
+  return FIRFirebaseVersion();
+}

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSFABHost.h

@@ -0,0 +1,35 @@
+// 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>
+
+/**
+ * Returns the OS version of the host device
+ */
+NSOperatingSystemVersion FIRCLSHostGetOSVersion(void);
+
+/**
+ * Returns model info for the device on which app is running
+ */
+NSString *FIRCLSHostModelInfo(void);
+
+/**
+ * Returns a string representing the OS build
+ */
+NSString *FIRCLSHostOSBuildVersion(void);
+
+/**
+ * Returns a concatenated string of the OS version(majorVersion.minorVersion.patchVersion)
+ */
+NSString *FIRCLSHostOSDisplayVersion(void);

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSFABHost.m

@@ -0,0 +1,95 @@
+// 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.
+
+#include "Crashlytics/Shared/FIRCLSFABHost.h"
+
+#import <GoogleUtilities/GULAppEnvironmentUtil.h>
+
+#if TARGET_OS_WATCH
+#import <WatchKit/WatchKit.h>
+#elif TARGET_OS_IPHONE
+#import <UIKit/UIKit.h>
+#endif
+
+#include <sys/sysctl.h>
+
+#define FIRCLS_HOST_SYSCTL_BUFFER_SIZE (128)
+
+#pragma mark - OS Versions
+
+#pragma mark Private
+
+static NSString *FIRCLSHostSysctlEntry(const char *sysctlKey) {
+  char buffer[FIRCLS_HOST_SYSCTL_BUFFER_SIZE];
+  size_t bufferSize = FIRCLS_HOST_SYSCTL_BUFFER_SIZE;
+  if (sysctlbyname(sysctlKey, buffer, &bufferSize, NULL, 0) != 0) {
+    return nil;
+  }
+  return [NSString stringWithUTF8String:buffer];
+}
+
+#pragma mark Public
+
+NSOperatingSystemVersion FIRCLSHostGetOSVersion(void) {
+  // works on macos(10.10), ios(8.0), watchos(2.0), tvos(9.0)
+  if ([NSProcessInfo.processInfo respondsToSelector:@selector(operatingSystemVersion)]) {
+    return [NSProcessInfo.processInfo operatingSystemVersion];
+  }
+
+  NSOperatingSystemVersion version = {0, 0, 0};
+
+#if TARGET_OS_IPHONE
+
+#if TARGET_OS_WATCH
+  NSString *versionString = [[WKInterfaceDevice currentDevice] systemVersion];
+#else
+  NSString *versionString = [[UIDevice currentDevice] systemVersion];
+#endif
+
+  NSArray *parts = [versionString componentsSeparatedByString:@"."];
+
+  if (parts.count > 0) {
+    version.majorVersion = [[parts objectAtIndex:0] integerValue];
+  }
+
+  if ([parts count] > 1) {
+    version.minorVersion = [[parts objectAtIndex:1] integerValue];
+  }
+
+  if ([parts count] > 2) {
+    version.patchVersion = [[parts objectAtIndex:2] integerValue];
+  }
+
+#endif
+
+  return version;
+}
+
+NSString *FIRCLSHostOSBuildVersion(void) {
+  return FIRCLSHostSysctlEntry("kern.osversion");
+}
+
+NSString *FIRCLSHostOSDisplayVersion(void) {
+  NSOperatingSystemVersion version = FIRCLSHostGetOSVersion();
+  return [NSString stringWithFormat:@"%ld.%ld.%ld", (long)version.majorVersion,
+                                    (long)version.minorVersion, (long)version.patchVersion];
+}
+
+#pragma mark - Host Models
+
+#pragma mark Public
+
+NSString *FIRCLSHostModelInfo(void) {
+  return [GULAppEnvironmentUtil deviceSimulatorModel];
+}

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSMachO/FIRCLSCodeMapping.h

@@ -0,0 +1,34 @@
+// 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>
+
+typedef enum {
+  FIRCLSCodeMappingSourceUnknown,
+  FIRCLSCodeMappingSourceBuild,
+  FIRCLSCodeSourceCache,
+  FIRCLSCodeSourceSpotlight
+} FIRCLSCodeMappingSource;
+
+@interface FIRCLSCodeMapping : NSObject
+
++ (instancetype)mappingWithURL:(NSURL*)URL;
+
+- (instancetype)initWithURL:(NSURL*)URL;
+
+@property(nonatomic, copy, readonly) NSURL* URL;
+@property(nonatomic, assign) FIRCLSCodeMappingSource source;
+@property(nonatomic, copy, readonly) NSString* sourceName;
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSMachO/FIRCLSCodeMapping.m

@@ -0,0 +1,40 @@
+// 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 "Crashlytics/Shared/FIRCLSMachO/FIRCLSCodeMapping.h"
+
+@interface FIRCLSCodeMapping () {
+  FIRCLSCodeMappingSource _source;
+}
+
+@end
+
+@implementation FIRCLSCodeMapping
+
++ (instancetype)mappingWithURL:(NSURL *)URL {
+  return [[self alloc] initWithURL:URL];
+}
+
+- (instancetype)initWithURL:(NSURL *)URL {
+  self = [super init];
+  if (!self) {
+    return nil;
+  }
+
+  _URL = [URL copy];
+
+  return self;
+}
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSMachO/FIRCLSMachO.h

@@ -0,0 +1,117 @@
+// 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.
+
+#pragma once
+
+#include <mach-o/arch.h>
+#include <mach-o/loader.h>
+#include <sys/types.h>
+
+#include <CoreFoundation/CoreFoundation.h>
+
+struct FIRCLSMachOFile {
+  int fd;
+  size_t mappedSize;
+  void* mappedFile;
+};
+typedef struct FIRCLSMachOFile* FIRCLSMachOFileRef;
+
+struct FIRCLSMachOSlice {
+  const void* startAddress;
+  cpu_type_t cputype;
+  cpu_subtype_t cpusubtype;
+};
+typedef struct FIRCLSMachOSlice* FIRCLSMachOSliceRef;
+
+typedef struct {
+  uint32_t major;
+  uint32_t minor;
+  uint32_t bugfix;
+} FIRCLSMachOVersion;
+
+typedef struct {
+  uint64_t addr;
+  uint64_t size;
+  uint32_t offset;
+} FIRCLSMachOSection;
+
+typedef struct {
+  char segname[16];
+  uint64_t vmaddr;
+  uint64_t vmsize;
+} FIRCLSMachOSegmentCommand;
+
+typedef void (^FIRCLSMachOSliceIterator)(FIRCLSMachOSliceRef slice);
+typedef void (^FIRCLSMachOLoadCommandIterator)(uint32_t type,
+                                               uint32_t size,
+                                               const struct load_command* cmd);
+typedef void (*FIRCLSMachOLoadCommandIteratorFunc)(uint32_t type,
+                                                   uint32_t size,
+                                                   const struct load_command* cmd,
+                                                   void* context);
+
+__BEGIN_DECLS
+
+bool FIRCLSMachOFileInitWithPath(FIRCLSMachOFileRef file, const char* path);
+bool FIRCLSMachOFileInitWithCurrent(FIRCLSMachOFileRef file);
+void FIRCLSMachOFileDestroy(FIRCLSMachOFileRef file);
+void FIRCLSMachOFileEnumerateSlices(FIRCLSMachOFileRef file, FIRCLSMachOSliceIterator block);
+struct FIRCLSMachOSlice FIRCLSMachOFileSliceWithArchitectureName(FIRCLSMachOFileRef file,
+                                                                 const char* name);
+
+void FIRCLSMachOEnumerateSlicesAtAddress(void* executableData, FIRCLSMachOSliceIterator block);
+void FIRCLSMachOSliceEnumerateLoadCommands(FIRCLSMachOSliceRef slice,
+                                           FIRCLSMachOLoadCommandIterator block);
+void FIRCLSMachOSliceEnumerateLoadCommands_f(FIRCLSMachOSliceRef slice,
+                                             void* context,
+                                             FIRCLSMachOLoadCommandIteratorFunc function);
+struct FIRCLSMachOSlice FIRCLSMachOSliceGetCurrent(void);
+struct FIRCLSMachOSlice FIRCLSMachOSliceWithHeader(void* machHeader);
+
+const char* FIRCLSMachOSliceGetExecutablePath(FIRCLSMachOSliceRef slice);
+const char* FIRCLSMachOSliceGetArchitectureName(FIRCLSMachOSliceRef slice);
+bool FIRCLSMachOSliceIs64Bit(FIRCLSMachOSliceRef slice);
+bool FIRCLSMachOSliceGetSectionByName(FIRCLSMachOSliceRef slice,
+                                      const char* segName,
+                                      const char* sectionName,
+                                      const void** ptr);
+bool FIRCLSMachOSliceInitSectionByName(FIRCLSMachOSliceRef slice,
+                                       const char* segName,
+                                       const char* sectionName,
+                                       FIRCLSMachOSection* section);
+void FIRCLSMachOSliceGetUnwindInformation(FIRCLSMachOSliceRef slice,
+                                          const void** ehFrame,
+                                          const void** unwindInfo);
+
+// load-command-specific calls for convenience
+
+// returns a pointer to the 16-byte UUID
+uint8_t const* FIRCLSMachOGetUUID(const struct load_command* cmd);
+const char* FIRCLSMachOGetDylibPath(const struct load_command* cmd);
+
+// return true if the header indicates the binary is encrypted
+bool FIRCLSMachOGetEncrypted(const struct load_command* cmd);
+
+// SDK minimums
+FIRCLSMachOVersion FIRCLSMachOGetMinimumOSVersion(const struct load_command* cmd);
+FIRCLSMachOVersion FIRCLSMachOGetLinkedSDKVersion(const struct load_command* cmd);
+
+// Helpers
+FIRCLSMachOSegmentCommand FIRCLSMachOGetSegmentCommand(const struct load_command* cmd);
+
+#ifdef __OBJC__
+NSString* FIRCLSMachONormalizeUUID(CFUUIDBytes* uuidBytes);
+NSString* FIRCLSMachOFormatVersion(FIRCLSMachOVersion* version);
+#endif
+__END_DECLS

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSMachO/FIRCLSMachO.m

@@ -0,0 +1,560 @@
+// 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.
+
+#include "Crashlytics/Shared/FIRCLSMachO/FIRCLSMachO.h"
+#include "Crashlytics/Crashlytics/Helpers/FIRCLSDefines.h"
+
+#include <Foundation/Foundation.h>
+
+#include <mach-o/dyld.h>
+#include <mach-o/fat.h>
+#include <mach-o/getsect.h>
+#include <mach-o/ldsyms.h>
+#include <mach-o/utils.h>
+
+#include <sys/mman.h>
+#include <sys/stat.h>
+
+#include <dlfcn.h>
+#include <fcntl.h>
+
+#include <stdio.h>
+
+#include <unistd.h>
+
+// This is defined in newer versions of iOS/macOS in usr/include/mach/machine.h
+#define CLS_CPU_SUBTYPE_ARM64E ((cpu_subtype_t)2)
+
+static void FIRCLSMachOHeaderValues(FIRCLSMachOSliceRef slice,
+                                    const struct load_command** cmds,
+                                    uint32_t* cmdCount);
+static bool FIRCLSMachOSliceIsValid(FIRCLSMachOSliceRef slice);
+
+bool FIRCLSMachOFileInitWithPath(FIRCLSMachOFileRef file, const char* path) {
+  if (!file || !path) {
+    return false;
+  }
+
+  file->fd = 0;
+  file->mappedFile = NULL;
+  file->mappedSize = 0;
+
+  file->fd = open(path, O_RDONLY);
+  if (file->fd < 0) {
+    // unable to open mach-o file
+    return false;
+  }
+
+  NSError* attributesError;
+  NSString* objCPath = [NSString stringWithCString:path encoding:NSUTF8StringEncoding];
+  NSDictionary* fileAttributes =
+      [[NSFileManager defaultManager] attributesOfItemAtPath:objCPath error:&attributesError];
+  if (attributesError != nil) {
+    close(file->fd);
+    return false;
+  }
+  NSNumber* fileSizeNumber = [fileAttributes objectForKey:NSFileSize];
+  long long currentFileSize = [fileSizeNumber longLongValue];
+  NSFileAttributeType fileType = [fileAttributes objectForKey:NSFileType];
+
+  // We need some minimum size for this to even be a possible mach-o file.  I believe
+  // its probably quite a bit bigger than this, but this at least covers something.
+  // We also need it to be a regular file.
+  file->mappedSize = (size_t)currentFileSize;
+  if (currentFileSize < 16 || ![fileType isEqualToString:NSFileTypeRegular]) {
+    close(file->fd);
+    return false;
+  }
+
+  // Map the file to memory. MAP_SHARED can potentially reduce the amount of actual private
+  // memory needed to do this mapping. Also, be sure to check for the correct failure result.
+  file->mappedFile = mmap(0, file->mappedSize, PROT_READ, MAP_FILE | MAP_SHARED, file->fd, 0);
+  if (!file->mappedFile || (file->mappedFile == MAP_FAILED)) {
+    close(file->fd);
+    return false;
+  }
+
+  return true;
+}
+
+bool FIRCLSMachOFileInitWithCurrent(FIRCLSMachOFileRef file) {
+  struct FIRCLSMachOSlice slice = FIRCLSMachOSliceGetCurrent();
+
+  const char* imagePath = FIRCLSMachOSliceGetExecutablePath(&slice);
+
+  return FIRCLSMachOFileInitWithPath(file, imagePath);
+}
+
+void FIRCLSMachOFileDestroy(FIRCLSMachOFileRef file) {
+  if (!file) {
+    return;
+  }
+
+  if (file->mappedFile && file->mappedSize > 0) {
+    munmap(file->mappedFile, file->mappedSize);
+  }
+
+  close(file->fd);
+}
+
+void FIRCLSMachOFileEnumerateSlices(FIRCLSMachOFileRef file, FIRCLSMachOSliceIterator block) {
+  FIRCLSMachOEnumerateSlicesAtAddress(file->mappedFile, block);
+}
+
+void FIRCLSMachOEnumerateSlicesAtAddress(void* executableData, FIRCLSMachOSliceIterator block) {
+  // check the magic value, to determine if we have a fat header or not
+  uint32_t magicValue;
+  uint32_t archCount;
+  const struct fat_arch* fatArch;
+  struct FIRCLSMachOSlice slice;
+
+  memset(&slice, 0, sizeof(struct FIRCLSMachOSlice));
+
+  magicValue = ((struct fat_header*)executableData)->magic;
+  if ((magicValue != FAT_MAGIC) && (magicValue != FAT_CIGAM)) {
+    slice.startAddress = executableData;
+
+    // use this to fill in the values
+    FIRCLSMachOHeaderValues(&slice, NULL, NULL);
+
+    block(&slice);
+
+    return;
+  }
+
+  archCount = OSSwapBigToHostInt32(((struct fat_header*)executableData)->nfat_arch);
+  fatArch = executableData + sizeof(struct fat_header);
+
+  for (uint32_t i = 0; i < archCount; ++i) {
+    slice.cputype = OSSwapBigToHostInt32(fatArch->cputype);
+    slice.cpusubtype = OSSwapBigToHostInt32(fatArch->cpusubtype);
+    slice.startAddress = executableData + OSSwapBigToHostInt32(fatArch->offset);
+
+    block(&slice);
+
+    // advance to the next fat_arch structure
+    fatArch = (struct fat_arch*)((uintptr_t)fatArch + sizeof(struct fat_arch));
+  }
+}
+
+struct FIRCLSMachOSlice FIRCLSMachOFileSliceWithArchitectureName(FIRCLSMachOFileRef file,
+                                                                 const char* name) {
+  __block struct FIRCLSMachOSlice value;
+
+  memset(&value, 0, sizeof(struct FIRCLSMachOSlice));
+
+  FIRCLSMachOFileEnumerateSlices(file, ^(FIRCLSMachOSliceRef slice) {
+    if (strcmp(FIRCLSMachOSliceGetArchitectureName(slice), name) == 0) {
+      value = *slice;
+    }
+  });
+
+  return value;
+}
+
+static void FIRCLSMachOHeaderValues(FIRCLSMachOSliceRef slice,
+                                    const struct load_command** cmds,
+                                    uint32_t* cmdCount) {
+  const struct mach_header* header32 = (const struct mach_header*)slice->startAddress;
+  const struct mach_header_64* header64 = (const struct mach_header_64*)slice->startAddress;
+  uint32_t commandCount;
+  const void* commandsAddress;
+
+  if (cmds) {
+    *cmds = NULL;
+  }
+
+  if (cmdCount) {
+    *cmdCount = 0;
+  }
+
+  if (!slice->startAddress) {
+    return;
+  }
+
+  // the 32 and 64 bit versions have an identical structures, so this will work
+  switch (header32->magic) {
+    case MH_MAGIC:  // 32-bit
+    case MH_CIGAM:
+      slice->cputype = header32->cputype;
+      slice->cpusubtype = header32->cpusubtype;
+      commandCount = header32->ncmds;
+      commandsAddress = slice->startAddress + sizeof(struct mach_header);
+      break;
+    case MH_MAGIC_64:  // 64-bit
+    case MH_CIGAM_64:
+      slice->cputype = header64->cputype;
+      slice->cpusubtype = header64->cpusubtype;
+      commandCount = header64->ncmds;
+      commandsAddress = slice->startAddress + sizeof(struct mach_header_64);
+      break;
+    default:
+      // not a valid header
+      return;
+  }
+
+  // assign everything back by reference
+  if (cmds) {
+    *cmds = commandsAddress;
+  }
+
+  if (cmdCount) {
+    *cmdCount = commandCount;
+  }
+}
+
+static bool FIRCLSMachOSliceIsValid(FIRCLSMachOSliceRef slice) {
+  if (!slice) {
+    return false;
+  }
+
+  if (!slice->startAddress) {
+    return false;
+  }
+
+  return true;
+}
+
+void FIRCLSMachOSliceEnumerateLoadCommands_f(FIRCLSMachOSliceRef slice,
+                                             void* context,
+                                             FIRCLSMachOLoadCommandIteratorFunc function) {
+  const struct load_command* cmd;
+  uint32_t cmdCount;
+
+  if (!FIRCLSMachOSliceIsValid(slice)) {
+    return;
+  }
+
+  FIRCLSMachOHeaderValues(slice, &cmd, &cmdCount);
+
+  for (uint32_t i = 0; cmd != NULL && i < cmdCount; ++i) {
+    function(cmd->cmd, cmd->cmdsize, cmd, context);
+
+    cmd = (struct load_command*)((uintptr_t)cmd + cmd->cmdsize);
+  }
+}
+
+void FIRCLSMachOSliceEnumerateLoadCommands(FIRCLSMachOSliceRef slice,
+                                           FIRCLSMachOLoadCommandIterator block) {
+  const struct load_command* cmd;
+  uint32_t cmdCount;
+
+  if (!block) {
+    return;
+  }
+
+  if (!FIRCLSMachOSliceIsValid(slice)) {
+    return;
+  }
+
+  FIRCLSMachOHeaderValues(slice, &cmd, &cmdCount);
+
+  for (uint32_t i = 0; cmd != NULL && i < cmdCount; ++i) {
+    block(cmd->cmd, cmd->cmdsize, cmd);
+
+    cmd = (struct load_command*)((uintptr_t)cmd + cmd->cmdsize);
+  }
+}
+
+struct FIRCLSMachOSlice FIRCLSMachOSliceGetCurrent(void) {
+  struct FIRCLSMachOSlice slice;
+  void* executableSymbol;
+  Dl_info dlinfo;
+
+#if !CLS_TARGET_OS_VISION
+  const NXArchInfo* archInfo;
+  archInfo = NXGetLocalArchInfo();
+
+  if (archInfo) {
+    slice.cputype = archInfo->cputype;
+    slice.cpusubtype = archInfo->cpusubtype;
+  }
+#else
+  cpu_type_t cputype;
+  cpu_subtype_t cpusubtype;
+  const char* archname = macho_arch_name_for_mach_header(NULL);
+  bool hasArchInfo = macho_cpu_type_for_arch_name(archname, &cputype, &cpusubtype);
+  if (hasArchInfo) {
+    slice.cputype = cputype;
+    slice.cpusubtype = cpusubtype;
+  }
+#endif
+
+  slice.startAddress = NULL;
+
+  // This call can fail when Exported Symbols File in Build Settings is missing the symbol value
+  // defined as _MH_EXECUTE_SYM (if you look in the header the underscored MH_EXECUTE_SYM define is
+  // there)
+  executableSymbol = dlsym(RTLD_MAIN_ONLY, MH_EXECUTE_SYM);
+
+  // get the address of the main function
+  if (dladdr(executableSymbol, &dlinfo) != 0) {
+    slice.startAddress = dlinfo.dli_fbase;
+  }
+
+  return slice;
+}
+
+struct FIRCLSMachOSlice FIRCLSMachOSliceWithHeader(void* machHeader) {
+  struct FIRCLSMachOSlice slice;
+
+  slice.startAddress = machHeader;
+
+  return slice;
+}
+
+const char* FIRCLSMachOSliceGetExecutablePath(FIRCLSMachOSliceRef slice) {
+  Dl_info info;
+
+  if (!FIRCLSMachOSliceIsValid(slice)) {
+    return NULL;
+  }
+
+  // use dladdr here to look up the information we need for a binary image
+  if (dladdr(slice->startAddress, &info) == 0) {
+    return NULL;
+  }
+
+  return info.dli_fname;
+}
+
+const char* FIRCLSMachOSliceGetArchitectureName(FIRCLSMachOSliceRef slice) {
+  // there are some special cases here for types not handled by earlier OSes
+  if (slice->cputype == CPU_TYPE_ARM && slice->cpusubtype == CPU_SUBTYPE_ARM_V7S) {
+    return "armv7s";
+  }
+
+  if (slice->cputype == (CPU_TYPE_ARM | CPU_ARCH_ABI64)) {
+    if (slice->cpusubtype == CLS_CPU_SUBTYPE_ARM64E) {
+      return "arm64e";
+    } else if (slice->cpusubtype == CPU_SUBTYPE_ARM64_ALL) {
+      return "arm64";
+    }
+  }
+
+  if (slice->cputype == (CPU_TYPE_ARM) && slice->cpusubtype == CPU_SUBTYPE_ARM_V7K) {
+    return "armv7k";
+  }
+
+#if !CLS_TARGET_OS_VISION
+  const NXArchInfo* archInfo;
+
+  archInfo = NXGetArchInfoFromCpuType(slice->cputype, slice->cpusubtype);
+  if (!archInfo) {
+    return "unknown";
+  }
+
+  return archInfo->name;
+#else
+  const char* archname = macho_arch_name_for_mach_header(slice->startAddress);
+
+  if (!archname) {
+    return "unknown";
+  }
+  return archname;
+#endif
+}
+
+bool FIRCLSMachOSliceIs64Bit(FIRCLSMachOSliceRef slice) {
+  // I'm pretty sure this is sufficient...
+  return (slice->cputype & CPU_ARCH_ABI64) == CPU_ARCH_ABI64;
+}
+
+// deprecated
+bool FIRCLSMachOSliceGetSectionByName(FIRCLSMachOSliceRef slice,
+                                      const char* segName,
+                                      const char* sectionName,
+                                      const void** ptr) {
+  if (!ptr) {
+    return false;
+  }
+
+  *ptr = NULL;  // make sure this is set before returning
+
+  FIRCLSMachOSection section;
+
+  if (!FIRCLSMachOSliceInitSectionByName(slice, segName, sectionName, &section)) {
+    return false;
+  }
+
+  // WARNING: this calculation isn't correct, but is here to maintain backwards
+  // compatibility for now with callers of FIRCLSMachOSliceGetSectionByName. All new
+  // users should be calling FIRCLSMachOSliceInitSectionByName
+  *ptr = (const void*)((uintptr_t)slice->startAddress + section.offset);
+
+  return true;
+}
+
+bool FIRCLSMachOSliceInitSectionByName(FIRCLSMachOSliceRef slice,
+                                       const char* segName,
+                                       const char* sectionName,
+                                       FIRCLSMachOSection* section) {
+  if (!FIRCLSMachOSliceIsValid(slice)) {
+    return false;
+  }
+
+  if (!section) {
+    return false;
+  }
+
+  memset(section, 0, sizeof(FIRCLSMachOSection));
+
+// Deprecated code for vision OS, entire function is not used anywhere
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+  if (FIRCLSMachOSliceIs64Bit(slice)) {
+    const struct section_64* sect =
+        getsectbynamefromheader_64(slice->startAddress, segName, sectionName);
+    if (!sect) {
+      return false;
+    }
+
+    section->addr = sect->addr;
+    section->size = sect->size;
+    section->offset = sect->offset;
+  } else {
+    const struct section* sect = getsectbynamefromheader(slice->startAddress, segName, sectionName);
+    if (!sect) {
+      return false;
+    }
+
+    section->addr = sect->addr;
+    section->size = sect->size;
+    section->offset = sect->offset;
+  }
+#pragma clang diagnostic pop
+  return true;
+}
+
+// TODO: this is left in-place just to ensure that old crashltyics + new fabric are still compatible
+// with each other. As a happy bonus, if that situation does come up, this will also fix the bug
+// that was preventing compact unwind on arm64 + iOS 9 from working correctly.
+void FIRCLSMachOSliceGetUnwindInformation(FIRCLSMachOSliceRef slice,
+                                          const void** ehFrame,
+                                          const void** unwindInfo) {
+  if (!unwindInfo && !ehFrame) {
+    return;
+  }
+
+  bool found = false;
+  intptr_t slide = 0;
+
+  // This is inefficient, but we have no other safe way to do this correctly. Modifying the
+  // FIRCLSMachOSlice structure is tempting, but could introduce weird binary-compatibility issues
+  // with version mis-matches.
+  for (uint32_t i = 0; i < _dyld_image_count(); ++i) {
+    const struct mach_header* header = _dyld_get_image_header(i);
+
+    if (header == slice->startAddress) {
+      found = true;
+      slide = _dyld_get_image_vmaddr_slide(i);
+      break;
+    }
+  }
+
+  // make sure we were able to find a matching value
+  if (!found) {
+    return;
+  }
+
+  FIRCLSMachOSection section;
+
+  if (unwindInfo) {
+    if (FIRCLSMachOSliceInitSectionByName(slice, SEG_TEXT, "__unwind_info", &section)) {
+      *unwindInfo = (void*)(section.addr + slide);
+    }
+  }
+
+  if (ehFrame) {
+    if (FIRCLSMachOSliceInitSectionByName(slice, SEG_TEXT, "__eh_frame", &section)) {
+      *ehFrame = (void*)(section.addr + slide);
+    }
+  }
+}
+
+uint8_t const* FIRCLSMachOGetUUID(const struct load_command* cmd) {
+  return ((const struct uuid_command*)cmd)->uuid;
+}
+
+const char* FIRCLSMachOGetDylibPath(const struct load_command* cmd) {
+  const struct dylib_command* dylibcmd = (const struct dylib_command*)cmd;
+
+  return (const char*)((uintptr_t)cmd + dylibcmd->dylib.name.offset);
+}
+
+bool FIRCLSMachOGetEncrypted(const struct load_command* cmd) {
+  return ((struct encryption_info_command*)cmd)->cryptid > 0;
+}
+
+static FIRCLSMachOVersion FIRCLSMachOVersionFromEncoded(uint32_t encoded) {
+  FIRCLSMachOVersion version;
+
+  version.major = (encoded & 0xffff0000) >> 16;
+  version.minor = (encoded & 0x0000ff00) >> 8;
+  version.bugfix = encoded & 0x000000ff;
+
+  return version;
+}
+
+FIRCLSMachOVersion FIRCLSMachOGetMinimumOSVersion(const struct load_command* cmd) {
+  return FIRCLSMachOVersionFromEncoded(((const struct version_min_command*)cmd)->version);
+}
+
+FIRCLSMachOVersion FIRCLSMachOGetLinkedSDKVersion(const struct load_command* cmd) {
+  return FIRCLSMachOVersionFromEncoded(((const struct version_min_command*)cmd)->sdk);
+}
+
+FIRCLSMachOSegmentCommand FIRCLSMachOGetSegmentCommand(const struct load_command* cmd) {
+  FIRCLSMachOSegmentCommand segmentCommand;
+
+  memset(&segmentCommand, 0, sizeof(FIRCLSMachOSegmentCommand));
+
+  if (!cmd) {
+    return segmentCommand;
+  }
+
+  if (cmd->cmd == LC_SEGMENT) {
+    struct segment_command* segCmd = (struct segment_command*)cmd;
+
+    memcpy(segmentCommand.segname, segCmd->segname, 16);
+    segmentCommand.vmaddr = segCmd->vmaddr;
+    segmentCommand.vmsize = segCmd->vmsize;
+  } else if (cmd->cmd == LC_SEGMENT_64) {
+    struct segment_command_64* segCmd = (struct segment_command_64*)cmd;
+
+    memcpy(segmentCommand.segname, segCmd->segname, 16);
+    segmentCommand.vmaddr = segCmd->vmaddr;
+    segmentCommand.vmsize = segCmd->vmsize;
+  }
+
+  return segmentCommand;
+}
+
+NSString* FIRCLSMachONormalizeUUID(CFUUIDBytes* uuidBytes) {
+  CFUUIDRef uuid = CFUUIDCreateFromUUIDBytes(kCFAllocatorDefault, *uuidBytes);
+
+  NSString* string = CFBridgingRelease(CFUUIDCreateString(kCFAllocatorDefault, uuid));
+
+  CFRelease(uuid);
+
+  return [[string stringByReplacingOccurrencesOfString:@"-" withString:@""] lowercaseString];
+}
+
+NSString* FIRCLSMachOFormatVersion(FIRCLSMachOVersion* version) {
+  if (!version) {
+    return nil;
+  }
+
+  return [NSString stringWithFormat:@"%d.%d.%d", version->major, version->minor, version->bugfix];
+}

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSMachO/FIRCLSMachOBinary.h

@@ -0,0 +1,41 @@
+// 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>
+#import "Crashlytics/Shared/FIRCLSMachO/FIRCLSMachO.h"
+
+@class FIRCLSMachOSlice;
+
+@interface FIRCLSMachOBinary : NSObject {
+  NSURL* _url;
+
+  struct FIRCLSMachOFile _file;
+  NSMutableArray* _slices;
+  NSString* _instanceIdentifier;
+}
+
++ (id)MachOBinaryWithPath:(NSString*)path;
+
+- (id)initWithURL:(NSURL*)url;
+
+@property(nonatomic, copy, readonly) NSURL* URL;
+@property(nonatomic, copy, readonly) NSString* path;
+@property(nonatomic, strong, readonly) NSArray* slices;
+@property(nonatomic, copy, readonly) NSString* instanceIdentifier;
+
+- (void)enumerateUUIDs:(void (^)(NSString* uuid, NSString* architecture))block;
+
+- (FIRCLSMachOSlice*)sliceForArchitecture:(NSString*)architecture;
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSMachO/FIRCLSMachOBinary.m

@@ -0,0 +1,175 @@
+// 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 "Crashlytics/Shared/FIRCLSMachO/FIRCLSMachOBinary.h"
+
+#import "Crashlytics/Shared/FIRCLSMachO/FIRCLSMachOSlice.h"
+
+#import <CommonCrypto/CommonHMAC.h>
+
+static void FIRCLSSafeHexToString(const uint8_t* value, size_t length, char* outputBuffer);
+static NSString* FIRCLSNSDataToNSString(NSData* data);
+static NSString* FIRCLSHashBytes(const void* bytes, size_t length);
+static NSString* FIRCLSHashNSString(NSString* value);
+
+@interface FIRCLSMachOBinary ()
+
++ (NSString*)hashNSString:(NSString*)value;
+
+@end
+
+@implementation FIRCLSMachOBinary
+
++ (id)MachOBinaryWithPath:(NSString*)path {
+  return [[self alloc] initWithURL:[NSURL fileURLWithPath:path]];
+}
+
+@synthesize slices = _slices;
+
+- (id)initWithURL:(NSURL*)url {
+  self = [super init];
+  if (self) {
+    _url = [url copy];
+
+    if (!FIRCLSMachOFileInitWithPath(&_file, [[_url path] fileSystemRepresentation])) {
+      return nil;
+    }
+
+    _slices = [NSMutableArray new];
+    FIRCLSMachOFileEnumerateSlices(&_file, ^(FIRCLSMachOSliceRef slice) {
+      FIRCLSMachOSlice* sliceObject;
+
+      sliceObject = [[FIRCLSMachOSlice alloc] initWithSlice:slice];
+
+      [self->_slices addObject:sliceObject];
+    });
+  }
+
+  return self;
+}
+
+- (void)dealloc {
+  FIRCLSMachOFileDestroy(&_file);
+}
+
+- (NSURL*)URL {
+  return _url;
+}
+
+- (NSString*)path {
+  return [_url path];
+}
+
+- (NSString*)instanceIdentifier {
+  if (_instanceIdentifier) {
+    return _instanceIdentifier;
+  }
+
+  NSMutableString* prehashedString = [NSMutableString new];
+
+  // sort the slices by architecture
+  NSArray* sortedSlices =
+      [_slices sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
+        return [[obj1 architectureName] compare:[obj2 architectureName]];
+      }];
+
+  // append them all into a big string
+  for (FIRCLSMachOSlice* slice in sortedSlices) {
+    [prehashedString appendString:[slice uuid]];
+  }
+
+  _instanceIdentifier = [FIRCLSHashNSString(prehashedString) copy];
+
+  return _instanceIdentifier;
+}
+
+- (void)enumerateUUIDs:(void (^)(NSString* uuid, NSString* architecture))block {
+  for (FIRCLSMachOSlice* slice in _slices) {
+    block([slice uuid], [slice architectureName]);
+  }
+}
+
+- (FIRCLSMachOSlice*)sliceForArchitecture:(NSString*)architecture {
+  for (FIRCLSMachOSlice* slice in [self slices]) {
+    if ([[slice architectureName] isEqualToString:architecture]) {
+      return slice;
+    }
+  }
+
+  return nil;
+}
+
++ (NSString*)hashNSString:(NSString*)value {
+  return FIRCLSHashNSString(value);
+}
+
+@end
+
+// TODO: Functions copied from the SDK.  We should figure out a way to share this.
+static void FIRCLSSafeHexToString(const uint8_t* value, size_t length, char* outputBuffer) {
+  const char hex[] = "0123456789abcdef";
+
+  if (!value) {
+    outputBuffer[0] = '\0';
+    return;
+  }
+
+  for (size_t i = 0; i < length; ++i) {
+    unsigned char c = value[i];
+    outputBuffer[i * 2] = hex[c >> 4];
+    outputBuffer[i * 2 + 1] = hex[c & 0x0F];
+  }
+
+  outputBuffer[length * 2] = '\0';  // null terminate
+}
+
+static NSString* FIRCLSNSDataToNSString(NSData* data) {
+  NSString* string;
+  char* buffer;
+  size_t size;
+  NSUInteger length;
+
+  // we need 2 hex char for every byte of data, plus one more spot for a
+  // null terminator
+  length = [data length];
+  size = (length * 2) + 1;
+  buffer = malloc(sizeof(char) * size);
+
+  if (!buffer) {
+    return nil;
+  }
+
+  FIRCLSSafeHexToString([data bytes], length, buffer);
+
+  string = [NSString stringWithUTF8String:buffer];
+
+  free(buffer);
+
+  return string;
+}
+
+static NSString* FIRCLSHashBytes(const void* bytes, size_t length) {
+  uint8_t digest[CC_SHA1_DIGEST_LENGTH] = {0};
+  CC_SHA1(bytes, (CC_LONG)length, digest);
+
+  NSData* result = [NSData dataWithBytes:digest length:CC_SHA1_DIGEST_LENGTH];
+
+  return FIRCLSNSDataToNSString(result);
+}
+
+static NSString* FIRCLSHashNSString(NSString* value) {
+  const char* s = [value cStringUsingEncoding:NSUTF8StringEncoding];
+
+  return FIRCLSHashBytes(s, strlen(s));
+}

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSMachO/FIRCLSMachOSlice.h

@@ -0,0 +1,37 @@
+// 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>
+#import "Crashlytics/Shared/FIRCLSMachO/FIRCLSMachO.h"
+
+@interface FIRCLSMachOSlice : NSObject {
+  struct FIRCLSMachOSlice _slice;
+
+  NSString* _uuidString;
+  NSArray* _linkedDylibs;
+  FIRCLSMachOVersion _minimumOSVersion;
+  FIRCLSMachOVersion _linkedSDKVersion;
+}
+
++ (id)runningSlice;
+
+- (id)initWithSlice:(FIRCLSMachOSliceRef)sliceRef;
+
+@property(nonatomic, copy, readonly) NSString* uuid;
+@property(nonatomic, copy, readonly) NSString* architectureName;
+@property(nonatomic, strong, readonly) NSArray* linkedDylibs;
+@property(nonatomic, assign, readonly) FIRCLSMachOVersion minimumOSVersion;
+@property(nonatomic, assign, readonly) FIRCLSMachOVersion linkedSDKVersion;
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSMachO/FIRCLSMachOSlice.m

@@ -0,0 +1,93 @@
+// 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 "Crashlytics/Shared/FIRCLSMachO/FIRCLSMachOSlice.h"
+
+#include <mach-o/loader.h>
+
+// this is defined only if __OPEN_SOURCE__ is *not* defined in the TVOS SDK's mach-o/loader.h
+// also, it has not yet made it back to the OSX SDKs, for example
+#ifndef LC_VERSION_MIN_TVOS
+#define LC_VERSION_MIN_TVOS 0x2F
+#endif
+
+@implementation FIRCLSMachOSlice
+
++ (id)runningSlice {
+  struct FIRCLSMachOSlice slice;
+
+  slice = FIRCLSMachOSliceGetCurrent();
+
+  return [[self alloc] initWithSlice:&slice];
+}
+
+@synthesize minimumOSVersion = _minimumOSVersion;
+@synthesize linkedSDKVersion = _linkedSDKVersion;
+
+- (id)initWithSlice:(FIRCLSMachOSliceRef)sliceRef {
+  self = [super init];
+  if (self) {
+    NSMutableArray* dylibs;
+
+    _slice = *sliceRef;
+
+    _minimumOSVersion.major = 0;
+    _minimumOSVersion.minor = 0;
+    _minimumOSVersion.bugfix = 0;
+
+    _linkedSDKVersion.major = 0;
+    _linkedSDKVersion.minor = 0;
+    _linkedSDKVersion.bugfix = 0;
+
+    dylibs = [NSMutableArray array];
+
+    FIRCLSMachOSliceEnumerateLoadCommands(
+        &_slice, ^(uint32_t type, uint32_t size, const struct load_command* cmd) {
+          switch (type) {
+            case LC_UUID:
+              self->_uuidString =
+                  [FIRCLSMachONormalizeUUID((CFUUIDBytes*)FIRCLSMachOGetUUID(cmd)) copy];
+              break;
+            case LC_LOAD_DYLIB:
+              [dylibs addObject:[NSString stringWithUTF8String:FIRCLSMachOGetDylibPath(cmd)]];
+              break;
+            case LC_VERSION_MIN_IPHONEOS:
+            case LC_VERSION_MIN_MACOSX:
+            case LC_VERSION_MIN_WATCHOS:
+            case LC_VERSION_MIN_TVOS:
+              self->_minimumOSVersion = FIRCLSMachOGetMinimumOSVersion(cmd);
+              self->_linkedSDKVersion = FIRCLSMachOGetLinkedSDKVersion(cmd);
+              break;
+          }
+        });
+
+    _linkedDylibs = [dylibs copy];
+  }
+
+  return self;
+}
+
+- (NSString*)architectureName {
+  return [NSString stringWithUTF8String:FIRCLSMachOSliceGetArchitectureName(&_slice)];
+}
+
+- (NSString*)uuid {
+  return _uuidString;
+}
+
+- (NSArray*)linkedDylibs {
+  return _linkedDylibs;
+}
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSMachO/FIRCLSdSYM.h

@@ -0,0 +1,38 @@
+// 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>
+
+@class FIRCLSMachOBinary;
+
+@interface FIRCLSdSYM : NSObject
+
+NS_ASSUME_NONNULL_BEGIN
+
++ (id)dSYMWithURL:(NSURL*)url;
+
+- (id)initWithURL:(NSURL*)url;
+
+@property(nonatomic, readonly) FIRCLSMachOBinary* binary;
+@property(nonatomic, copy, readonly, nullable) NSString* bundleIdentifier;
+@property(nonatomic, copy, readonly) NSURL* executableURL;
+@property(nonatomic, copy, readonly) NSString* executablePath;
+@property(nonatomic, copy, readonly) NSString* bundleVersion;
+@property(nonatomic, copy, readonly) NSString* shortBundleVersion;
+
+- (void)enumerateUUIDs:(void (^)(NSString* uuid, NSString* architecture))block;
+
+NS_ASSUME_NONNULL_END
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSMachO/FIRCLSdSYM.m

@@ -0,0 +1,109 @@
+// 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 "Crashlytics/Shared/FIRCLSMachO/FIRCLSdSYM.h"
+
+#import "Crashlytics/Shared/FIRCLSMachO/FIRCLSMachOBinary.h"
+
+#define CLS_XCODE_DSYM_PREFIX (@"com.apple.xcode.dsym.")
+
+@interface FIRCLSdSYM ()
+
+@property(nonatomic, readonly) NSBundle* bundle;
+
+@end
+
+@implementation FIRCLSdSYM
+
++ (id)dSYMWithURL:(NSURL*)url {
+  return [[self alloc] initWithURL:url];
+}
+
+- (id)initWithURL:(NSURL*)url {
+  self = [super init];
+  if (self) {
+    NSDirectoryEnumerator* enumerator;
+    NSString* path;
+    NSFileManager* fileManager;
+    BOOL isDirectory;
+    BOOL fileExistsAtPath;
+    NSArray* itemsInDWARFDir;
+
+    fileManager = [NSFileManager defaultManager];
+
+    // Is there a file at this path?
+    if (![fileManager fileExistsAtPath:[url path]]) {
+      return nil;
+    }
+
+    _bundle = [NSBundle bundleWithURL:url];
+    if (!_bundle) {
+      return nil;
+    }
+
+    path = [[url path] stringByAppendingPathComponent:@"Contents/Resources/DWARF"];
+
+    // Does this path exist and is it a directory?
+    fileExistsAtPath = [fileManager fileExistsAtPath:path isDirectory:&isDirectory];
+    if (!fileExistsAtPath || !isDirectory) {
+      return nil;
+    }
+
+    enumerator = [fileManager enumeratorAtPath:path];
+    itemsInDWARFDir = [enumerator allObjects];
+    // Do we have a Contents/Resources/DWARF dir but no contents?
+    if ([itemsInDWARFDir count] == 0) {
+      return nil;
+    }
+
+    path = [path stringByAppendingPathComponent:[itemsInDWARFDir objectAtIndex:0]];
+
+    _binary = [[FIRCLSMachOBinary alloc] initWithURL:[NSURL fileURLWithPath:path]];
+  }
+
+  return self;
+}
+
+- (NSString*)bundleIdentifier {
+  NSString* identifier;
+
+  identifier = [_bundle bundleIdentifier];
+  if ([identifier hasPrefix:CLS_XCODE_DSYM_PREFIX]) {
+    return [identifier substringFromIndex:[CLS_XCODE_DSYM_PREFIX length]];
+  }
+
+  return identifier;
+}
+
+- (NSURL*)executableURL {
+  return [_binary URL];
+}
+
+- (NSString*)executablePath {
+  return [_binary path];
+}
+
+- (NSString*)bundleVersion {
+  return [[_bundle infoDictionary] objectForKey:@"CFBundleVersion"];
+}
+
+- (NSString*)shortBundleVersion {
+  return [[_bundle infoDictionary] objectForKey:@"CFBundleShortVersionString"];
+}
+
+- (void)enumerateUUIDs:(void (^)(NSString* uuid, NSString* architecture))block {
+  [_binary enumerateUUIDs:block];
+}
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSNetworking/FIRCLSFABNetworkClient.h

@@ -0,0 +1,56 @@
+// 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>
+
+OBJC_EXTERN const NSUInteger FIRCLSNetworkMaximumRetryCount;
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef void (^FIRCLSNetworkDataTaskCompletionHandlerBlock)(NSData *__nullable data,
+                                                            NSURLResponse *__nullable response,
+                                                            NSError *__nullable error);
+typedef void (^FIRCLSNetworkDownloadTaskCompletionHandlerBlock)(NSURL *__nullable location,
+                                                                NSURLResponse *__nullable response,
+                                                                NSError *__nullable error);
+
+@interface FIRCLSFABNetworkClient : NSObject
+
+- (instancetype)init;
+- (instancetype)initWithQueue:(nullable NSOperationQueue *)operationQueue;
+- (instancetype)initWithSessionConfiguration:(NSURLSessionConfiguration *)config
+                                       queue:(nullable NSOperationQueue *)operationQueue
+    NS_DESIGNATED_INITIALIZER;
+
+- (void)startDataTaskWithRequest:(NSURLRequest *)request
+                      retryLimit:(NSUInteger)retryLimit
+               completionHandler:(FIRCLSNetworkDataTaskCompletionHandlerBlock)completionHandler;
+- (void)startDownloadTaskWithRequest:(NSURLRequest *)request
+                          retryLimit:(NSUInteger)retryLimit
+                   completionHandler:
+                       (FIRCLSNetworkDownloadTaskCompletionHandlerBlock)completionHandler;
+
+- (void)invalidateAndCancel;
+
+// Backwards compatibility (we cannot change an interface in Fabric Base that other kits rely on,
+// since we have no control of versioning dependencies)
+- (void)startDataTaskWithRequest:(NSURLRequest *)request
+               completionHandler:(FIRCLSNetworkDataTaskCompletionHandlerBlock)completionHandler;
+- (void)startDownloadTaskWithRequest:(NSURLRequest *)request
+                   completionHandler:
+                       (FIRCLSNetworkDownloadTaskCompletionHandlerBlock)completionHandler;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSNetworking/FIRCLSFABNetworkClient.m

@@ -0,0 +1,267 @@
+// 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 "Crashlytics/Shared/FIRCLSNetworking/FIRCLSFABNetworkClient.h"
+
+#import "Crashlytics/Shared/FIRCLSNetworking/FIRCLSNetworkResponseHandler.h"
+
+static const float FIRCLSNetworkMinimumRetryJitter = 0.90f;
+static const float FIRCLSNetworkMaximumRetryJitter = 1.10f;
+const NSUInteger FIRCLSNetworkMaximumRetryCount = 10;
+
+@interface FIRCLSFABNetworkClient () <NSURLSessionDelegate, NSURLSessionTaskDelegate>
+
+@property(nonatomic, strong, readonly) NSURLSession *session;
+
+@end
+
+@implementation FIRCLSFABNetworkClient
+
+- (instancetype)init {
+  return [self initWithQueue:nil];
+}
+
+- (instancetype)initWithQueue:(nullable NSOperationQueue *)operationQueue {
+  NSURLSessionConfiguration *config = [NSURLSessionConfiguration defaultSessionConfiguration];
+  return [self initWithSessionConfiguration:config queue:operationQueue];
+}
+
+- (instancetype)initWithSessionConfiguration:(NSURLSessionConfiguration *)config
+                                       queue:(nullable NSOperationQueue *)operationQueue {
+  self = [super init];
+  if (!self) {
+    return nil;
+  }
+
+  _session = [NSURLSession sessionWithConfiguration:config
+                                           delegate:self
+                                      delegateQueue:operationQueue];
+
+  if (!_session) {
+    return nil;
+  }
+
+  return self;
+}
+
+- (void)dealloc {
+  [_session finishTasksAndInvalidate];
+}
+
+#pragma mark - Delay Handling
+- (double)randomDoubleWithMin:(double)min max:(double)max {
+  return min + ((max - min) * drand48());
+}
+
+- (double)generateRandomJitter {
+  return [self randomDoubleWithMin:FIRCLSNetworkMinimumRetryJitter
+                               max:FIRCLSNetworkMaximumRetryJitter];
+}
+
+- (NSTimeInterval)computeDelayForResponse:(NSURLResponse *)response
+                           withRetryCount:(NSUInteger)count {
+  NSTimeInterval initialValue = [FIRCLSNetworkResponseHandler retryValueForResponse:response];
+
+  // make sure count is > 0
+  count = MAX(count, 1);
+  // make sure initialValue is >2 for exponential backoff to work reasonably with low count numbers
+  initialValue = MAX(initialValue, 2.0);
+
+  const double jitter = [self generateRandomJitter];
+
+  return pow(initialValue, count) * jitter;  // exponential backoff
+}
+
+- (void)runAfterRetryValueFromResponse:(NSURLResponse *)response
+                              attempts:(NSUInteger)count
+                               onQueue:(dispatch_queue_t)queue
+                                 block:(void (^)(void))block {
+  const NSTimeInterval delay = [self computeDelayForResponse:response withRetryCount:count];
+
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (uint64_t)(delay * NSEC_PER_SEC)), queue, block);
+}
+
+- (void)runAfterRetryValueFromResponse:(NSURLResponse *)response
+                              attempts:(NSUInteger)count
+                                 block:(void (^)(void))block {
+  dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+  [self runAfterRetryValueFromResponse:response attempts:count onQueue:queue block:block];
+}
+
+#pragma mark - Tasks
+
+- (void)startDataTaskWithRequest:(NSURLRequest *)request
+                      retryLimit:(NSUInteger)retryLimit
+                           tries:(NSUInteger)tries
+               completionHandler:(FIRCLSNetworkDataTaskCompletionHandlerBlock)completionHandler {
+  NSURLSessionTask *task = [self.session
+      dataTaskWithRequest:request
+        completionHandler:^(NSData *data, NSURLResponse *response, NSError *taskError) {
+          [FIRCLSNetworkResponseHandler
+              handleCompletedResponse:response
+                   forOriginalRequest:request
+                                error:taskError
+                                block:^(BOOL retry, NSError *error) {
+                                  if (!retry) {
+                                    completionHandler(data, response, error);
+                                    return;
+                                  }
+
+                                  if (tries >= retryLimit) {
+                                    NSDictionary *userInfo = @{
+                                      @"retryLimit" : @(retryLimit),
+                                      NSURLErrorFailingURLStringErrorKey : request.URL
+                                    };
+                                    completionHandler(
+                                        nil, nil,
+                                        [NSError
+                                            errorWithDomain:FIRCLSNetworkErrorDomain
+                                                       code:FIRCLSNetworkErrorMaximumAttemptsReached
+                                                   userInfo:userInfo]);
+                                    return;
+                                  }
+
+                                  [self
+                                      runAfterRetryValueFromResponse:response
+                                                            attempts:tries
+                                                               block:^{
+                                                                 [self
+                                                                     startDataTaskWithRequest:
+                                                                         request
+                                                                                   retryLimit:
+                                                                                       retryLimit
+                                                                                        tries:
+                                                                                            (tries +
+                                                                                             1)
+                                                                            completionHandler:
+                                                                                completionHandler];
+                                                               }];
+                                }];
+        }];
+
+  [task resume];
+
+  if (!task) {
+    completionHandler(nil, nil,
+                      [NSError errorWithDomain:FIRCLSNetworkErrorDomain
+                                          code:FIRCLSNetworkErrorFailedToStartOperation
+                                      userInfo:nil]);
+  }
+}
+
+- (void)startDataTaskWithRequest:(NSURLRequest *)request
+                      retryLimit:(NSUInteger)retryLimit
+               completionHandler:(FIRCLSNetworkDataTaskCompletionHandlerBlock)completionHandler {
+  [self startDataTaskWithRequest:request
+                      retryLimit:retryLimit
+                           tries:0
+               completionHandler:completionHandler];
+}
+
+- (void)startDataTaskWithRequest:(NSURLRequest *)request
+               completionHandler:(FIRCLSNetworkDataTaskCompletionHandlerBlock)completionHandler {
+  [self startDataTaskWithRequest:request
+                      retryLimit:FIRCLSNetworkMaximumRetryCount
+               completionHandler:completionHandler];
+}
+
+- (void)startDownloadTaskWithRequest:(NSURLRequest *)request
+                          retryLimit:(NSUInteger)retryLimit
+                               tries:(NSUInteger)tries
+                   completionHandler:
+                       (FIRCLSNetworkDownloadTaskCompletionHandlerBlock)completionHandler {
+  NSURLSessionTask *task = [self.session
+      downloadTaskWithRequest:request
+            completionHandler:^(NSURL *location, NSURLResponse *response, NSError *taskError) {
+              [FIRCLSNetworkResponseHandler
+                  handleCompletedResponse:response
+                       forOriginalRequest:request
+                                    error:taskError
+                                    block:^(BOOL retry, NSError *error) {
+                                      if (!retry) {
+                                        completionHandler(location, response, error);
+                                        return;
+                                      }
+
+                                      if (tries >= retryLimit) {
+                                        NSDictionary *userInfo = @{
+                                          @"retryLimit" : @(retryLimit),
+                                          NSURLErrorFailingURLStringErrorKey : request.URL
+                                        };
+                                        completionHandler(
+                                            nil, nil,
+                                            [NSError
+                                                errorWithDomain:FIRCLSNetworkErrorDomain
+                                                           code:
+                                                               FIRCLSNetworkErrorMaximumAttemptsReached
+                                                       userInfo:userInfo]);
+                                        return;
+                                      }
+
+                                      [self
+                                          runAfterRetryValueFromResponse:response
+                                                                attempts:tries
+                                                                   block:^{
+                                                                     [self
+                                                                         startDownloadTaskWithRequest:
+                                                                             request
+                                                                                           retryLimit:
+                                                                                               retryLimit
+                                                                                                tries:
+                                                                                                    (tries +
+                                                                                                     1)
+                                                                                    completionHandler:
+                                                                                        completionHandler];
+                                                                   }];
+                                    }];
+            }];
+
+  [task resume];
+
+  if (!task) {
+    completionHandler(nil, nil,
+                      [NSError errorWithDomain:FIRCLSNetworkErrorDomain
+                                          code:FIRCLSNetworkErrorFailedToStartOperation
+                                      userInfo:nil]);
+  }
+}
+
+- (void)startDownloadTaskWithRequest:(NSURLRequest *)request
+                          retryLimit:(NSUInteger)retryLimit
+                   completionHandler:
+                       (FIRCLSNetworkDownloadTaskCompletionHandlerBlock)completionHandler {
+  [self startDownloadTaskWithRequest:request
+                          retryLimit:retryLimit
+                               tries:0
+                   completionHandler:completionHandler];
+}
+
+- (void)startDownloadTaskWithRequest:(NSURLRequest *)request
+                   completionHandler:
+                       (FIRCLSNetworkDownloadTaskCompletionHandlerBlock)completionHandler {
+  [self startDownloadTaskWithRequest:request
+                          retryLimit:FIRCLSNetworkMaximumRetryCount
+                   completionHandler:completionHandler];
+}
+
+- (void)invalidateAndCancel {
+  [self.session invalidateAndCancel];
+}
+
+#pragma mark - NSURLSession Delegate
+- (void)URLSession:(NSURLSession *)session didBecomeInvalidWithError:(NSError *)error {
+}
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSNetworking/FIRCLSNetworkResponseHandler.h

@@ -0,0 +1,87 @@
+// 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>
+
+/**
+ * Type to indicate response status
+ */
+typedef NS_ENUM(NSInteger, FIRCLSNetworkClientResponseType) {
+  FIRCLSNetworkClientResponseSuccess,
+  FIRCLSNetworkClientResponseInvalid,
+  FIRCLSNetworkClientResponseFailure,
+  FIRCLSNetworkClientResponseRetry,
+  FIRCLSNetworkClientResponseBackOff
+};
+
+typedef NS_ENUM(NSInteger, FIRCLSNetworkErrorType) {
+  FIRCLSNetworkErrorUnknown = -1,
+  FIRCLSNetworkErrorFailedToStartOperation = -3,
+  FIRCLSNetworkErrorResponseInvalid = -4,
+  FIRCLSNetworkErrorRequestFailed = -5,
+  FIRCLSNetworkErrorMaximumAttemptsReached = -6,
+};
+
+extern NSInteger const FIRCLSNetworkErrorUnknownURLCancelReason;
+
+/**
+ * This block is an input parameter to handleCompletedResponse: and handleCompletedTask: methods of
+ * this class.
+ * @param retryMightSucceed is YES if the request should be retried.
+ * @param error is the error received back in response.
+ */
+typedef void (^FIRCLSNetworkResponseCompletionHandlerBlock)(BOOL retryMightSucceed, NSError *error);
+
+/**
+ * Error domain for Crashlytics network errors
+ */
+extern NSString *const FIRCLSNetworkErrorDomain;
+/**
+ * This class handles network responses.
+ */
+@interface FIRCLSNetworkResponseHandler : NSObject
+/**
+ * Returns the header in the given NSURLResponse with name as key
+ */
++ (NSString *)headerForResponse:(NSURLResponse *)response withKey:(NSString *)key;
+/**
+ * Returns Retry-After header value in response, and if absent returns a default retry value
+ */
++ (NSTimeInterval)retryValueForResponse:(NSURLResponse *)response;
+/**
+ * Checks if the content type for response matches the request
+ */
++ (BOOL)contentTypeForResponse:(NSURLResponse *)response matchesRequest:(NSURLRequest *)request;
+
++ (NSInteger)cancelReasonFromURLError:(NSError *)error;
+
++ (BOOL)retryableURLError:(NSError *)error;
+
+/**
+ * Convenience method that calls back the input block with FIRCLSNetworkClientResponseType after
+ * checking the response code in response
+ */
++ (void)clientResponseType:(NSURLResponse *)response
+                   handler:(void (^)(FIRCLSNetworkClientResponseType type,
+                                     NSInteger statusCode))responseTypeAndStatusCodeHandlerBlock;
+/**
+ * Handles a completed response for request and calls back input block. Populates error even if
+ * error was nil, but response code indicated an error.
+ */
++ (void)handleCompletedResponse:(NSURLResponse *)response
+             forOriginalRequest:(NSURLRequest *)originalRequest
+                          error:(NSError *)error
+                          block:(FIRCLSNetworkResponseCompletionHandlerBlock)completionHandlerBlock;
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSNetworking/FIRCLSNetworkResponseHandler.m

@@ -0,0 +1,290 @@
+// 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 "Crashlytics/Shared/FIRCLSNetworking/FIRCLSNetworkResponseHandler.h"
+
+@implementation FIRCLSNetworkResponseHandler
+
+static const NSTimeInterval kFIRCLSNetworkResponseHandlerDefaultRetryInterval = 2.0;
+static NSString *const kFIRCLSNetworkResponseHandlerContentType = @"Content-Type";
+NSString *const FIRCLSNetworkErrorDomain = @"FIRCLSNetworkError";
+
+NSInteger const FIRCLSNetworkErrorUnknownURLCancelReason = -1;
+
+#pragma mark - Header Handling
++ (NSString *)headerForResponse:(NSURLResponse *)response withKey:(NSString *)key {
+  if (![response respondsToSelector:@selector(allHeaderFields)]) {
+    return nil;
+  }
+
+  return [((NSHTTPURLResponse *)response).allHeaderFields objectForKey:key];
+}
+
++ (NSTimeInterval)retryValueForResponse:(NSURLResponse *)response {
+  NSString *retryValueString = [self headerForResponse:response withKey:@"Retry-After"];
+  if (!retryValueString) {
+    return kFIRCLSNetworkResponseHandlerDefaultRetryInterval;
+  }
+
+  NSTimeInterval value = retryValueString.doubleValue;
+  if (value < 0.0) {
+    return kFIRCLSNetworkResponseHandlerDefaultRetryInterval;
+  }
+
+  return value;
+}
+
++ (NSString *)requestIdForResponse:(NSURLResponse *)response {
+  return [self headerForResponse:response withKey:@"X-Request-Id"];
+}
+
++ (BOOL)contentTypeForResponse:(NSURLResponse *)response matchesRequest:(NSURLRequest *)request {
+  NSString *accept = [request.allHTTPHeaderFields objectForKey:@"Accept"];
+  if (!accept) {
+    // An omitted accept header is defined to match everything
+    return YES;
+  }
+
+  NSString *contentHeader = [self.class headerForResponse:response
+                                                  withKey:kFIRCLSNetworkResponseHandlerContentType];
+  if (!contentHeader) {
+    //        FIRCLSDeveloperLog("Network", @"Content-Type not present in response");
+    return NO;
+  }
+
+  NSString *acceptCharset = request.allHTTPHeaderFields[@"Accept-Charset"];
+
+  NSArray *parts = [contentHeader componentsSeparatedByString:@"; charset="];
+  if (!parts) {
+    parts = @[ contentHeader ];
+  }
+
+  if ([[parts objectAtIndex:0] caseInsensitiveCompare:accept] != NSOrderedSame) {
+    //        FIRCLSDeveloperLog("Network", @"Content-Type does not match Accept");
+    return NO;
+  }
+
+  if (!acceptCharset) {
+    return YES;
+  }
+
+  if (parts.count < 2) {
+    return YES;
+  }
+
+  return [[parts objectAtIndex:1] caseInsensitiveCompare:acceptCharset] == NSOrderedSame;
+}
+
++ (NSInteger)cancelReasonFromURLError:(NSError *)error {
+  if (![[error domain] isEqualToString:NSURLErrorDomain]) {
+    return FIRCLSNetworkErrorUnknownURLCancelReason;
+  }
+
+  if ([error code] != NSURLErrorCancelled) {
+    return FIRCLSNetworkErrorUnknownURLCancelReason;
+  }
+
+  NSNumber *reason = [[error userInfo] objectForKey:NSURLErrorBackgroundTaskCancelledReasonKey];
+  if (reason == nil) {
+    return FIRCLSNetworkErrorUnknownURLCancelReason;
+  }
+
+  return [reason integerValue];
+}
+
++ (BOOL)retryableURLError:(NSError *)error {
+  // So far, the only task errors seen are NSURLErrorDomain. For others, we're not
+  // sure what to do.
+  if (![[error domain] isEqualToString:NSURLErrorDomain]) {
+    return NO;
+  }
+
+  // cases that we know are definitely not retryable
+  switch ([error code]) {
+    case NSURLErrorBadURL:
+    case NSURLErrorUnsupportedURL:
+    case NSURLErrorHTTPTooManyRedirects:
+    case NSURLErrorRedirectToNonExistentLocation:
+    case NSURLErrorUserCancelledAuthentication:
+    case NSURLErrorUserAuthenticationRequired:
+    case NSURLErrorAppTransportSecurityRequiresSecureConnection:
+    case NSURLErrorFileDoesNotExist:
+    case NSURLErrorFileIsDirectory:
+    case NSURLErrorDataLengthExceedsMaximum:
+    case NSURLErrorSecureConnectionFailed:
+    case NSURLErrorServerCertificateHasBadDate:
+    case NSURLErrorServerCertificateUntrusted:
+    case NSURLErrorServerCertificateHasUnknownRoot:
+    case NSURLErrorServerCertificateNotYetValid:
+    case NSURLErrorClientCertificateRejected:
+    case NSURLErrorClientCertificateRequired:
+    case NSURLErrorBackgroundSessionRequiresSharedContainer:
+      return NO;
+  }
+
+  // All other errors, as far as I can tell, are things that could clear up
+  // without action on the part of the client.
+
+  // NSURLErrorCancelled is a potential special-case. I believe there are
+  // situations where a cancelled request cannot be successfully restarted. But,
+  // until I can prove it, we'll retry. There are definitely many cases where
+  // a cancelled request definitely can be restarted and will work.
+
+  return YES;
+}
+
+#pragma mark - Error Creation
++ (NSError *)errorForCode:(NSInteger)code userInfo:(NSDictionary *)userInfo {
+  return [NSError errorWithDomain:FIRCLSNetworkErrorDomain code:code userInfo:userInfo];
+}
+
++ (NSError *)errorForResponse:(NSURLResponse *)response
+                       ofType:(FIRCLSNetworkClientResponseType)type
+                       status:(NSInteger)status {
+  if (type == FIRCLSNetworkClientResponseSuccess) {
+    return nil;
+  }
+
+  NSString *requestId = [self requestIdForResponse:response];
+  NSString *contentType = [self headerForResponse:response
+                                          withKey:kFIRCLSNetworkResponseHandlerContentType];
+
+  // this could be nil, so be careful
+  requestId = requestId ? requestId : @"";
+  contentType = contentType ? contentType : @"";
+
+  NSDictionary *userInfo = @{
+    @"type" : @(type),
+    @"status_code" : @(status),
+    @"request_id" : requestId,
+    @"content_type" : contentType
+  };
+
+  // compute a reasonable error code type
+  NSInteger errorCode = FIRCLSNetworkErrorUnknown;
+  switch (type) {
+    case FIRCLSNetworkClientResponseFailure:
+      errorCode = FIRCLSNetworkErrorRequestFailed;
+      break;
+    case FIRCLSNetworkClientResponseInvalid:
+      errorCode = FIRCLSNetworkErrorResponseInvalid;
+      break;
+    default:
+      break;
+  }
+
+  return [self errorForCode:errorCode userInfo:userInfo];
+}
+
++ (void)clientResponseType:(NSURLResponse *)response
+                   handler:(void (^)(FIRCLSNetworkClientResponseType type,
+                                     NSInteger statusCode))responseTypeAndStatusCodeHandlerBlock {
+  if (![response respondsToSelector:@selector(statusCode)]) {
+    responseTypeAndStatusCodeHandlerBlock(FIRCLSNetworkClientResponseInvalid, 0);
+    return;
+  }
+
+  NSInteger code = ((NSHTTPURLResponse *)response).statusCode;
+
+  switch (code) {
+    case 200:
+    case 201:
+    case 202:
+    case 204:
+    case 304:
+      responseTypeAndStatusCodeHandlerBlock(FIRCLSNetworkClientResponseSuccess, code);
+      return;
+    case 420:
+    case 429:
+      responseTypeAndStatusCodeHandlerBlock(FIRCLSNetworkClientResponseBackOff, code);
+      return;
+    case 408:
+      responseTypeAndStatusCodeHandlerBlock(FIRCLSNetworkClientResponseRetry, code);
+      return;
+    case 400:
+    case 401:
+    case 403:
+    case 404:
+    case 406:
+    case 410:
+    case 411:
+    case 413:
+    case 419:
+    case 422:
+    case 431:
+      responseTypeAndStatusCodeHandlerBlock(FIRCLSNetworkClientResponseFailure, code);
+      return;
+  }
+
+  // check for a 5xx
+  if (code >= 500 && code <= 599) {
+    responseTypeAndStatusCodeHandlerBlock(FIRCLSNetworkClientResponseRetry, code);
+    return;
+  }
+
+  responseTypeAndStatusCodeHandlerBlock(FIRCLSNetworkClientResponseInvalid, code);
+}
+
++ (void)handleCompletedResponse:(NSURLResponse *)response
+             forOriginalRequest:(NSURLRequest *)originalRequest
+                          error:(NSError *)originalError
+                          block:
+                              (FIRCLSNetworkResponseCompletionHandlerBlock)completionHandlerBlock {
+  // if we have an error, we can just continue
+  if (originalError) {
+    BOOL retryable = [self retryableURLError:originalError];
+
+    completionHandlerBlock(retryable, originalError);
+    return;
+  }
+
+  [self.class clientResponseType:response
+                         handler:^(FIRCLSNetworkClientResponseType type, NSInteger statusCode) {
+                           NSError *error = nil;
+
+                           switch (type) {
+                             case FIRCLSNetworkClientResponseInvalid:
+                               error = [self errorForResponse:response
+                                                       ofType:type
+                                                       status:statusCode];
+                               break;
+                             case FIRCLSNetworkClientResponseBackOff:
+                             case FIRCLSNetworkClientResponseRetry:
+                               error = [self errorForResponse:response
+                                                       ofType:type
+                                                       status:statusCode];
+                               completionHandlerBlock(YES, error);
+                               return;
+                             case FIRCLSNetworkClientResponseFailure:
+                               error = [self errorForResponse:response
+                                                       ofType:type
+                                                       status:statusCode];
+                               break;
+                             case FIRCLSNetworkClientResponseSuccess:
+                               if (![self contentTypeForResponse:response
+                                                  matchesRequest:originalRequest]) {
+                                 error = [self errorForResponse:response
+                                                         ofType:FIRCLSNetworkClientResponseInvalid
+                                                         status:statusCode];
+                                 break;
+                               }
+
+                               break;
+                           }
+
+                           completionHandlerBlock(NO, error);
+                         }];
+}
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSNetworking/FIRCLSURLBuilder.h

@@ -0,0 +1,44 @@
+// 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>
+
+/**
+ * This is a convenience class to ease constructing NSURLs.
+ */
+@interface FIRCLSURLBuilder : NSObject
+
+/**
+ * Convenience method that returns a FIRCLSURLBuilder instance with the input base URL appended to
+ * it.
+ */
++ (instancetype)URLWithBase:(NSString *)base;
+/**
+ * Appends the component to the URL being built by FIRCLSURLBuilder instance
+ */
+- (void)appendComponent:(NSString *)component;
+/**
+ * Escapes and appends the component to the URL being built by FIRCLSURLBuilder instance
+ */
+- (void)escapeAndAppendComponent:(NSString *)component;
+/**
+ * Adds a query and value to the URL being built
+ */
+- (void)appendValue:(id)value forQueryParam:(NSString *)param;
+/**
+ * Returns the built URL
+ */
+- (NSURL *)URL;
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSNetworking/FIRCLSURLBuilder.m

@@ -0,0 +1,104 @@
+// 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 "Crashlytics/Shared/FIRCLSNetworking/FIRCLSURLBuilder.h"
+
+#import "Crashlytics/Crashlytics/Helpers/FIRCLSLogger.h"
+
+@interface FIRCLSURLBuilder ()
+
+@property(nonatomic) NSMutableString *URLString;
+@property(nonatomic) NSUInteger queryParams;
+
+- (NSString *)escapeString:(NSString *)string;
+
+@end
+
+@implementation FIRCLSURLBuilder
+
++ (instancetype)URLWithBase:(NSString *)base {
+  FIRCLSURLBuilder *url = [[FIRCLSURLBuilder alloc] init];
+
+  [url appendComponent:base];
+
+  return url;
+}
+
+- (instancetype)init {
+  self = [super init];
+  if (!self) {
+    return nil;
+  }
+
+  _URLString = [[NSMutableString alloc] init];
+  _queryParams = 0;
+
+  return self;
+}
+
+- (NSString *)escapeString:(NSString *)string {
+#if TARGET_OS_WATCH
+  // TODO: Question - Why does watchOS use a different encoding from the other platforms and the
+  // Android SDK?
+  // This broken the unit test on watchOS: https://github.com/firebase/firebase-ios-sdk/pull/10511
+  return
+      [string stringByAddingPercentEncodingWithAllowedCharacters:[NSCharacterSet
+                                                                     URLPathAllowedCharacterSet]];
+#else
+  return
+      [string stringByAddingPercentEncodingWithAllowedCharacters:NSCharacterSet
+                                                                     .URLQueryAllowedCharacterSet];
+#endif
+}
+
+- (void)appendComponent:(NSString *)component {
+  if (component.length == 0) {
+    FIRCLSErrorLog(@"URLBuilder parameter component must not be empty");
+    return;
+  }
+
+  [self.URLString appendString:component];
+}
+
+- (void)escapeAndAppendComponent:(NSString *)component {
+  [self appendComponent:[self escapeString:component]];
+}
+
+- (void)appendValue:(id)value forQueryParam:(NSString *)param {
+  if (!value) {
+    return;
+  }
+
+  if (self.queryParams == 0) {
+    [self appendComponent:@"?"];
+  } else {
+    [self appendComponent:@"&"];
+  }
+
+  self.queryParams += 1;
+
+  [self appendComponent:param];
+  [self appendComponent:@"="];
+  if ([value isKindOfClass:NSString.class]) {
+    [self escapeAndAppendComponent:value];
+  } else {
+    [self escapeAndAppendComponent:[value description]];
+  }
+}
+
+- (NSURL *)URL {
+  return [NSURL URLWithString:self.URLString];
+}
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSOperation/FIRCLSCompoundOperation.h

@@ -0,0 +1,58 @@
+// 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 "Crashlytics/Shared/FIRCLSOperation/FIRCLSFABAsyncOperation.h"
+
+/**
+ * If the compound operation is sent a @c -[cancel] message while executing, it will attempt to
+ * cancel all operations on its internal queue, and will return an error in its @c asyncCompletion
+ * block with this value as its code.
+ */
+FOUNDATION_EXPORT const NSUInteger FIRCLSCompoundOperationErrorCodeCancelled;
+
+/**
+ * If one or more of the operations on the @c compoundQueue fail, this operation returns an error
+ * in its @c asyncCompletion block with this code, and an array of @c NSErrors keyed on @c
+ * FIRCLSCompoundOperationErrorUserInfoKeyUnderlyingErrors in the @c userInfo dictionary.
+ */
+FOUNDATION_EXPORT const NSUInteger FIRCLSCompoundOperationErrorCodeSuboperationFailed;
+
+/**
+ * When all the operations complete, this @c FIRCLSCompoundOperation instance's @c asyncCompletion
+ * block is called. If any errors were passed by the suboperations' @c asyncCompletion blocks, they
+ * are put in an array which can be accessed in the @c userInfo dictionary in the error parameter
+ * for this instance's @c asyncCompletion block.
+ */
+FOUNDATION_EXPORT NSString *const FIRCLSCompoundOperationErrorUserInfoKeyUnderlyingErrors;
+
+/**
+ * An operation that executes a collection of suboperations on an internal private queue. Any
+ * instance of @c FIRCLSFABAsyncOperation passed into this instance's @c operations property has the
+ * potential to return an @c NSError in its @c asyncCompletion block. This instance's @c
+ * asyncCompletion block will put all such errors in an @c NSArray and return an @c NSError whose @c
+ * userInfo contains that array keyed by @c FIRCLSCompoundOperationErrorUserInfoKeyUnderlyingErrors.
+ */
+@interface FIRCLSCompoundOperation : FIRCLSFABAsyncOperation
+
+/**
+ * An array of @c NSOperations to execute, which can include instances of @c FIRCLSFABAsyncOperation
+ * or
+ * @c FIRCLSCompoundOperation. This operation will not be marked as finished until all suboperations
+ * are marked as finished.
+ */
+@property(copy, nonatomic) NSArray<NSOperation *> *operations;
+
+@property(strong, nonatomic, readonly) NSOperationQueue *compoundQueue;
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSOperation/FIRCLSCompoundOperation.m

@@ -0,0 +1,165 @@
+// 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 "Crashlytics/Shared/FIRCLSOperation/FIRCLSCompoundOperation.h"
+
+#import "Crashlytics/Shared/FIRCLSOperation/FIRCLSFABAsyncOperation_Private.h"
+
+#define FIRCLS_DISPATCH_QUEUES_AS_OBJECTS OS_OBJECT_USE_OBJC_RETAIN_RELEASE
+
+const NSUInteger FIRCLSCompoundOperationErrorCodeCancelled = UINT_MAX - 1;
+const NSUInteger FIRCLSCompoundOperationErrorCodeSuboperationFailed = UINT_MAX - 2;
+
+NSString *const FIRCLSCompoundOperationErrorUserInfoKeyUnderlyingErrors =
+    @"com.google.firebase.crashlytics.FIRCLSCompoundOperation.error.user-info-key.underlying-"
+    @"errors";
+
+static NSString *const FIRCLSCompoundOperationErrorDomain =
+    @"com.google.firebase.crashlytics.FIRCLSCompoundOperation.error";
+static char *const FIRCLSCompoundOperationCountingQueueLabel =
+    "com.google.firebase.crashlytics.FIRCLSCompoundOperation.dispatch-queue.counting-queue";
+
+@interface FIRCLSCompoundOperation ()
+
+@property(strong, nonatomic, readwrite) NSOperationQueue *compoundQueue;
+@property(assign, nonatomic) NSUInteger completedOperations;
+@property(strong, nonatomic) NSMutableArray *errors;
+#if FIRCLS_DISPATCH_QUEUES_AS_OBJECTS
+@property(strong, nonatomic) dispatch_queue_t countingQueue;
+#else
+@property(assign, nonatomic) dispatch_queue_t countingQueue;
+#endif
+
+@end
+
+@implementation FIRCLSCompoundOperation
+
+- (instancetype)init {
+  self = [super init];
+  if (!self) {
+    return nil;
+  }
+
+  _compoundQueue = [[NSOperationQueue alloc] init];
+  _completedOperations = 0;
+  _errors = [NSMutableArray array];
+  _countingQueue =
+      dispatch_queue_create(FIRCLSCompoundOperationCountingQueueLabel, DISPATCH_QUEUE_SERIAL);
+
+  return self;
+}
+
+#if !FIRCLS_DISPATCH_QUEUES_AS_OBJECTS
+- (void)dealloc {
+  if (_countingQueue) {
+    dispatch_release(_countingQueue);
+  }
+}
+#endif
+
+- (void)main {
+  for (FIRCLSFABAsyncOperation *operation in self.operations) {
+    [self injectCompoundAsyncCompletionInOperation:operation];
+    [self injectCompoundSyncCompletionInOperation:operation];
+
+    [self.compoundQueue addOperation:operation];
+  }
+}
+
+- (void)cancel {
+  if (self.compoundQueue.operations.count > 0) {
+    [self.compoundQueue cancelAllOperations];
+    dispatch_sync(self.countingQueue, ^{
+      [self attemptCompoundCompletion];
+    });
+  } else {
+    for (NSOperation *operation in self.operations) {
+      [operation cancel];
+    }
+
+    // we have to add the operations to the queue in order for their isFinished property to be set
+    // to true.
+    [self.compoundQueue addOperations:self.operations waitUntilFinished:NO];
+  }
+  [super cancel];
+}
+
+- (void)injectCompoundAsyncCompletionInOperation:(FIRCLSFABAsyncOperation *)operation {
+  __weak FIRCLSCompoundOperation *weakSelf = self;
+  FIRCLSFABAsyncOperationCompletionBlock originalAsyncCompletion = [operation.asyncCompletion copy];
+  FIRCLSFABAsyncOperationCompletionBlock completion = ^(NSError *error) {
+    __strong FIRCLSCompoundOperation *strongSelf = weakSelf;
+
+    if (originalAsyncCompletion) {
+      dispatch_sync(strongSelf.countingQueue, ^{
+        originalAsyncCompletion(error);
+      });
+    }
+
+    [strongSelf updateCompletionCountsWithError:error];
+  };
+  operation.asyncCompletion = completion;
+}
+
+- (void)injectCompoundSyncCompletionInOperation:(FIRCLSFABAsyncOperation *)operation {
+  __weak FIRCLSCompoundOperation *weakSelf = self;
+  void (^originalSyncCompletion)(void) = [operation.completionBlock copy];
+  void (^completion)(void) = ^{
+    __strong FIRCLSCompoundOperation *strongSelf = weakSelf;
+
+    if (originalSyncCompletion) {
+      dispatch_sync(strongSelf.countingQueue, ^{
+        originalSyncCompletion();
+      });
+    }
+
+    dispatch_sync(strongSelf.countingQueue, ^{
+      [strongSelf attemptCompoundCompletion];
+    });
+  };
+  operation.completionBlock = completion;
+}
+
+- (void)updateCompletionCountsWithError:(NSError *)error {
+  dispatch_sync(self.countingQueue, ^{
+    if (!error) {
+      self.completedOperations += 1;
+    } else {
+      [self.errors addObject:error];
+    }
+  });
+}
+
+- (void)attemptCompoundCompletion {
+  if (self.isCancelled) {
+    [self finishWithError:[NSError errorWithDomain:FIRCLSCompoundOperationErrorDomain
+                                              code:FIRCLSCompoundOperationErrorCodeCancelled
+                                          userInfo:@{
+                                            NSLocalizedDescriptionKey : [NSString
+                                                stringWithFormat:@"%@ cancelled", self.name]
+                                          }]];
+    self.asyncCompletion = nil;
+  } else if (self.completedOperations + self.errors.count == self.operations.count) {
+    NSError *error = nil;
+    if (self.errors.count > 0) {
+      error = [NSError
+          errorWithDomain:FIRCLSCompoundOperationErrorDomain
+                     code:FIRCLSCompoundOperationErrorCodeSuboperationFailed
+                 userInfo:@{FIRCLSCompoundOperationErrorUserInfoKeyUnderlyingErrors : self.errors}];
+    }
+    [self finishWithError:error];
+  }
+}
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSOperation/FIRCLSFABAsyncOperation.h

@@ -0,0 +1,39 @@
+// 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>
+
+/**
+ *  Completion block that can be called in your subclass implementation. It is up to you when you
+ *  want to call it.
+ */
+typedef void (^FIRCLSFABAsyncOperationCompletionBlock)(NSError *__nullable error);
+
+/**
+ *  FIRCLSFABAsyncOperation is a subclass of NSOperation that allows for asynchronous work to be
+ *  performed, for things like networking, IPC or UI-driven logic. Create your own subclasses to
+ *  encapsulate custom logic.
+ *  @warning When subclassing to create your own operations, be sure to call -[finishWithError:] at
+ *  some point, or program execution will hang.
+ *  @see -[finishWithError:] in FIRCLSFABAsyncOperation_Private.h
+ */
+@interface FIRCLSFABAsyncOperation : NSOperation
+
+/**
+ *  Add a callback method for consumers of your subclasses to set when the asynchronous work is
+ *  marked as complete with -[finishWithError:].
+ */
+@property(copy, nonatomic, nullable) FIRCLSFABAsyncOperationCompletionBlock asyncCompletion;
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSOperation/FIRCLSFABAsyncOperation.m

@@ -0,0 +1,146 @@
+// 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 "Crashlytics/Shared/FIRCLSOperation/FIRCLSFABAsyncOperation.h"
+
+#import "Crashlytics/Shared/FIRCLSOperation/FIRCLSFABAsyncOperation_Private.h"
+
+@interface FIRCLSFABAsyncOperation () {
+  BOOL _internalExecuting;
+  BOOL _internalFinished;
+}
+
+@property(nonatomic, strong) NSRecursiveLock *lock;
+
+@end
+
+@implementation FIRCLSFABAsyncOperation
+
+- (instancetype)init {
+  self = [super init];
+  if (!self) {
+    return nil;
+  }
+
+  _internalExecuting = NO;
+  _internalFinished = NO;
+
+  _lock = [[NSRecursiveLock alloc] init];
+  _lock.name = [NSString stringWithFormat:@"com.google.firebase.crashlytics.%@-lock", [self class]];
+  ;
+
+  return self;
+}
+
+#pragma mark - NSOperation Overrides
+- (BOOL)isConcurrent {
+  return YES;
+}
+
+- (BOOL)isAsynchronous {
+  return YES;
+}
+
+- (BOOL)isExecuting {
+  [self.lock lock];
+  BOOL result = _internalExecuting;
+  [self.lock unlock];
+
+  return result;
+}
+
+- (BOOL)isFinished {
+  [self.lock lock];
+  BOOL result = _internalFinished;
+  [self.lock unlock];
+
+  return result;
+}
+
+- (void)start {
+  if ([self checkForCancellation]) {
+    return;
+  }
+
+  [self markStarted];
+
+  [self main];
+}
+
+#pragma mark - Utilities
+- (void)changeValueForKey:(NSString *)key inBlock:(void (^)(void))block {
+  [self willChangeValueForKey:key];
+  block();
+  [self didChangeValueForKey:key];
+}
+
+- (void)lock:(void (^)(void))block {
+  [self.lock lock];
+  block();
+  [self.lock unlock];
+}
+
+- (BOOL)checkForCancellation {
+  if ([self isCancelled]) {
+    [self markDone];
+    return YES;
+  }
+
+  return NO;
+}
+
+#pragma mark - State Management
+- (void)unlockedMarkFinished {
+  [self changeValueForKey:@"isFinished"
+                  inBlock:^{
+                    self->_internalFinished = YES;
+                  }];
+}
+
+- (void)unlockedMarkStarted {
+  [self changeValueForKey:@"isExecuting"
+                  inBlock:^{
+                    self->_internalExecuting = YES;
+                  }];
+}
+
+- (void)unlockedMarkComplete {
+  [self changeValueForKey:@"isExecuting"
+                  inBlock:^{
+                    self->_internalExecuting = NO;
+                  }];
+}
+
+- (void)markStarted {
+  [self lock:^{
+    [self unlockedMarkStarted];
+  }];
+}
+
+- (void)markDone {
+  [self lock:^{
+    [self unlockedMarkComplete];
+    [self unlockedMarkFinished];
+  }];
+}
+
+#pragma mark - Protected
+- (void)finishWithError:(NSError *)error {
+  if (self.asyncCompletion) {
+    self.asyncCompletion(error);
+  }
+  [self markDone];
+}
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSOperation/FIRCLSFABAsyncOperation_Private.h

@@ -0,0 +1,32 @@
+// 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 "Crashlytics/Shared/FIRCLSOperation/FIRCLSFABAsyncOperation.h"
+
+@interface FIRCLSFABAsyncOperation (Private)
+
+/**
+ * Subclasses must call this method when they are done performing work. When it is called is up to
+ * you; it can be directly after kicking of a network request, say, or in the callback for its
+ * response. Once this method is called, the operation queue it is on will begin executing the next
+ * waiting operation. If you directly invoked -[start] on the instance, execution will proceed to
+ * the next code statement.
+ * @note as soon as this method is called, @c NSOperation's standard @c completionBlock will be
+ * executed if one exists, as a result of setting the operation's isFinished property to YES, and
+ * the asyncCompletion block is called.
+ * @param error Any error to pass to asyncCompletion, or nil if there is none.
+ */
+- (void)finishWithError:(NSError *__nullable)error;
+
+@end

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSOperation/FIRCLSOperation.h

@@ -0,0 +1,19 @@
+// 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>
+
+#import "Crashlytics/Shared/FIRCLSOperation/FIRCLSCompoundOperation.h"
+#import "Crashlytics/Shared/FIRCLSOperation/FIRCLSFABAsyncOperation.h"
+#import "Crashlytics/Shared/FIRCLSOperation/FIRCLSFABAsyncOperation_Private.h"

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSUUID.h

@@ -0,0 +1,26 @@
+// 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>
+#import "Crashlytics/Shared/FIRCLSConstants.h"
+
+/**
+ * Generates and returns a UUID
+ */
+NSString *FIRCLSGenerateUUID(void);
+
+/**
+ * Converts the input uint8_t UUID to String
+ */
+NSString *FIRCLSUUIDToNSString(const uint8_t *uuid);

Pods/FirebaseCrashlytics/Crashlytics/Shared/FIRCLSUUID.m

@@ -0,0 +1,39 @@
+// 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 "Crashlytics/Shared/FIRCLSUUID.h"
+
+#import "Crashlytics/Shared/FIRCLSByteUtility.h"
+
+static NSInteger const FIRCLSUUIDStringLength = 33;
+
+#pragma mark Public methods
+
+NSString *FIRCLSGenerateUUID(void) {
+  NSString *string;
+
+  CFUUIDRef uuid = CFUUIDCreate(kCFAllocatorDefault);
+  string = CFBridgingRelease(CFUUIDCreateString(kCFAllocatorDefault, uuid));
+  CFRelease(uuid);
+
+  return string;
+}
+
+NSString *FIRCLSUUIDToNSString(const uint8_t *uuid) {
+  char uuidString[FIRCLSUUIDStringLength];
+
+  FIRCLSSafeHexToString(uuid, 16, uuidString);
+
+  return [NSString stringWithUTF8String:uuidString];
+}