// 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/Crashlytics/Helpers/FIRCLSDefines.h"
#include "Crashlytics/Crashlytics/Helpers/FIRCLSFeatures.h"

#if CLS_MACH_EXCEPTION_SUPPORTED

#include "Crashlytics/Crashlytics/Components/FIRCLSGlobals.h"
#include "Crashlytics/Crashlytics/Handlers/FIRCLSHandler.h"
#include "Crashlytics/Crashlytics/Handlers/FIRCLSMachException.h"
#include "Crashlytics/Crashlytics/Components/FIRCLSProcess.h"
#include "Crashlytics/Crashlytics/Handlers/FIRCLSSignal.h"
#include "Crashlytics/Crashlytics/Helpers/FIRCLSUtility.h"

#include <errno.h>
#include <mach/mach.h>
#include <pthread.h>
#include <unistd.h>

#pragma mark Prototypes
static void* FIRCLSMachExceptionServer(void* argument);
static bool FIRCLSMachExceptionThreadStart(FIRCLSMachExceptionReadContext* context);
static bool FIRCLSMachExceptionReadMessage(FIRCLSMachExceptionReadContext* context,
                                           MachExceptionMessage* message);
static kern_return_t FIRCLSMachExceptionDispatchMessage(FIRCLSMachExceptionReadContext* context,
                                                        MachExceptionMessage* message);
static bool FIRCLSMachExceptionReply(FIRCLSMachExceptionReadContext* context,
                                     MachExceptionMessage* message,
                                     kern_return_t result);
static bool FIRCLSMachExceptionRegister(FIRCLSMachExceptionReadContext* context);
static bool FIRCLSMachExceptionUnregister(FIRCLSMachExceptionOriginalPorts* originalPorts,
                                          exception_mask_t mask);
static bool FIRCLSMachExceptionRecord(FIRCLSMachExceptionReadContext* context,
                                      MachExceptionMessage* message);

#pragma mark - Initialization
void FIRCLSMachExceptionInit(FIRCLSMachExceptionReadContext* context) {
  if (!FIRCLSUnlinkIfExists(context->path)) {
    FIRCLSSDKLog("Unable to reset the mach exception file %s\n", strerror(errno));
  }

  if (!FIRCLSMachExceptionRegister(context)) {
    FIRCLSSDKLog("Unable to register mach exception handler\n");
    return;
  }

  if (!FIRCLSMachExceptionThreadStart(context)) {
    FIRCLSSDKLog("Unable to start thread\n");
    FIRCLSMachExceptionUnregister(&context->originalPorts, context->mask);
  }
}

void FIRCLSMachExceptionCheckHandlers(void) {
  if (_firclsContext.readonly->debuggerAttached) {
    return;
  }

  // It isn't really critical that this be done, as its extremely uncommon to run into
  // preexisting handlers.
  // Can use task_get_exception_ports for this.
}

static exception_mask_t FIRCLSMachExceptionMask(void) {
  exception_mask_t mask;

  // EXC_BAD_ACCESS
  // EXC_BAD_INSTRUCTION
  // EXC_ARITHMETIC
  // EXC_EMULATION - non-failure
  // EXC_SOFTWARE - non-failure
  // EXC_BREAKPOINT - trap instructions, from the debugger and code. Needs special treatment.
  // EXC_SYSCALL - non-failure
  // EXC_MACH_SYSCALL - non-failure
  // EXC_RPC_ALERT - non-failure
  // EXC_CRASH - see below
  // EXC_RESOURCE - non-failure, happens when a process exceeds a resource limit
  // EXC_GUARD - see below
  //
  // EXC_CRASH is a special kind of exception.  It is handled by launchd, and treated special by
  // the kernel.  Seems that we cannot safely catch it - our handler will never be called.  This
  // is a confirmed kernel bug.  Lacking access to EXC_CRASH means we must use signal handlers to
  // cover all types of crashes.
  // EXC_GUARD is relatively new, and isn't available on all OS versions. You have to be careful,
  // because you cannot successfully register hanlders if there are any unrecognized masks. We've
  // dropped support for old OS versions that didn't have EXC_GUARD (iOS 5 and below, macOS 10.6 and
  // below) so we always add it now

  mask = EXC_MASK_BAD_ACCESS | EXC_MASK_BAD_INSTRUCTION | EXC_MASK_ARITHMETIC |
         EXC_MASK_BREAKPOINT | EXC_MASK_GUARD;

  return mask;
}

static bool FIRCLSMachExceptionThreadStart(FIRCLSMachExceptionReadContext* context) {
  pthread_attr_t attr;

  if (pthread_attr_init(&attr) != 0) {
    FIRCLSSDKLog("pthread_attr_init %s\n", strerror(errno));
    return false;
  }

  if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0) {
    FIRCLSSDKLog("pthread_attr_setdetachstate %s\n", strerror(errno));
    return false;
  }

  // Use to pre-allocate a stack for this thread
  // The stack must be page-aligned
  if (pthread_attr_setstack(&attr, _firclsContext.readonly->machStack,
                            CLS_MACH_EXCEPTION_HANDLER_STACK_SIZE) != 0) {
    FIRCLSSDKLog("pthread_attr_setstack %s\n", strerror(errno));
    return false;
  }

  if (pthread_create(&context->thread, &attr, FIRCLSMachExceptionServer, context) != 0) {
    FIRCLSSDKLog("pthread_create %s\n", strerror(errno));
    return false;
  }

  pthread_attr_destroy(&attr);

  return true;
}

exception_mask_t FIRCLSMachExceptionMaskForSignal(int signal) {
  switch (signal) {
    case SIGTRAP:
      return EXC_MASK_BREAKPOINT;
    case SIGSEGV:
      return EXC_MASK_BAD_ACCESS;
    case SIGBUS:
      return EXC_MASK_BAD_ACCESS;
    case SIGILL:
      return EXC_MASK_BAD_INSTRUCTION;
    case SIGABRT:
      return EXC_MASK_CRASH;
    case SIGSYS:
      return EXC_MASK_CRASH;
    case SIGFPE:
      return EXC_MASK_ARITHMETIC;
  }

  return 0;
}

#pragma mark - Message Handling
static void* FIRCLSMachExceptionServer(void* argument) {
  FIRCLSMachExceptionReadContext* context = argument;

  pthread_setname_np("com.google.firebase.crashlytics.MachExceptionServer");

  while (1) {
    MachExceptionMessage message;

    // read the exception message
    if (!FIRCLSMachExceptionReadMessage(context, &message)) {
      break;
    }

    // handle it, and possibly forward
    kern_return_t result = FIRCLSMachExceptionDispatchMessage(context, &message);

    // and now, reply
    if (!FIRCLSMachExceptionReply(context, &message, result)) {
      break;
    }
  }

  FIRCLSSDKLog("Mach exception server thread exiting\n");

  return NULL;
}

static bool FIRCLSMachExceptionReadMessage(FIRCLSMachExceptionReadContext* context,
                                           MachExceptionMessage* message) {
  mach_msg_return_t r;

  memset(message, 0, sizeof(MachExceptionMessage));

  r = mach_msg(&message->head, MACH_RCV_MSG | MACH_RCV_LARGE, 0, sizeof(MachExceptionMessage),
               context->port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
  if (r != MACH_MSG_SUCCESS) {
    FIRCLSSDKLog("Error receving mach_msg (%d)\n", r);
    return false;
  }

  FIRCLSSDKLog("Accepted mach exception message\n");

  return true;
}

static kern_return_t FIRCLSMachExceptionDispatchMessage(FIRCLSMachExceptionReadContext* context,
                                                        MachExceptionMessage* message) {
  FIRCLSSDKLog("Mach exception: 0x%x, count: %d, code: 0x%llx 0x%llx\n", message->exception,
               message->codeCnt, message->codeCnt > 0 ? message->code[0] : -1,
               message->codeCnt > 1 ? message->code[1] : -1);

  // This will happen if a child process raises an exception, as the exception ports are
  // inherited.
  if (message->task.name != mach_task_self()) {
    FIRCLSSDKLog("Mach exception task mis-match, returning failure\n");
    return KERN_FAILURE;
  }

  FIRCLSSDKLog("Unregistering handler\n");
  if (!FIRCLSMachExceptionUnregister(&context->originalPorts, context->mask)) {
    FIRCLSSDKLog("Failed to unregister\n");
    return KERN_FAILURE;
  }

  FIRCLSSDKLog("Restoring original signal handlers\n");
  if (!FIRCLSSignalSafeInstallPreexistingHandlers(& _firclsContext.readonly->signal, -1, NULL, NULL)) {
    FIRCLSSDKLog("Failed to restore signal handlers\n");
    return KERN_FAILURE;
  }

  FIRCLSSDKLog("Recording mach exception\n");
  if (!FIRCLSMachExceptionRecord(context, message)) {
    FIRCLSSDKLog("Failed to record mach exception\n");
    return KERN_FAILURE;
  }

  return KERN_SUCCESS;
}

static bool FIRCLSMachExceptionReply(FIRCLSMachExceptionReadContext* context,
                                     MachExceptionMessage* message,
                                     kern_return_t result) {
  MachExceptionReply reply;
  mach_msg_return_t r;

  // prepare the reply
  reply.head.msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REMOTE(message->head.msgh_bits), 0);
  reply.head.msgh_remote_port = message->head.msgh_remote_port;
  reply.head.msgh_size = (mach_msg_size_t)sizeof(MachExceptionReply);
  reply.head.msgh_local_port = MACH_PORT_NULL;
  reply.head.msgh_id = message->head.msgh_id + 100;

  reply.NDR = NDR_record;

  reply.retCode = result;

  FIRCLSSDKLog("Sending exception reply\n");

  // send it
  r = mach_msg(&reply.head, MACH_SEND_MSG, reply.head.msgh_size, 0, MACH_PORT_NULL,
               MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
  if (r != MACH_MSG_SUCCESS) {
    FIRCLSSDKLog("mach_msg reply failed (%d)\n", r);
    return false;
  }

  FIRCLSSDKLog("Exception reply delivered\n");

  return true;
}

#pragma mark - Registration
static bool FIRCLSMachExceptionRegister(FIRCLSMachExceptionReadContext* context) {
  mach_port_t task = mach_task_self();

  kern_return_t kr = mach_port_allocate(task, MACH_PORT_RIGHT_RECEIVE, &context->port);
  if (kr != KERN_SUCCESS) {
    FIRCLSSDKLog("Error: mach_port_allocate failed %d\n", kr);
    return false;
  }

  kr = mach_port_insert_right(task, context->port, context->port, MACH_MSG_TYPE_MAKE_SEND);
  if (kr != KERN_SUCCESS) {
    FIRCLSSDKLog("Error: mach_port_insert_right failed %d\n", kr);
    mach_port_deallocate(task, context->port);
    return false;
  }

  // Get the desired mask, which covers all the mach exceptions we are capable of handling,
  // but clear out any that are in our ignore list.  We do this by ANDing with the bitwise
  // negation.  Because we are only clearing bits, there's no way to set an incorrect mask
  // using ignoreMask.
  context->mask = FIRCLSMachExceptionMask();

  // ORing with MACH_EXCEPTION_CODES will produce 64-bit exception data
  kr = task_swap_exception_ports(task, context->mask, context->port,
                                 EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES, THREAD_STATE_NONE,
                                 context->originalPorts.masks, &context->originalPorts.count,
                                 context->originalPorts.ports, context->originalPorts.behaviors,
                                 context->originalPorts.flavors);
  if (kr != KERN_SUCCESS) {
    FIRCLSSDKLog("Error: task_swap_exception_ports %d\n", kr);
    return false;
  }

  for (int i = 0; i < context->originalPorts.count; ++i) {
    FIRCLSSDKLog("original 0x%x 0x%x 0x%x 0x%x\n", context->originalPorts.ports[i],
                 context->originalPorts.masks[i], context->originalPorts.behaviors[i],
                 context->originalPorts.flavors[i]);
  }

  return true;
}

static bool FIRCLSMachExceptionUnregister(FIRCLSMachExceptionOriginalPorts* originalPorts,
                                          exception_mask_t mask) {
  kern_return_t kr;

  // Re-register all the old ports.
  for (mach_msg_type_number_t i = 0; i < originalPorts->count; ++i) {
    // clear the bits from this original mask
    mask &= ~originalPorts->masks[i];

    kr =
        task_set_exception_ports(mach_task_self(), originalPorts->masks[i], originalPorts->ports[i],
                                 originalPorts->behaviors[i], originalPorts->flavors[i]);
    if (kr != KERN_SUCCESS) {
      FIRCLSSDKLog("unable to restore original port: %d", originalPorts->ports[i]);
    }
  }

  // Finally, mark any masks we registered for that do not have an original port as unused.
  kr = task_set_exception_ports(mach_task_self(), mask, MACH_PORT_NULL,
                                EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES, THREAD_STATE_NONE);
  if (kr != KERN_SUCCESS) {
    FIRCLSSDKLog("unable to unset unregistered mask: 0x%x", mask);
    return false;
  }

  return true;
}

#pragma mark - Recording
void FIRCLSMachExceptionNameLookup(exception_type_t number,
                                          mach_exception_data_type_t code,
                                          const char** name,
                                          const char** codeName) {
  if (!name || !codeName) {
    return;
  }

  *name = NULL;
  *codeName = NULL;

  switch (number) {
    case EXC_BAD_ACCESS:
      *name = "EXC_BAD_ACCESS";
      switch (code) {
        case KERN_INVALID_ADDRESS:
          *codeName = "KERN_INVALID_ADDRESS";
          break;
        case KERN_PROTECTION_FAILURE:
          *codeName = "KERN_PROTECTION_FAILURE";
          break;
      }

      break;
    case EXC_BAD_INSTRUCTION:
      *name = "EXC_BAD_INSTRUCTION";
#if CLS_CPU_X86
      *codeName = "EXC_I386_INVOP";
#endif
      break;
    case EXC_ARITHMETIC:
      *name = "EXC_ARITHMETIC";
#if CLS_CPU_X86
      switch (code) {
        case EXC_I386_DIV:
          *codeName = "EXC_I386_DIV";
          break;
        case EXC_I386_INTO:
          *codeName = "EXC_I386_INTO";
          break;
        case EXC_I386_NOEXT:
          *codeName = "EXC_I386_NOEXT";
          break;
        case EXC_I386_EXTOVR:
          *codeName = "EXC_I386_EXTOVR";
          break;
        case EXC_I386_EXTERR:
          *codeName = "EXC_I386_EXTERR";
          break;
        case EXC_I386_EMERR:
          *codeName = "EXC_I386_EMERR";
          break;
        case EXC_I386_BOUND:
          *codeName = "EXC_I386_BOUND";
          break;
        case EXC_I386_SSEEXTERR:
          *codeName = "EXC_I386_SSEEXTERR";
          break;
      }
#endif
      break;
    case EXC_BREAKPOINT:
      *name = "EXC_BREAKPOINT";
#if CLS_CPU_X86
      switch (code) {
        case EXC_I386_DIVERR:
          *codeName = "EXC_I386_DIVERR";
          break;
        case EXC_I386_SGLSTP:
          *codeName = "EXC_I386_SGLSTP";
          break;
        case EXC_I386_NMIFLT:
          *codeName = "EXC_I386_NMIFLT";
          break;
        case EXC_I386_BPTFLT:
          *codeName = "EXC_I386_BPTFLT";
          break;
        case EXC_I386_INTOFLT:
          *codeName = "EXC_I386_INTOFLT";
          break;
        case EXC_I386_BOUNDFLT:
          *codeName = "EXC_I386_BOUNDFLT";
          break;
        case EXC_I386_INVOPFLT:
          *codeName = "EXC_I386_INVOPFLT";
          break;
        case EXC_I386_NOEXTFLT:
          *codeName = "EXC_I386_NOEXTFLT";
          break;
        case EXC_I386_EXTOVRFLT:
          *codeName = "EXC_I386_EXTOVRFLT";
          break;
        case EXC_I386_INVTSSFLT:
          *codeName = "EXC_I386_INVTSSFLT";
          break;
        case EXC_I386_SEGNPFLT:
          *codeName = "EXC_I386_SEGNPFLT";
          break;
        case EXC_I386_STKFLT:
          *codeName = "EXC_I386_STKFLT";
          break;
        case EXC_I386_GPFLT:
          *codeName = "EXC_I386_GPFLT";
          break;
        case EXC_I386_PGFLT:
          *codeName = "EXC_I386_PGFLT";
          break;
        case EXC_I386_EXTERRFLT:
          *codeName = "EXC_I386_EXTERRFLT";
          break;
        case EXC_I386_ALIGNFLT:
          *codeName = "EXC_I386_ALIGNFLT";
          break;
        case EXC_I386_ENDPERR:
          *codeName = "EXC_I386_ENDPERR";
          break;
        case EXC_I386_ENOEXTFLT:
          *codeName = "EXC_I386_ENOEXTFLT";
          break;
      }
#endif
      break;
    case EXC_GUARD:
      *name = "EXC_GUARD";
      break;
  }
}

static bool FIRCLSMachExceptionRecord(FIRCLSMachExceptionReadContext* context,
                                      MachExceptionMessage* message) {
  if (!context || !message) {
    return false;
  }

  if (FIRCLSContextMarkAndCheckIfCrashed()) {
    FIRCLSSDKLog("Error: aborting mach exception handler because crash has already occurred\n");
    exit(1);
    return false;
  }

  FIRCLSFile file;

  if (!FIRCLSFileInitWithPath(&file, context->path, false)) {
    FIRCLSSDKLog("Unable to open mach exception file\n");
    return false;
  }

  FIRCLSFileWriteSectionStart(&file, "mach_exception");

  FIRCLSFileWriteHashStart(&file);

  FIRCLSFileWriteHashEntryUint64(&file, "exception", message->exception);

  // record the codes
  FIRCLSFileWriteHashKey(&file, "codes");
  FIRCLSFileWriteArrayStart(&file);
  for (mach_msg_type_number_t i = 0; i < message->codeCnt; ++i) {
    FIRCLSFileWriteArrayEntryUint64(&file, message->code[i]);
  }
  FIRCLSFileWriteArrayEnd(&file);

  const char* name = NULL;
  const char* codeName = NULL;

  FIRCLSMachExceptionNameLookup(message->exception, message->codeCnt > 0 ? message->code[0] : 0,
                                &name, &codeName);

  FIRCLSFileWriteHashEntryString(&file, "name", name);
  FIRCLSFileWriteHashEntryString(&file, "code_name", codeName);

  FIRCLSFileWriteHashEntryUint64(&file, "original_ports", context->originalPorts.count);
  FIRCLSFileWriteHashEntryUint64(&file, "time", time(NULL));

  FIRCLSFileWriteHashEnd(&file);

  FIRCLSFileWriteSectionEnd(&file);

  FIRCLSHandler(&file, message->thread.name, NULL);

  FIRCLSFileClose(&file);

  return true;
}

#else

INJECT_STRIP_SYMBOL(cls_mach_exception)

#endif
