1. 20 Jul, 2019 1 commit
  2. 11 Jul, 2019 1 commit
    • fileops: fix creation of directory in filesystem root · 5ae22a63
      In commit 45f24e78 (git_repository_init: stop traversing at
      windows root, 2019-04-12), we have fixed `git_futils_mkdir` to
      correctly handle the case where we create a directory in
      Windows-style filesystem roots like "C:\repo".
      
      The problem here is an off-by-one: previously, to that commit,
      we've been checking wether the parent directory's length is equal
      to the root directory's length incremented by one. When we call
      the function with "/example", then the parent directory's length
      ("/") is 1, but the root directory offset is 0 as the path is
      directly rooted without a drive prefix. This resulted in `1 == 0 +
      1`, which was true. With the change, we've stopped incrementing
      the root directory length, and thus now compare `1 <= 0`, which
      is false.
      
      The previous way of doing it was kind of finicky any non-obvious,
      which is also why the error was introduced. So instead of just
      re-adding the increment, let's explicitly add a condition that
      aborts finding the parent if the current parent path is "/".
      
      Making this change causes Azure Pipelines to fail the testcase
      repo::init::nonexistent_paths on Unix-based systems. This is because we
      have just fixed creating directories in the filesystem root, which
      previously didn't work. As Docker-based tests are running as root user,
      we are thus able to create the non-existing path and will now succeed to
      create the repository that was expected to actually fail.
      
      Let's split this up into three different tests:
      
      - A test to verify that we do not create repos in a non-existing parent
        directoy if the flag `GIT_REPOSITORY_INIT_MKPATH` is not set.
      
      - A test to verify that we fail if the root directory does not exist. As
        there is a common root directory on Unix-based systems that always
        exist, we can only test for this on Windows-based systems.
      
      - A test to verify that we fail if trying to create a repository in an
        unwriteable parent directory. We can only test this if not running
        tests as root user, as CAP_DAC_OVERRIDE will cause us to ignore
        permissions when creating files.
      Patrick Steinhardt committed
  3. 24 Jun, 2019 1 commit
  4. 17 Apr, 2019 1 commit
    • git_repository_init: stop traversing at windows root · 45f24e78
      Stop traversing the filesystem at the Windows directory root.  We were
      calculating the filesystem root for the given directory to create, and
      walking up the filesystem hierarchy.  We intended to stop when the
      traversal path length is equal to the root path length (ie, stopping at
      the root, since no path may be shorter than the root path).
      
      However, on Windows, the root path may be specified in two different
      ways, as either `Z:` or `Z:\`, where `Z:` is the current drive letter.
      `git_path_dirname_r` returns the path _without_ a trailing slash, even
      for the Windows root.  As a result, during traversal, we need to test
      that the traversal path is _less than or equal to_ the root path length
      to determine if we've hit the root to ensure that we stop when our
      traversal path is `Z:` and our calculated root path was `Z:\`.
      Edward Thomson committed
  5. 15 Feb, 2019 1 commit
    • strmap: introduce high-level setter for key/value pairs · 03555830
      Currently, one would use the function `git_strmap_insert` to insert key/value
      pairs into a map. This function has historically been a macro, which is why its
      syntax is kind of weird: instead of returning an error code directly, it instead
      has to be passed a pointer to where the return value shall be stored. This does
      not match libgit2's common idiom of directly returning error codes.
      
      Introduce a new function `git_strmap_set`, which takes as parameters the map,
      key and value and directly returns an error code. Convert all callers of
      `git_strmap_insert` to make use of it.
      Patrick Steinhardt committed
  6. 22 Jan, 2019 1 commit
  7. 10 Jun, 2018 1 commit
  8. 26 Dec, 2017 1 commit
  9. 03 Jul, 2017 1 commit
    • Make sure to always include "common.h" first · 0c7f49dd
      Next to including several files, our "common.h" header also declares
      various macros which are then used throughout the project. As such, we
      have to make sure to always include this file first in all
      implementation files. Otherwise, we might encounter problems or even
      silent behavioural differences due to macros or defines not being
      defined as they should be. So in fact, our header and implementation
      files should make sure to always include "common.h" first.
      
      This commit does so by establishing a common include pattern. Header
      files inside of "src" will now always include "common.h" as its first
      other file, separated by a newline from all the other includes to make
      it stand out as special. There are two cases for the implementation
      files. If they do have a matching header file, they will always include
      this one first, leading to "common.h" being transitively included as
      first file. If they do not have a matching header file, they instead
      include "common.h" as first file themselves.
      
      This fixes the outlined problems and will become our standard practice
      for header and source files inside of the "src/" from now on.
      Patrick Steinhardt committed
  10. 10 Jun, 2017 1 commit
  11. 08 Jun, 2017 1 commit
  12. 12 Apr, 2017 1 commit
  13. 04 Apr, 2017 1 commit
    • fileops: do not overwrite correct error message on mmap · 9daba9f4
      When executing `git_futils_mmap_ro_file`, we first try to guess whether
      the file is mmapable at all. Part of this check is whether the file is
      too large to be mmaped, which can be true on systems with 32 bit
      `size_t` types.
      
      The check is performed by first getting the file size wtih
      `git_futils_filesize` and then checking whether the returned size can be
      represented as `size_t`, returning an error if so. While this test also
      catches the case where the function returned an error (as `-1` is not
      representable by `size_t`), we will set the misleading error message
      "file too large to mmap". But in fact, a negative return value from
      `git_futils_filesize` will be caused by the inability to fstat the file.
      
      Fix the error message by handling negative return values separately and
      not overwriting the error message in that case.
      Patrick Steinhardt committed
  14. 22 Mar, 2017 1 commit
  15. 09 Mar, 2017 1 commit
  16. 28 Feb, 2017 4 commits
  17. 17 Feb, 2017 2 commits
  18. 29 Dec, 2016 1 commit
  19. 14 Nov, 2016 1 commit
  20. 04 Aug, 2016 2 commits
  21. 25 Feb, 2016 1 commit
    • nsec: support NDK's crazy nanoseconds · 3d6a42d1
      Android NDK does not have a `struct timespec` in its `struct stat`
      for nanosecond support, instead it has a single nanosecond member inside
      the struct stat itself.  We will use that and use a macro to expand to
      the `st_mtim` / `st_mtimespec` definition on other systems (much like
      the existing `st_mtime` backcompat definition).
      Edward Thomson committed
  22. 09 Feb, 2016 1 commit
  23. 20 Nov, 2015 1 commit
  24. 30 Oct, 2015 2 commits
  25. 02 Oct, 2015 1 commit
  26. 19 Sep, 2015 2 commits
  27. 17 Sep, 2015 4 commits
  28. 17 May, 2015 1 commit
  29. 15 May, 2015 1 commit
  30. 11 May, 2015 1 commit