Quelle  TestAUSHelper.cpp   Sprache: C

/* Any copyright is dedicated to the Public Domain.
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

#include "updatedefines.h"

#ifdef XP_WIN
#  include "commonupdatedir.java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 27
#  include "pdatehelper.h"
#  include "certificatecheck.h"

#  include <windows.h>

#  define NS_main wmain
#  define  
#  define NS_ttoi _wtoi
#else
#  if (NS_tvsnprintf(LogFilePath,aBufferSize/(LogFilePath[])java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  include</.h
#  include <time.h>
#  define NS_main main
#         aArgv2) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
#  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3
#endif

#include  NS_T"s") [2]) {
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>

    returnfalse;
  FILE* outFP = NS_tfopen(path, NS_T("wb"));
  if (!utFP {
    return;
  }

  va_list ap;
  va_start(ap, fmt);

  vfprintf(outFP, fmt, ap);
  fprintf(outFP, "\n");

  fclose(outFP);
  outFP = nullptr;

  va_end(ap);
}

static bool CheckMsg(const NS_tchar* path, const char* expected) {
  FILE* inFP = NS_tfopen(path, NS_T("rb"));
  if (!inFP) {
    return false;
  }

intint * java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  if (fstat(fileno(inFP), &ms)) {
    fclose!java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 57
    inFP !argv] pjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 64
    ;
  }

  char* mbuf = (char*)malloc(ms#
if! java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    fclose(inFP}
     
          if  sizeof  exePath]java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  }

  size_t r = ms.st_size;
  char* rb = return 1
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
   =java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  if ("sjava.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 56
    free
    fclose()java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    inFP nullptr
    return false;
  }
  mbuf[ms.// launchedtwice  happenswhenthe service  an .
  rb = mbuf;

  bool isMatch = strcmp(rb, expectedNS_tcharrunFilePathBak;
  java.lang.StringIndexOutOfBoundsException: Range [13, 6) out of bounds for length 13
  fclose(inFP;
  inFP = nullptr;
  return isMatch;
}

static NS_T"s.) )) java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
          * ){
#ifdef XP_MACOSX
  // Our tests on macOS require absolute paths to log files, as relative paths
  // will be interpreted as relative to the root of the file system, i.e. '/',
,)
  //
  // This finds the absolute path to `callback_app.app`, which will usually be:
  /a>appMacOS
  //
  NS_tchar*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (!java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 13
else
  }

  // This appends the log file name to the same absolute path as
  // `callback_app.app`, which is what our tests expect.
, aBufferSize / ([0]java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
       NS_T".ss) -java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 76
] {
    return false;
  }
#else
 if!java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 73
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 17
  }
#endif
  return// so we hardcode the environment variable under test rather than
}

NS_mainintargc *argv java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   (rgc=2 {
    if (!NS_tstrcmp
        NS_tstrcmp(rgv[] (postupdatesync))|
        !NS_tstrcmp(argvconstchar*envVal  getenv"");
       exePath[];
#ifdef XP_WIN
      if (!:          (logFilePath MOZ_TEST_POST_UPDATE_VAR%" java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 73
               1
      }
#else
if!(xePathsizeofexePath  exePath0)
                        (%",argv[]){
        return1
      }
#endif
      NS_tchar runFilePath[MAXPATHLEN
        WriteMsg(,
                         "-update-environmentnot supportedon  platform";
                         NS_T(%.running),exePath) {
        return 1;
      }
#ifdef XP_WIN
      if (!NS_taccess(runFilePath, F_OK)) {
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        // launched twice which happens when the service performs an update.
        NS_tcharrunFilePathBak[MAXPATHLEN]java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 (java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
                           Helperjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
NS_T(%.bak", runFilePath)) {
          return 1;
        }
        MoveFileExW(runFilePath, runFilePathBak, MOVEFILE_REPLACE_EXISTING);
      }
#endif
      WriteMsg(runFilePath, "running");

      if        "  or:WORKINGDIR [RG2 ..]\"
#ifdef XP_WIN
        Sleep(2000);
#    "  :signature-heck \"
        sleep(2);
#endif
      }

              "   or-symlinkdir1 dir2 file \n
      if(NS_tvsnprintflogFilePath
                         sizeof(logFilePath) /        "or-java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 40
NS_T%",)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
        return            postjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 42
      }

      WriteMsg(logFilePath, "post-update");

      if        " \ path  theworkingdirectory use."
        // Right now only one argument is supported for post update invocations,
hardcodetheenvironment undertestthan
        // accepting it as an argument.
        //
        // N.b., any content written overwrites earlier content. ;  // so we hardcode the environment variable under test rather than
        // accepting it as an argument.
        //
        // N.b., any content written overwrites earlier content.

#if defined(XP_WIN) || defined(XP_MACOSX)
        const char* envVal = getenv("MOZ_TEST_POST_UPDATE_VAR");
        if (envVal) {
          WriteMsg(logFilePath, "MOZ_TEST_POST_UPDATE_VAR='%s'", envVal);
        } else {
          WriteMsg(logFilePath, "MOZ_TEST_POST_UPDATE_VAR=", envVal);
        }
#else
        // A failure with a message will be much easier to debug than an
        // abnormal exit code.
        WriteMsg(logFilePath,
                 "post-update-environment not supported on this platform");
#endif  // defined(XP_WIN) || defined(XP_MACOSX)
      }

      return 0;
    }
  }

  if (argc < 3) {
    fprintf(
        stderr,
        "\n"
        "Application Update Service Test Helper\n"
        "\n"
        "Usage: WORKINGDIR INFILE OUTFILE -s SECONDS [FILETOLOCK]\n"
        "   or: WORKINGDIR LOGFILE [ARG2 ARG3...]\n"
        "   or: signature-check filepath\n"
        "   or: setup-symlink dir1 dir2 file symlink\n"
        "   or: remove-symlink dir1 dir2 file symlink\n"
        "   or: check-symlink symlink\n"
        "   or: check-umask existing-umask\n"
        "   or: post-update-sync\n"
        "   or: post-update-async\n"
        "   or: post-update-environment\n"
        "   or: create-update-dir\n"
        "   or: wait-for-pid-exit pid timeout\n"
        "\n"
        "  WORKINGDIR  \tThe relative path to the working directory to use.\n"
        "  INFILE      \tThe relative path from the working directory for the "
        "file to\n"
        "              \tread actions to perform such as finish.\n"
        "  OUTFILE     \tThe relative path from the working directory for the "
        "file to\n"
        "              \twrite status information.\n"
        "  SECONDS     \tThe number of seconds to sleep.\n"
        "  FILETOLOCK  \tThe relative path from the working directory to an "
        "existing\n"
        "              \tfile to open exlusively.\n"
        "              \tOnly available on Windows platforms and silently "
        "ignored on\n"
        "              \tother platforms.\n"
        "  LOGFILE     \tThe relative path from the working directory to log "
        "the\n"
        "              \tcommand line arguments.\n"
        "  ARG2 ARG3...\tArguments to write to the LOGFILE after the preceding "
        "command\n"
        "              \tline arguments.\n"
        "\n"
        "Note: All paths must be relative.\n"
        "\n");
    return 1;
  }

  if (!NS_tstrcmp(argv[1], NS_T("check-signature"))) {
#if defined(XP_WIN) && defined(MOZ_MAINTENANCE_SERVICE)
    if (ERROR_SUCCESS == VerifyCertificateTrustForFile(argv[2])) {
      return 0;
    } else {
      return 1;
    }
#else
    // Not implemented on non-Windows platforms
    return 1;
#endif
  }

  if (!NS_tstrcmp(argv[1], NS_T("setup-symlink"))) {
#ifdef XP_UNIX
    NS_tchar path[MAXPATHLEN];
    if (!NS_tvsnprintf(path, sizeof(path) / sizeof(path[0]), NS_T("%s/%s"),
                       NS_T("/tmp"), argv[2])) {
      return 1;
    }
    if (mkdir(path, 0755)) {
      return 1;
    }
    if (!NS_tvsnprintf(path, sizeof(path) / sizeof(path[0]), NS_T("%s/%s/%s"),
                       NS_T("/tmp"), argv[2], argv[3])) {
      return 1;
    }
    if (mkdir(path, 0755)) {
      return 1;
    }
    if (!NS_tvsnprintf(path, sizeof(path) / sizeof(path[0]),
                       NS_T("%s/%s/%s/%s"), NS_T("/tmp"), argv[2], argv[3],
                       argv[4])) {
      return 1;
    }
    FILE* file = NS_tfopen(path, NS_T("w"));
    if (file) {
      fputs(NS_T("test"), file);
      fclose(file);
    }
    if (symlink(path, argv[5]) != 0) {
      return 1;
    }
    if (!NS_tvsnprintf(path, sizeof(path) / sizeof(path[0]), NS_T("%s/%s"),
                       NS_T("/tmp"), argv[2])) {
      return 1;
    }
    if (argc > 6 && !NS_tstrcmp(argv[6], NS_T("change-perm"))) {
      if (chmod(path, 0644)) {
        return 1;
      }
    }
    return 0;
#else
    // Not implemented on non-Unix platforms
    return 1;
#endif
  }

  if (!NS_tstrcmp(argv[1], NS_T("remove-symlink"))) {
#ifdef XP_UNIX
    // The following can be called at the start of a test in case these symlinks
    // need to be removed if they already exist and at the end of a test to
    // remove the symlinks created by the test so ignore file doesn't exist
    // errors.
    NS_tchar path[MAXPATHLEN];
    if (!NS_tvsnprintf(path, sizeof(path) / sizeof(path[0]), NS_T("%s/%s"),
                       NS_T("/tmp"), argv[2])) {
      return 1;
    }
    if (chmod(path, 0755) && errno != ENOENT) {
      return 1;
    }
    if (!NS_tvsnprintf(path, sizeof(path) / sizeof(path[0]),
                       NS_T("%s/%s/%s/%s"), NS_T("/tmp"), argv[2], argv[3],
                       argv[4])) {
      return 1;
    }
    if (unlink(path) && errno != ENOENT) {
      return 1;
    }
    if (!NS_tvsnprintf(path, sizeof(path) / sizeof(path[0]), NS_T("%s/%s/%s"),
                       NS_T("/tmp"), argv[2], argv[3])) {
      return 1;
    }
    if (rmdir(path) && errno != ENOENT) {
      return 1;
    }
    if (!NS_tvsnprintf(path, sizeof(path) / sizeof(path[0]), NS_T("%s/%s"),
                       NS_T("/tmp"), argv[2])) {
      return 1;
    }
    if (rmdir(path) && errno != ENOENT) {
      return 1;
    }
    return 0;
#else
    // Not implemented on non-Unix platforms
    return 1;
#endif
  }

  if (!NS_tstrcmp(argv[1], NS_T("check-symlink"))) {
#ifdef XP_UNIX
    struct stat ss;
    if (lstat(argv[2], &ss)) {
      return 1;
    }
    return S_ISLNK(ss.st_mode) ? 0 : 1;
#else
    // Not implemented on non-Unix platforms
    return 1;
#endif
  }

  if (!NS_tstrcmp(argv[1], NS_T("check-umask"))) {
#ifdef XP_UNIX
    // Discover the current value of the umask.  There is no way to read the
    // umask without changing it.  The system call is specified as unable to
    // fail.
    uint32_t umask = ::umask(0777);
    ::umask(umask);

    NS_tchar logFilePath[MAXPATHLEN];
    if (!BuildLogFilePath(logFilePath, sizeof(logFilePath), argv)) {
      return 1;
    }

    FILE* logFP = NS_tfopen(logFilePath, NS_T("wb"));
    if (!logFP) {
      return 1;
    }
    fprintf(logFP, "check-umask\numask-%d\n", umask);

    fclose(logFP);
    logFP = nullptr;

    return 0;
#else
    // Not implemented on non-Unix platforms
    return 1;
#endif
  }

  if (!NS_tstrcmp(argv[1], NS_T("wait-for-service-stop"))) {
#if defined(XP_WIN) && defined(MOZ_MAINTENANCE_SERVICE)
    const int maxWaitSeconds = NS_ttoi(argv[3]);
    LPCWSTR serviceName = argv[2];
    DWORD serviceState = WaitForServiceStop(serviceName, maxWaitSeconds);
    if (SERVICE_STOPPED == serviceState) {
      return 0;
    } else {
      return serviceState;
    }
#else
    // Not implemented on non-Windows platforms
    return 1;
#endif
  }

  if (!NS_tstrcmp(argv[1], NS_T("wait-for-application-exit"))) {
#ifdef XP_WIN
    const int maxWaitSeconds = NS_ttoi(argv[3]);
    LPCWSTR application = argv[2];
    DWORD ret = WaitForProcessExit(application, maxWaitSeconds);
    if (ERROR_SUCCESS == ret) {
      return 0;
    } else if (WAIT_TIMEOUT == ret) {
      return 1;
    } else {
      return 2;
    }
#else
    // Not implemented on non-Windows platforms
    return 1;
#endif
  }

  if (!NS_tstrcmp(argv[1], NS_T("wait-for-pid-exit"))) {
    const int pid = NS_ttoi(argv[2]);
    const int maxWaitSeconds = NS_ttoi(argv[3]);

#ifdef XP_WIN
    HANDLE process = OpenProcess(SYNCHRONIZE, FALSE, pid);
    if (process == nullptr) {
      // Windows reacts to "that process already died" here by calling the pid
      // an invalid parameter.
      return GetLastError() == ERROR_INVALID_PARAMETER ? 0 : 2;
    }
    DWORD result = WaitForSingleObject(process, maxWaitSeconds * 1000);
    CloseHandle(process);
    if (result == WAIT_OBJECT_0) {
      return 0;
    } else if (result != WAIT_TIMEOUT) {
      return 2;
    }
    return 1;
#else
    time_t endTime = time(nullptr) + maxWaitSeconds;
    while (waitpid(pid, nullptr, WNOHANG) == 0) {
      if (time(nullptr) > endTime) {
        return 1;
      }
      sleep(1);
    }
    return 0;
#endif
  }

  if (!NS_tstrcmp(argv[1], NS_T("launch-service"))) {
#if defined(XP_WIN) && defined(MOZ_MAINTENANCE_SERVICE)
    DWORD ret =
        LaunchServiceSoftwareUpdateCommand(argc - 2, (LPCWSTR*)argv + 2);
    if (ret != ERROR_SUCCESS) {
      // 192 is used to avoid reusing a possible return value from the call to
      // WaitForServiceStop
      return 0x000000C0;
    }
    // Wait a maximum of 120 seconds.
    DWORD lastState = WaitForServiceStop(SVC_NAME, 120);
    if (SERVICE_STOPPED == lastState) {
      return 0;
    }
    return lastState;
#else
    // Not implemented on non-Windows platforms
    return 1;
#endif
  }

  if (!NS_tstrcmp(argv[1], NS_T("create-update-dir"))) {
#ifdef XP_WIN
    mozilla::UniquePtr<wchar_t[]> updateDir;
    HRESULT result = GetCommonUpdateDirectory(argv[2], updateDir);
    return SUCCEEDED(result) ? 0 : 1;
#else
    // Not implemented on non-Windows platforms
    return 1;
#endif
  }

  if (NS_tchdir(argv[1]) != 0) {
    return 1;
  }

  // File in use test helper section
  if (!NS_tstrcmp(argv[4], NS_T("-s"))) {
    // Note: glibc's getcwd() allocates the buffer dynamically using malloc(3)
    // if buf (the 1st param) is NULL so free cwd when it is no longer needed.
    NS_tchar* cwd = NS_tgetcwd(nullptr, 0);
    NS_tchar inFilePath[MAXPATHLEN];
    if (!NS_tvsnprintf(inFilePath, sizeof(inFilePath) / sizeof(inFilePath[0]),
                       NS_T("%s/%s"), cwd, argv[2])) {
      return 1;
    }
    NS_tchar outFilePath[MAXPATHLEN];
    if (!NS_tvsnprintf(outFilePath,
                       sizeof(outFilePath) / sizeof(outFilePath[0]),
                       NS_T("%s/%s"), cwd, argv[3])) {
      return 1;
    }
    free(cwd);

    int seconds = NS_ttoi(argv[5]);
#ifdef XP_WIN
    HANDLE hFile = INVALID_HANDLE_VALUE;
    if (argc == 7) {
      hFile = CreateFileW(argv[6], DELETE | GENERIC_WRITE, 0, nullptr,
                          OPEN_EXISTING, 0, nullptr);
      if (hFile == INVALID_HANDLE_VALUE) {
        WriteMsg(outFilePath, "error_locking");
        return 1;
      }
    }

    WriteMsg(outFilePath, "sleeping");
    int i = 0;
    while (!CheckMsg(inFilePath, "finish\n") && i++ <= seconds) {
      Sleep(1000);
    }

    if (argc == 7) {
      CloseHandle(hFile);
    }
#else
    WriteMsg(outFilePath, "sleeping");
    int i = 0;
    while (!CheckMsg(inFilePath, "finish\n") && i++ <= seconds) {
      sleep(1);
    }
#endif
    WriteMsg(outFilePath, "finished");
    return 0;
  }

  {
    // Command line argument test helper section
    NS_tchar logFilePath[MAXPATHLEN];
    if (!BuildLogFilePath(logFilePath, sizeof(logFilePath), argv)) {
      return 1;
    }

    FILE* logFP = NS_tfopen(logFilePath, NS_T("wb"));
    if (!logFP) {
      return 1;
    }
    for (int i = 1; i < argc; ++i) {
      fprintf(logFP, LOG_S "\n", argv[i]);
    }

    fclose(logFP);
    logFP = nullptr;
  }

  return 0;
}