1. 01 Jul, 2020 3 commits
  2. 09 Jun, 2020 1 commit
  3. 10 Mar, 2020 2 commits
    • win32: don't canonicalize symlink targets · 43d7a42b
      Don't canonicalize symlink targets; our win32 path canonicalization
      routines expect an absolute path.  In particular, using the path
      canonicalization routines for symlink targets (introduced in commit
      7d55bee6, "win32: fix relative symlinks pointing into dirs",
      2020-01-10).
      
      Now, use the utf8 -> utf16 relative path handling functions, so that
      paths like "../foo" will be translated to "..\foo".
      Edward Thomson committed
    • win32: introduce relative path handling function · f2b114ba
      Add a function that takes a (possibly) relative UTF-8 path and emits a
      UTF-16 path with forward slashes translated to backslashes.  If the
      given path is, in fact, absolute, it will be translated to absolute path
      handling rules.
      Edward Thomson committed
  4. 08 Mar, 2020 1 commit
    • win32: clarify usage of path canonicalization funcs · fb7da154
      The path canonicalization functions on win32 are intended to
      canonicalize absolute paths; those with prefixes.  In other words,
      things start with drive letters (`C:\`), share names (`\\server\share`),
      or other prefixes (`\\?\`).
      
      This function removes leading `..` that occur after the prefix but
      before the directory/file portion (eg, turning `C:\..\..\..\foo` into
      `C:\foo`).  This translation is not appropriate for local paths.
      Edward Thomson committed
  5. 10 Jan, 2020 1 commit
    • win32: fix relative symlinks pointing into dirs · 7d55bee6
      On Windows platforms, we need some logic to emulate symlink(3P) defined
      by POSIX. As unprivileged symlinks on Windows are a rather new feature,
      our current implementation is comparatively new and still has some
      rough edges in special cases.
      
      One such case is relative symlinks. While relative symlinks to files in
      the same directory work as expected, libgit2 currently fails to create
      reltaive symlinks pointing into other directories. This is due to the
      fact that we forgot to translate the Unix-style target path to
      Windows-style. Most importantly, we are currently not converting
      directory separators from "/" to "\".
      
      Fix the issue by calling `git_win32_path_canonicalize` on the target.
      Add a test that verifies our ability to create such relative links
      across directories.
      Patrick Steinhardt committed
  6. 29 Nov, 2019 1 commit
    • global: convert to fiber-local storage to fix exit races · 5c6180b5
      On Windows platforms, we automatically clean up the thread-local storage
      upon detaching a thread via `DllMain()`. The thing is that this happens
      for every thread of applications that link against the libgit2 DLL, even
      those that don't have anything to do with libgit2 itself. As a result,
      we cannot assume that these unsuspecting threads make use of our
      `git_libgit2_init()` and `git_libgit2_shutdow()` reference counting,
      which may lead to racy situations:
      
          Thread 1                    Thread 2
      
          git_libgit2_shutdown()
                                      DllMain(DETACH_THREAD)
                                      git__free_tls_data()
          git_atomic_dec() == 0
          git__free_tls_data()
          TlsFree(_tls_index)
                                      TlsGetValue(_tls_index)
      
      Due to the second thread never having executed `git_libgit2_init()`, the
      first thread will clean up TLS data and as a result also free the
      `_tls_index` variable. When detaching the second thread, we
      unconditionally access the now-free'd `_tls_index` variable, which is
      obviously not going to work out well.
      
      Fix the issue by converting the code to use fiber-local storage instead
      of thread-local storage. While FLS will behave the exact same as TLS if
      no fibers are in use, it does allow us to specify a destructor similar
      to the one that is accepted by pthread_key_create(3P). Like this, we do
      not have to manually free indices anymore, but will let the FLS handle
      calling the destructor. This allows us to get rid of `DllMain()`
      completely, as we only used it to keep track of when threads were
      exiting and results in an overall simplification of TLS cleanup.
      Patrick Steinhardt committed
  7. 25 Nov, 2019 3 commits
  8. 20 Jul, 2019 3 commits
    • win32: fix symlinks to relative file targets · 50194dcd
      When creating a symlink in Windows, one needs to tell Windows whether
      the symlink should be a file or directory symlink. To determine which
      flag to pass, we call `GetFileAttributesW` on the target file to see
      whether it is a directory and then pass the flag accordingly. The
      problem though is if create a symlink with a relative target path, then
      we will check that relative path while not necessarily being inside of
      the working directory where the symlink is to be created. Thus, getting
      its attributes will either fail or return attributes of the wrong
      target.
      
      Fix this by resolving the target path relative to the directory in which
      the symlink is to be created.
      Patrick Steinhardt committed
    • win32: correctly unlink symlinks to directories · a00842c4
      When deleting a symlink on Windows, then the way to delete it depends on
      whether it is a directory symlink or a file symlink. In the first case,
      we need to use `DeleteFile`, in the second `RemoveDirectory`. Right now,
      `p_unlink` will only ever try to use `DeleteFile`, though, and thus fail
      to remove directory symlinks. This mismatches how unlink(3P) is expected
      to behave, though, as it shall remove any symlink disregarding whether
      it is a file or directory symlink.
      
      In order to correctly unlink a symlink, we thus need to check what kind
      of file this is. If we were to first query file attributes of every file
      upon calling `p_unlink`, then this would penalize the common case
      though. Instead, we can try to first delete the file with `DeleteFile`
      and only if the error returned is `ERROR_ACCESS_DENIED` will we query
      file attributes and determine whether it is a directory symlink to use
      `RemoveDirectory` instead.
      Patrick Steinhardt committed
    • fileops: rename to "futils.h" to match function signatures · e54343a4
      Our file utils functions all have a "futils" prefix, e.g.
      `git_futils_touch`. One would thus naturally guess that their
      definitions and implementation would live in files "futils.h" and
      "futils.c", respectively, but in fact they live in "fileops.h".
      
      Rename the files to match expectations.
      Patrick Steinhardt committed
  9. 05 Jul, 2019 1 commit
    • w32_stack: convert buffer length param to `size_t` · 2f14c4fc
      In both `git_win32__stack_format` and `git_win32__stack`, we handle
      buffer lengths via an integer variable. As we only ever pass buffer
      sizes to it, this should be a `size_t` though to avoid loss of
      precision. As we also use it to compare with other `size_t` variables,
      this also silences signed/unsigned comparison warnings.
      Patrick Steinhardt committed
  10. 25 Jun, 2019 1 commit
  11. 24 Jun, 2019 5 commits
  12. 14 Jun, 2019 1 commit
    • posix: remove `p_fallocate` abstraction · 2d85c7e8
      By now, we have repeatedly failed to provide a nice
      cross-platform implementation of `p_fallocate`. Recent tries to
      do that escalated quite fast to a set of different CMake checks,
      implementations, fallbacks, etc., which started to look real
      awkward to maintain. In fact, `p_fallocate` had only been
      introduced in commit 4e3949b7 (tests: test that largefiles can
      be read through the tree API, 2019-01-30) to support a test with
      large files, but given the maintenance costs it just seems not to
      be worht it.
      
      As we have removed the sole user of `p_fallocate` in the previous
      commit, let's drop it altogether.
      Patrick Steinhardt committed
  13. 20 May, 2019 1 commit
  14. 19 May, 2019 3 commits
  15. 06 May, 2019 1 commit
  16. 05 May, 2019 1 commit
  17. 22 Feb, 2019 1 commit
  18. 21 Feb, 2019 1 commit
    • allocators: extract crtdbg allocator into its own file · 48727e5d
      The Windows-specific crtdbg allocator is currently mixed into the
      crtdbg stacktracing compilation unit, making it harder to find
      than necessary. Extract it and move it into the new "allocators/"
      subdirectory to improve discoverability.
      
      This change means that the crtdbg compilation unit is now
      compiled unconditionally, whereas it has previously only been
      compiled on Windows platforms. Thus we now have additional guards
      around the code so that it will only be compiled if
      GIT_MSVC_CRTDBG is defined. This also allows us to move over the
      fallback-implementation of `git_win32_crtdbg_init_allocator` into
      the same compilation unit.
      Patrick Steinhardt committed
  19. 30 Jan, 2019 1 commit
  20. 25 Jan, 2019 1 commit
    • windows: add SSIZE_MAX · a861839d
      Windows doesn't include ssize_t or its _MAX value by default.  We are
      already declaring ssize_t as SSIZE_T, which is __int64_t on Win64 and
      long otherwise.  Include its _MAX value as a correspondence to its type.
      Edward Thomson committed
  21. 22 Jan, 2019 1 commit
  22. 06 Jan, 2019 1 commit
    • Fix a bunch of warnings · 7b453e7e
      This change fixes a bunch of warnings that were discovered by compiling
      with `clang -target=i386-pc-linux-gnu`. It turned out that the
      intrinsics were not necessarily being used in all platforms! Especially
      in GCC, since it does not support __has_builtin.
      
      Some more warnings were gleaned from the Windows build, but I stopped
      when I saw that some third-party dependencies (e.g. zlib) have warnings
      of their own, so we might never be able to enable -Werror there.
      lhchavez committed
  23. 20 Oct, 2018 2 commits
  24. 19 Oct, 2018 2 commits
    • win32: refactor `git_win32_path_remove_namespace` · a34f5b0d
      Update `git_win32_path_remove_namespace` to disambiguate the prefix
      being removed versus the prefix being added.  Now we remove the
      "namespace", and (may) add a "prefix" in its place.  Eg, we remove the
      `\\?\` namespace.  We remove the `\\?\UNC\` namespace, and replace it
      with the `\\` prefix.  This aids readability somewhat.
      
      Additionally, use pointer arithmetic instead of offsets, which seems to
      also help readability.
      Edward Thomson committed
    • win32: rename `git_win32__canonicalize_path` · b2e85f98
      The internal API `git_win32__canonicalize_path` is far, far too easily
      confused with the internal API `git_win32_path_canonicalize`.  The
      former removes the namespace prefix from a path (eg, given
      `\\?\C:\Temp\foo`, it returns `C:\Temp\foo`, and given
      `\\?\UNC\server\share`, it returns `\\server\share`).  As such, rename
      it to `git_win32_path_remove_namespace`.
      
      `git_win32_path_canonicalize` remains unchanged.
      Edward Thomson committed
  25. 30 Sep, 2018 1 commit