# Copyright 2010-2025 The pygit2 contributors # # This file is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License, version 2, # as published by the Free Software Foundation. # # In addition to the permissions in the GNU General Public License, # the authors give you unlimited permission to link the compiled # version of this file into combinations with other programs, # and to distribute those combinations without any restriction # coming from the use of this file. (The General Public License # restrictions do apply in other respects; for example, they cover # modification of the file, and distribution when not linked into # a combined executable.) # # This file is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; see the file COPYING. If not, write to # the Free Software Foundation, 51 Franklin Street, Fifth Floor, # Boston, MA 02110-1301, USA. """ Libgit2 global options management using CFFI. """ from __future__ import annotations # Import only for type checking to avoid circular imports from typing import TYPE_CHECKING, Any, Literal, cast, overload from .errors import check_error from .ffi import C, ffi from .utils import to_bytes, to_str if TYPE_CHECKING: from ._libgit2.ffi import NULL_TYPE, ArrayC, char, char_pointer from .enums import ConfigLevel, ObjectType, Option # Export GIT_OPT constants for backward compatibility GIT_OPT_GET_MWINDOW_SIZE: int = C.GIT_OPT_GET_MWINDOW_SIZE GIT_OPT_SET_MWINDOW_SIZE: int = C.GIT_OPT_SET_MWINDOW_SIZE GIT_OPT_GET_MWINDOW_MAPPED_LIMIT: int = C.GIT_OPT_GET_MWINDOW_MAPPED_LIMIT GIT_OPT_SET_MWINDOW_MAPPED_LIMIT: int = C.GIT_OPT_SET_MWINDOW_MAPPED_LIMIT GIT_OPT_GET_SEARCH_PATH: int = C.GIT_OPT_GET_SEARCH_PATH GIT_OPT_SET_SEARCH_PATH: int = C.GIT_OPT_SET_SEARCH_PATH GIT_OPT_SET_CACHE_OBJECT_LIMIT: int = C.GIT_OPT_SET_CACHE_OBJECT_LIMIT GIT_OPT_SET_CACHE_MAX_SIZE: int = C.GIT_OPT_SET_CACHE_MAX_SIZE GIT_OPT_ENABLE_CACHING: int = C.GIT_OPT_ENABLE_CACHING GIT_OPT_GET_CACHED_MEMORY: int = C.GIT_OPT_GET_CACHED_MEMORY GIT_OPT_GET_TEMPLATE_PATH: int = C.GIT_OPT_GET_TEMPLATE_PATH GIT_OPT_SET_TEMPLATE_PATH: int = C.GIT_OPT_SET_TEMPLATE_PATH GIT_OPT_SET_SSL_CERT_LOCATIONS: int = C.GIT_OPT_SET_SSL_CERT_LOCATIONS GIT_OPT_SET_USER_AGENT: int = C.GIT_OPT_SET_USER_AGENT GIT_OPT_ENABLE_STRICT_OBJECT_CREATION: int = C.GIT_OPT_ENABLE_STRICT_OBJECT_CREATION GIT_OPT_ENABLE_STRICT_SYMBOLIC_REF_CREATION: int = ( C.GIT_OPT_ENABLE_STRICT_SYMBOLIC_REF_CREATION ) GIT_OPT_SET_SSL_CIPHERS: int = C.GIT_OPT_SET_SSL_CIPHERS GIT_OPT_GET_USER_AGENT: int = C.GIT_OPT_GET_USER_AGENT GIT_OPT_ENABLE_OFS_DELTA: int = C.GIT_OPT_ENABLE_OFS_DELTA GIT_OPT_ENABLE_FSYNC_GITDIR: int = C.GIT_OPT_ENABLE_FSYNC_GITDIR GIT_OPT_GET_WINDOWS_SHAREMODE: int = C.GIT_OPT_GET_WINDOWS_SHAREMODE GIT_OPT_SET_WINDOWS_SHAREMODE: int = C.GIT_OPT_SET_WINDOWS_SHAREMODE GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION: int = C.GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION GIT_OPT_SET_ALLOCATOR: int = C.GIT_OPT_SET_ALLOCATOR GIT_OPT_ENABLE_UNSAVED_INDEX_SAFETY: int = C.GIT_OPT_ENABLE_UNSAVED_INDEX_SAFETY GIT_OPT_GET_PACK_MAX_OBJECTS: int = C.GIT_OPT_GET_PACK_MAX_OBJECTS GIT_OPT_SET_PACK_MAX_OBJECTS: int = C.GIT_OPT_SET_PACK_MAX_OBJECTS GIT_OPT_DISABLE_PACK_KEEP_FILE_CHECKS: int = C.GIT_OPT_DISABLE_PACK_KEEP_FILE_CHECKS GIT_OPT_GET_MWINDOW_FILE_LIMIT: int = C.GIT_OPT_GET_MWINDOW_FILE_LIMIT GIT_OPT_SET_MWINDOW_FILE_LIMIT: int = C.GIT_OPT_SET_MWINDOW_FILE_LIMIT GIT_OPT_GET_OWNER_VALIDATION: int = C.GIT_OPT_GET_OWNER_VALIDATION GIT_OPT_SET_OWNER_VALIDATION: int = C.GIT_OPT_SET_OWNER_VALIDATION GIT_OPT_ENABLE_HTTP_EXPECT_CONTINUE: int = C.GIT_OPT_ENABLE_HTTP_EXPECT_CONTINUE GIT_OPT_SET_ODB_PACKED_PRIORITY: int = C.GIT_OPT_SET_ODB_PACKED_PRIORITY GIT_OPT_SET_ODB_LOOSE_PRIORITY: int = C.GIT_OPT_SET_ODB_LOOSE_PRIORITY GIT_OPT_GET_EXTENSIONS: int = C.GIT_OPT_GET_EXTENSIONS GIT_OPT_SET_EXTENSIONS: int = C.GIT_OPT_SET_EXTENSIONS GIT_OPT_GET_HOMEDIR: int = C.GIT_OPT_GET_HOMEDIR GIT_OPT_SET_HOMEDIR: int = C.GIT_OPT_SET_HOMEDIR GIT_OPT_SET_SERVER_CONNECT_TIMEOUT: int = C.GIT_OPT_SET_SERVER_CONNECT_TIMEOUT GIT_OPT_GET_SERVER_CONNECT_TIMEOUT: int = C.GIT_OPT_GET_SERVER_CONNECT_TIMEOUT GIT_OPT_SET_SERVER_TIMEOUT: int = C.GIT_OPT_SET_SERVER_TIMEOUT GIT_OPT_GET_SERVER_TIMEOUT: int = C.GIT_OPT_GET_SERVER_TIMEOUT GIT_OPT_GET_USER_AGENT_PRODUCT: int = C.GIT_OPT_GET_USER_AGENT_PRODUCT GIT_OPT_SET_USER_AGENT_PRODUCT: int = C.GIT_OPT_SET_USER_AGENT_PRODUCT GIT_OPT_ADD_SSL_X509_CERT: int = C.GIT_OPT_ADD_SSL_X509_CERT NOT_PASSED = object() def check_args(option: Option, arg1: Any, arg2: Any, expected: int) -> None: if expected == 0 and (arg1 is not NOT_PASSED or arg2 is not NOT_PASSED): raise TypeError(f'option({option}) takes no additional arguments') if expected == 1 and (arg1 is NOT_PASSED or arg2 is not NOT_PASSED): raise TypeError(f'option({option}, x) requires 1 additional argument') if expected == 2 and (arg1 is NOT_PASSED or arg2 is NOT_PASSED): raise TypeError(f'option({option}, x, y) requires 2 additional arguments') @overload def option( option_type: Literal[ Option.GET_MWINDOW_SIZE, Option.GET_MWINDOW_MAPPED_LIMIT, Option.GET_MWINDOW_FILE_LIMIT, ], ) -> int: ... @overload def option( option_type: Literal[ Option.SET_MWINDOW_SIZE, Option.SET_MWINDOW_MAPPED_LIMIT, Option.SET_MWINDOW_FILE_LIMIT, Option.SET_CACHE_MAX_SIZE, ], arg1: int, # value ) -> None: ... @overload def option( option_type: Literal[Option.GET_SEARCH_PATH], arg1: ConfigLevel, # value ) -> str: ... @overload def option( option_type: Literal[Option.SET_SEARCH_PATH], arg1: ConfigLevel, # type arg2: str, # value ) -> None: ... @overload def option( option_type: Literal[Option.SET_CACHE_OBJECT_LIMIT], arg1: ObjectType, # type arg2: int, # limit ) -> None: ... @overload def option(option_type: Literal[Option.GET_CACHED_MEMORY]) -> tuple[int, int]: ... @overload def option( option_type: Literal[Option.SET_SSL_CERT_LOCATIONS], arg1: str | bytes | None, # cert_file arg2: str | bytes | None, # cert_dir ) -> None: ... @overload def option( option_type: Literal[ Option.ENABLE_CACHING, Option.ENABLE_STRICT_OBJECT_CREATION, Option.ENABLE_STRICT_SYMBOLIC_REF_CREATION, Option.ENABLE_OFS_DELTA, Option.ENABLE_FSYNC_GITDIR, Option.ENABLE_STRICT_HASH_VERIFICATION, Option.ENABLE_UNSAVED_INDEX_SAFETY, Option.DISABLE_PACK_KEEP_FILE_CHECKS, Option.SET_OWNER_VALIDATION, ], arg1: bool, # value ) -> None: ... @overload def option(option_type: Literal[Option.GET_OWNER_VALIDATION]) -> bool: ... @overload def option( option_type: Literal[ Option.GET_TEMPLATE_PATH, Option.GET_USER_AGENT, Option.GET_HOMEDIR, Option.GET_USER_AGENT_PRODUCT, ], ) -> str | None: ... @overload def option( option_type: Literal[ Option.SET_TEMPLATE_PATH, Option.SET_USER_AGENT, Option.SET_SSL_CIPHERS, Option.SET_HOMEDIR, Option.SET_USER_AGENT_PRODUCT, ], arg1: str | bytes, # value ) -> None: ... @overload def option( option_type: Literal[ Option.GET_WINDOWS_SHAREMODE, Option.GET_PACK_MAX_OBJECTS, Option.GET_SERVER_CONNECT_TIMEOUT, Option.GET_SERVER_TIMEOUT, ], ) -> int: ... @overload def option( option_type: Literal[ Option.SET_WINDOWS_SHAREMODE, Option.SET_PACK_MAX_OBJECTS, Option.ENABLE_HTTP_EXPECT_CONTINUE, Option.SET_ODB_PACKED_PRIORITY, Option.SET_ODB_LOOSE_PRIORITY, Option.SET_SERVER_CONNECT_TIMEOUT, Option.SET_SERVER_TIMEOUT, ], arg1: int, # value ) -> None: ... @overload def option(option_type: Literal[Option.GET_EXTENSIONS]) -> list[str]: ... @overload def option( option_type: Literal[Option.SET_EXTENSIONS], arg1: list[str], # extensions arg2: int, # length ) -> None: ... @overload def option( option_type: Literal[Option.ADD_SSL_X509_CERT], arg1: str | bytes, # certificate ) -> None: ... # Fallback overload for generic Option values (used in tests) @overload def option(option_type: Option, arg1: Any = ..., arg2: Any = ...) -> Any: ... def option(option_type: Option, arg1: Any = NOT_PASSED, arg2: Any = NOT_PASSED) -> Any: """ Get or set a libgit2 option. Parameters: GIT_OPT_GET_SEARCH_PATH, level Get the config search path for the given level. GIT_OPT_SET_SEARCH_PATH, level, path Set the config search path for the given level. GIT_OPT_GET_MWINDOW_SIZE Get the maximum mmap window size. GIT_OPT_SET_MWINDOW_SIZE, size Set the maximum mmap window size. GIT_OPT_GET_MWINDOW_FILE_LIMIT Get the maximum number of files that will be mapped at any time by the library. GIT_OPT_SET_MWINDOW_FILE_LIMIT, size Set the maximum number of files that can be mapped at any time by the library. The default (0) is unlimited. GIT_OPT_GET_OWNER_VALIDATION Gets the owner validation setting for repository directories. GIT_OPT_SET_OWNER_VALIDATION, enabled Set that repository directories should be owned by the current user. The default is to validate ownership. GIT_OPT_GET_TEMPLATE_PATH Get the default template path. GIT_OPT_SET_TEMPLATE_PATH, path Set the default template path. GIT_OPT_GET_USER_AGENT Get the user agent string. GIT_OPT_SET_USER_AGENT, user_agent Set the user agent string. GIT_OPT_GET_PACK_MAX_OBJECTS Get the maximum number of objects to include in a pack. GIT_OPT_SET_PACK_MAX_OBJECTS, count Set the maximum number of objects to include in a pack. """ result: str | None | list[str] if option_type in ( C.GIT_OPT_GET_MWINDOW_SIZE, C.GIT_OPT_GET_MWINDOW_MAPPED_LIMIT, C.GIT_OPT_GET_MWINDOW_FILE_LIMIT, ): check_args(option_type, arg1, arg2, 0) size_ptr = ffi.new('size_t *') err = C.git_libgit2_opts(option_type, size_ptr) check_error(err) return size_ptr[0] elif option_type in ( C.GIT_OPT_SET_MWINDOW_SIZE, C.GIT_OPT_SET_MWINDOW_MAPPED_LIMIT, C.GIT_OPT_SET_MWINDOW_FILE_LIMIT, ): check_args(option_type, arg1, arg2, 1) if not isinstance(arg1, int): raise TypeError(f'option value must be an integer, not {type(arg1)}') size = arg1 if size < 0: raise ValueError('size must be non-negative') err = C.git_libgit2_opts(option_type, ffi.cast('size_t', size)) check_error(err) return None elif option_type == C.GIT_OPT_GET_SEARCH_PATH: check_args(option_type, arg1, arg2, 1) level = int(arg1) # Convert enum to int buf = ffi.new('git_buf *') err = C.git_libgit2_opts(option_type, ffi.cast('int', level), buf) check_error(err) try: if buf.ptr != ffi.NULL: result = to_str(ffi.string(buf.ptr)) else: result = None finally: C.git_buf_dispose(buf) return result elif option_type == C.GIT_OPT_SET_SEARCH_PATH: check_args(option_type, arg1, arg2, 2) level = int(arg1) # Convert enum to int path = arg2 path_cdata: ArrayC[char] | NULL_TYPE if path is None: path_cdata = ffi.NULL else: path_bytes = to_bytes(path) path_cdata = ffi.new('char[]', path_bytes) err = C.git_libgit2_opts(option_type, ffi.cast('int', level), path_cdata) check_error(err) return None elif option_type == C.GIT_OPT_SET_CACHE_OBJECT_LIMIT: check_args(option_type, arg1, arg2, 2) object_type = int(arg1) # Convert enum to int if not isinstance(arg2, int): raise TypeError( f'option value must be an integer, not {type(arg2).__name__}' ) size = arg2 if size < 0: raise ValueError('size must be non-negative') err = C.git_libgit2_opts( option_type, ffi.cast('int', object_type), ffi.cast('size_t', size) ) check_error(err) return None elif option_type == C.GIT_OPT_SET_CACHE_MAX_SIZE: check_args(option_type, arg1, arg2, 1) size = arg1 if not isinstance(size, int): raise TypeError( f'option value must be an integer, not {type(size).__name__}' ) err = C.git_libgit2_opts(option_type, ffi.cast('ssize_t', size)) check_error(err) return None elif option_type == C.GIT_OPT_GET_CACHED_MEMORY: check_args(option_type, arg1, arg2, 0) current_ptr = ffi.new('ssize_t *') allowed_ptr = ffi.new('ssize_t *') err = C.git_libgit2_opts(option_type, current_ptr, allowed_ptr) check_error(err) return (current_ptr[0], allowed_ptr[0]) elif option_type == C.GIT_OPT_SET_SSL_CERT_LOCATIONS: check_args(option_type, arg1, arg2, 2) cert_file = arg1 cert_dir = arg2 cert_file_cdata: ArrayC[char] | NULL_TYPE if cert_file is None: cert_file_cdata = ffi.NULL else: cert_file_bytes = to_bytes(cert_file) cert_file_cdata = ffi.new('char[]', cert_file_bytes) cert_dir_cdata: ArrayC[char] | NULL_TYPE if cert_dir is None: cert_dir_cdata = ffi.NULL else: cert_dir_bytes = to_bytes(cert_dir) cert_dir_cdata = ffi.new('char[]', cert_dir_bytes) err = C.git_libgit2_opts(option_type, cert_file_cdata, cert_dir_cdata) check_error(err) return None # Handle boolean/int enable/disable options elif option_type in ( C.GIT_OPT_ENABLE_CACHING, C.GIT_OPT_ENABLE_STRICT_OBJECT_CREATION, C.GIT_OPT_ENABLE_STRICT_SYMBOLIC_REF_CREATION, C.GIT_OPT_ENABLE_OFS_DELTA, C.GIT_OPT_ENABLE_FSYNC_GITDIR, C.GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION, C.GIT_OPT_ENABLE_UNSAVED_INDEX_SAFETY, C.GIT_OPT_DISABLE_PACK_KEEP_FILE_CHECKS, C.GIT_OPT_SET_OWNER_VALIDATION, ): check_args(option_type, arg1, arg2, 1) enabled = arg1 # Convert to int (0 or 1) value = 1 if enabled else 0 err = C.git_libgit2_opts(option_type, ffi.cast('int', value)) check_error(err) return None elif option_type == C.GIT_OPT_GET_OWNER_VALIDATION: check_args(option_type, arg1, arg2, 0) enabled_ptr = ffi.new('int *') err = C.git_libgit2_opts(option_type, enabled_ptr) check_error(err) return bool(enabled_ptr[0]) elif option_type == C.GIT_OPT_GET_TEMPLATE_PATH: check_args(option_type, arg1, arg2, 0) buf = ffi.new('git_buf *') err = C.git_libgit2_opts(option_type, buf) check_error(err) try: if buf.ptr != ffi.NULL: result = to_str(ffi.string(buf.ptr)) else: result = None finally: C.git_buf_dispose(buf) return result elif option_type == C.GIT_OPT_SET_TEMPLATE_PATH: check_args(option_type, arg1, arg2, 1) path = arg1 template_path_cdata: ArrayC[char] | NULL_TYPE if path is None: template_path_cdata = ffi.NULL else: path_bytes = to_bytes(path) template_path_cdata = ffi.new('char[]', path_bytes) err = C.git_libgit2_opts(option_type, template_path_cdata) check_error(err) return None elif option_type == C.GIT_OPT_GET_USER_AGENT: check_args(option_type, arg1, arg2, 0) buf = ffi.new('git_buf *') err = C.git_libgit2_opts(option_type, buf) check_error(err) try: if buf.ptr != ffi.NULL: result = to_str(ffi.string(buf.ptr)) else: result = None finally: C.git_buf_dispose(buf) return result elif option_type == C.GIT_OPT_SET_USER_AGENT: check_args(option_type, arg1, arg2, 1) agent = arg1 agent_bytes = to_bytes(agent) agent_cdata = ffi.new('char[]', agent_bytes) err = C.git_libgit2_opts(option_type, agent_cdata) check_error(err) return None elif option_type == C.GIT_OPT_SET_SSL_CIPHERS: check_args(option_type, arg1, arg2, 1) ciphers = arg1 ciphers_bytes = to_bytes(ciphers) ciphers_cdata = ffi.new('char[]', ciphers_bytes) err = C.git_libgit2_opts(option_type, ciphers_cdata) check_error(err) return None # Handle GET_WINDOWS_SHAREMODE elif option_type == C.GIT_OPT_GET_WINDOWS_SHAREMODE: check_args(option_type, arg1, arg2, 0) value_ptr = ffi.new('unsigned int *') err = C.git_libgit2_opts(option_type, value_ptr) check_error(err) return value_ptr[0] # Handle SET_WINDOWS_SHAREMODE elif option_type == C.GIT_OPT_SET_WINDOWS_SHAREMODE: check_args(option_type, arg1, arg2, 1) if not isinstance(arg1, int): raise TypeError( f'option value must be an integer, not {type(arg1).__name__}' ) value = arg1 if value < 0: raise ValueError('value must be non-negative') err = C.git_libgit2_opts(option_type, ffi.cast('unsigned int', value)) check_error(err) return None # Handle GET_PACK_MAX_OBJECTS elif option_type == C.GIT_OPT_GET_PACK_MAX_OBJECTS: check_args(option_type, arg1, arg2, 0) size_ptr = ffi.new('size_t *') err = C.git_libgit2_opts(option_type, size_ptr) check_error(err) return size_ptr[0] # Handle SET_PACK_MAX_OBJECTS elif option_type == C.GIT_OPT_SET_PACK_MAX_OBJECTS: check_args(option_type, arg1, arg2, 1) if not isinstance(arg1, int): raise TypeError( f'option value must be an integer, not {type(arg1).__name__}' ) size = arg1 if size < 0: raise ValueError('size must be non-negative') err = C.git_libgit2_opts(option_type, ffi.cast('size_t', size)) check_error(err) return None # Handle ENABLE_HTTP_EXPECT_CONTINUE elif option_type == C.GIT_OPT_ENABLE_HTTP_EXPECT_CONTINUE: check_args(option_type, arg1, arg2, 1) enabled = arg1 # Convert to int (0 or 1) value = 1 if enabled else 0 err = C.git_libgit2_opts(option_type, ffi.cast('int', value)) check_error(err) return None # Handle SET_ODB_PACKED_PRIORITY elif option_type == C.GIT_OPT_SET_ODB_PACKED_PRIORITY: check_args(option_type, arg1, arg2, 1) if not isinstance(arg1, int): raise TypeError( f'option value must be an integer, not {type(arg1).__name__}' ) priority = arg1 err = C.git_libgit2_opts(option_type, ffi.cast('int', priority)) check_error(err) return None # Handle SET_ODB_LOOSE_PRIORITY elif option_type == C.GIT_OPT_SET_ODB_LOOSE_PRIORITY: check_args(option_type, arg1, arg2, 1) if not isinstance(arg1, int): raise TypeError( f'option value must be an integer, not {type(arg1).__name__}' ) priority = arg1 err = C.git_libgit2_opts(option_type, ffi.cast('int', priority)) check_error(err) return None # Handle GET_EXTENSIONS elif option_type == C.GIT_OPT_GET_EXTENSIONS: check_args(option_type, arg1, arg2, 0) # GET_EXTENSIONS expects a git_strarray pointer strarray = ffi.new('git_strarray *') err = C.git_libgit2_opts(option_type, strarray) check_error(err) result = [] try: if strarray.strings != ffi.NULL: # Cast to the non-NULL type for type checking strings = cast('ArrayC[char_pointer]', strarray.strings) for i in range(strarray.count): if strings[i] != ffi.NULL: result.append(to_str(ffi.string(strings[i]))) finally: # Must dispose of the strarray to free the memory C.git_strarray_dispose(strarray) return result # Handle SET_EXTENSIONS elif option_type == C.GIT_OPT_SET_EXTENSIONS: check_args(option_type, arg1, arg2, 2) extensions = arg1 length = arg2 if not isinstance(extensions, list): raise TypeError('extensions must be a list of strings') if not isinstance(length, int): raise TypeError('length must be an integer') # Create array of char pointers # libgit2 will make its own copies with git__strdup ext_array: ArrayC[char_pointer] = ffi.new('char *[]', len(extensions)) ext_strings: list[ArrayC[char]] = [] # Keep references during the call for i, ext in enumerate(extensions): ext_bytes = to_bytes(ext) ext_string: ArrayC[char] = ffi.new('char[]', ext_bytes) ext_strings.append(ext_string) ext_array[i] = ffi.cast('char *', ext_string) err = C.git_libgit2_opts(option_type, ext_array, ffi.cast('size_t', length)) check_error(err) return None # Handle GET_HOMEDIR elif option_type == C.GIT_OPT_GET_HOMEDIR: check_args(option_type, arg1, arg2, 0) buf = ffi.new('git_buf *') err = C.git_libgit2_opts(option_type, buf) check_error(err) try: if buf.ptr != ffi.NULL: result = to_str(ffi.string(buf.ptr)) else: result = None finally: C.git_buf_dispose(buf) return result # Handle SET_HOMEDIR elif option_type == C.GIT_OPT_SET_HOMEDIR: check_args(option_type, arg1, arg2, 1) path = arg1 homedir_cdata: ArrayC[char] | NULL_TYPE if path is None: homedir_cdata = ffi.NULL else: path_bytes = to_bytes(path) homedir_cdata = ffi.new('char[]', path_bytes) err = C.git_libgit2_opts(option_type, homedir_cdata) check_error(err) return None # Handle GET_SERVER_CONNECT_TIMEOUT elif option_type == C.GIT_OPT_GET_SERVER_CONNECT_TIMEOUT: check_args(option_type, arg1, arg2, 0) timeout_ptr = ffi.new('int *') err = C.git_libgit2_opts(option_type, timeout_ptr) check_error(err) return timeout_ptr[0] # Handle SET_SERVER_CONNECT_TIMEOUT elif option_type == C.GIT_OPT_SET_SERVER_CONNECT_TIMEOUT: check_args(option_type, arg1, arg2, 1) if not isinstance(arg1, int): raise TypeError( f'option value must be an integer, not {type(arg1).__name__}' ) timeout = arg1 err = C.git_libgit2_opts(option_type, ffi.cast('int', timeout)) check_error(err) return None # Handle GET_SERVER_TIMEOUT elif option_type == C.GIT_OPT_GET_SERVER_TIMEOUT: check_args(option_type, arg1, arg2, 0) timeout_ptr = ffi.new('int *') err = C.git_libgit2_opts(option_type, timeout_ptr) check_error(err) return timeout_ptr[0] # Handle SET_SERVER_TIMEOUT elif option_type == C.GIT_OPT_SET_SERVER_TIMEOUT: check_args(option_type, arg1, arg2, 1) if not isinstance(arg1, int): raise TypeError( f'option value must be an integer, not {type(arg1).__name__}' ) timeout = arg1 err = C.git_libgit2_opts(option_type, ffi.cast('int', timeout)) check_error(err) return None # Handle GET_USER_AGENT_PRODUCT elif option_type == C.GIT_OPT_GET_USER_AGENT_PRODUCT: check_args(option_type, arg1, arg2, 0) buf = ffi.new('git_buf *') err = C.git_libgit2_opts(option_type, buf) check_error(err) try: if buf.ptr != ffi.NULL: result = to_str(ffi.string(buf.ptr)) else: result = None finally: C.git_buf_dispose(buf) return result # Handle SET_USER_AGENT_PRODUCT elif option_type == C.GIT_OPT_SET_USER_AGENT_PRODUCT: check_args(option_type, arg1, arg2, 1) product = arg1 product_bytes = to_bytes(product) product_cdata = ffi.new('char[]', product_bytes) err = C.git_libgit2_opts(option_type, product_cdata) check_error(err) return None # Not implemented - ADD_SSL_X509_CERT requires directly binding with OpenSSL # as the API works accepts a X509* struct. Use GIT_OPT_SET_SSL_CERT_LOCATIONS # instead. elif option_type == C.GIT_OPT_ADD_SSL_X509_CERT: raise NotImplementedError('Use GIT_OPT_SET_SSL_CERT_LOCATIONS instead') # Not implemented - SET_ALLOCATOR is not feasible from Python level # because it requires providing C function pointers for memory management # (malloc, free, etc.) that must handle raw memory at the C level, # which cannot be safely implemented in pure Python. elif option_type == C.GIT_OPT_SET_ALLOCATOR: raise NotImplementedError('Setting a custom allocator not possible from Python') else: raise ValueError(f'Invalid option {option_type}')