// Copyright 2014 The Crashpad Authors
//
// 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 "test/multiprocess.h"

#include <signal.h>
#include <stdlib.h>
#include <unistd.h>

#include "gtest/gtest.h"
#include "test/gtest_death.h"
#include "util/file/file_io.h"

namespace crashpad {
namespace test {
namespace {

class TestMultiprocess final : public Multiprocess {
 public:
  TestMultiprocess() : Multiprocess() {}

  TestMultiprocess(const TestMultiprocess&) = delete;
  TestMultiprocess& operator=(const TestMultiprocess&) = delete;

  ~TestMultiprocess() {}

 private:
  // Multiprocess:

  void MultiprocessParent() override {
    FileHandle read_handle = ReadPipeHandle();
    char c;
    CheckedReadFileExactly(read_handle, &c, 1);
    EXPECT_EQ(c, 'M');

    pid_t pid;
    CheckedReadFileExactly(read_handle, &pid, sizeof(pid));
    EXPECT_EQ(ChildPID(), pid);

    c = 'm';
    CheckedWriteFile(WritePipeHandle(), &c, 1);

    // The child will close its end of the pipe and exit. Make sure that the
    // parent sees EOF.
    CheckedReadFileAtEOF(read_handle);
  }

  void MultiprocessChild() override {
    FileHandle write_handle = WritePipeHandle();

    char c = 'M';
    CheckedWriteFile(write_handle, &c, 1);

    pid_t pid = getpid();
    CheckedWriteFile(write_handle, &pid, sizeof(pid));

    CheckedReadFileExactly(ReadPipeHandle(), &c, 1);
    EXPECT_EQ(c, 'm');
  }
};

TEST(Multiprocess, Multiprocess) {
  TestMultiprocess multiprocess;
  multiprocess.Run();
}

class TestMultiprocessUnclean final : public Multiprocess {
 public:
  enum TerminationType {
    kExitSuccess = 0,
    kExitFailure,
    kExit2,
    kAbort,
  };

  explicit TestMultiprocessUnclean(TerminationType type)
      : Multiprocess(),
        type_(type) {
    if (type_ == kAbort) {
      SetExpectedChildTermination(kTerminationSignal, SIGABRT);
    } else {
      SetExpectedChildTermination(kTerminationNormal, ExitCode());
    }
  }

  TestMultiprocessUnclean(const TestMultiprocessUnclean&) = delete;
  TestMultiprocessUnclean& operator=(const TestMultiprocessUnclean&) = delete;

  ~TestMultiprocessUnclean() {}

 private:
  int ExitCode() const {
    return type_;
  }

  // Multiprocess:

  void MultiprocessParent() override {
  }

  void MultiprocessChild() override {
    if (type_ == kAbort) {
      abort();
    } else {
      _exit(ExitCode());
    }
  }

  TerminationType type_;
};

TEST(Multiprocess, SuccessfulExit) {
  TestMultiprocessUnclean multiprocess(TestMultiprocessUnclean::kExitSuccess);
  multiprocess.Run();
}

TEST(Multiprocess, UnsuccessfulExit) {
  TestMultiprocessUnclean multiprocess(TestMultiprocessUnclean::kExitFailure);
  multiprocess.Run();
}

TEST(Multiprocess, Exit2) {
  TestMultiprocessUnclean multiprocess(TestMultiprocessUnclean::kExit2);
  multiprocess.Run();
}

TEST(Multiprocess, AbortSignal) {
  TestMultiprocessUnclean multiprocess(TestMultiprocessUnclean::kAbort);
  multiprocess.Run();
}

class TestMultiprocessClosePipe final : public Multiprocess {
 public:
  enum WhoCloses {
    kParentCloses = 0,
    kChildCloses,
  };
  enum WhatCloses {
    kReadCloses = 0,
    kWriteCloses,
    kReadAndWriteClose,
  };

  TestMultiprocessClosePipe(WhoCloses who_closes, WhatCloses what_closes)
      : Multiprocess(),
        who_closes_(who_closes),
        what_closes_(what_closes) {
    // Fails under "threadsafe" mode on macOS 10.11.
    GTEST_FLAG_SET(death_test_style, "fast");
  }

  TestMultiprocessClosePipe(const TestMultiprocessClosePipe&) = delete;
  TestMultiprocessClosePipe& operator=(const TestMultiprocessClosePipe&) =
      delete;

  ~TestMultiprocessClosePipe() {}

 private:
  void VerifyInitial() {
    ASSERT_NE(ReadPipeHandle(), -1);
    ASSERT_NE(WritePipeHandle(), -1);
  }

  // Verifies that the partner process did what it was supposed to do. This must
  // only be called when who_closes_ names the partner process, not this
  // process.
  //
  // If the partner was supposed to close its write pipe, the read pipe will be
  // checked to ensure that it shows end-of-file.
  //
  // If the partner was supposed to close its read pipe, the write pipe will be
  // checked to ensure that a checked write causes death. This can only be done
  // if the partner also provides some type of signal when it has closed its
  // read pipe, which is done in the form of it closing its write pipe, causing
  // the read pipe in this process to show end-of-file.
  void VerifyPartner() {
    if (what_closes_ == kWriteCloses) {
      CheckedReadFileAtEOF(ReadPipeHandle());
    } else if (what_closes_ == kReadAndWriteClose) {
      CheckedReadFileAtEOF(ReadPipeHandle());
      char c = '\0';

      // This will raise SIGPIPE. If fatal (the normal case), that will cause
      // process termination. If SIGPIPE is being handled somewhere, the write
      // will still fail and set errno to EPIPE, and CheckedWriteFile() will
      // abort execution. Regardless of how SIGPIPE is handled, the process will
      // be terminated. Because the actual termination mechanism is not known,
      // no regex can be specified.
      EXPECT_DEATH_CHECK(CheckedWriteFile(WritePipeHandle(), &c, 1), "");
    }
  }

  void Close() {
    switch (what_closes_) {
      case kReadCloses:
        CloseReadPipe();
        EXPECT_NE(WritePipeHandle(), -1);
        EXPECT_DEATH_CHECK(ReadPipeHandle(), "fd");
        break;
      case kWriteCloses:
        CloseWritePipe();
        EXPECT_NE(ReadPipeHandle(), -1);
        EXPECT_DEATH_CHECK(WritePipeHandle(), "fd");
        break;
      case kReadAndWriteClose:
        CloseReadPipe();
        CloseWritePipe();
        EXPECT_DEATH_CHECK(ReadPipeHandle(), "fd");
        EXPECT_DEATH_CHECK(WritePipeHandle(), "fd");
        break;
    }
  }

  // Multiprocess:

  void MultiprocessParent() override {
    ASSERT_NO_FATAL_FAILURE(VerifyInitial());

    if (who_closes_ == kParentCloses) {
      Close();
    } else {
      VerifyPartner();
    }
  }

  void MultiprocessChild() override {
    ASSERT_NO_FATAL_FAILURE(VerifyInitial());

    if (who_closes_ == kChildCloses) {
      Close();
    } else {
      VerifyPartner();
    }
  }

  WhoCloses who_closes_;
  WhatCloses what_closes_;
};

TEST(MultiprocessDeathTest, ParentClosesReadPipe) {
  TestMultiprocessClosePipe multiprocess(
      TestMultiprocessClosePipe::kParentCloses,
      TestMultiprocessClosePipe::kReadCloses);
  multiprocess.Run();
}

TEST(MultiprocessDeathTest, ParentClosesWritePipe) {
  TestMultiprocessClosePipe multiprocess(
      TestMultiprocessClosePipe::kParentCloses,
      TestMultiprocessClosePipe::kWriteCloses);
  multiprocess.Run();
}

TEST(MultiprocessDeathTest, ParentClosesReadAndWritePipe) {
  TestMultiprocessClosePipe multiprocess(
      TestMultiprocessClosePipe::kParentCloses,
      TestMultiprocessClosePipe::kReadAndWriteClose);
  multiprocess.Run();
}

TEST(MultiprocessDeathTest, ChildClosesReadPipe) {
  TestMultiprocessClosePipe multiprocess(
      TestMultiprocessClosePipe::kChildCloses,
      TestMultiprocessClosePipe::kReadCloses);
  multiprocess.Run();
}

TEST(MultiprocessDeathTest, ChildClosesWritePipe) {
  TestMultiprocessClosePipe multiprocess(
      TestMultiprocessClosePipe::kChildCloses,
      TestMultiprocessClosePipe::kWriteCloses);
  multiprocess.Run();
}

TEST(MultiprocessDeathTest, ChildClosesReadAndWritePipe) {
  TestMultiprocessClosePipe multiprocess(
      TestMultiprocessClosePipe::kChildCloses,
      TestMultiprocessClosePipe::kReadAndWriteClose);
  multiprocess.Run();
}

}  // namespace
}  // namespace test
}  // namespace crashpad