├── .codecov.yml ├── .github └── workflows │ ├── build.yml │ ├── build_freebsd.yml │ ├── build_ossfuzz.yml │ ├── build_shared.yml │ └── build_wheel.yml ├── .gitignore ├── AUTHORS ├── COPYING ├── COPYING.LESSER ├── ChangeLog ├── Makefile.am ├── NEWS ├── README ├── acinclude.m4 ├── appveyor.yml ├── autogen.ps1 ├── autogen.sh ├── build.ps1 ├── builddokan.ps1 ├── common ├── Makefile.am ├── byte_stream.h ├── common.h ├── config_borlandc.h ├── config_msc.h ├── config_winapi.h ├── file_stream.h ├── memory.h ├── narrow_string.h ├── system_string.h ├── types.h.in └── wide_string.h ├── configure.ac ├── documentation └── Logical Volume Manager (LVM) format.asciidoc ├── dpkg ├── changelog.in ├── compat ├── control ├── copyright ├── libvslvm-dev.install ├── libvslvm-python3.install ├── libvslvm-tools.install ├── libvslvm.install ├── rules └── source │ └── format ├── include ├── Makefile.am ├── libvslvm.h.in └── libvslvm │ ├── codepage.h │ ├── definitions.h.in │ ├── error.h │ ├── extern.h │ ├── features.h.in │ └── types.h.in ├── libvslvm.ini ├── libvslvm.nuspec ├── libvslvm.pc.in ├── libvslvm.spec.in ├── libvslvm ├── Makefile.am ├── libvslvm.c ├── libvslvm.rc.in ├── libvslvm_checksum.c ├── libvslvm_checksum.h ├── libvslvm_chunk_data.c ├── libvslvm_chunk_data.h ├── libvslvm_data_area_descriptor.c ├── libvslvm_data_area_descriptor.h ├── libvslvm_debug.c ├── libvslvm_debug.h ├── libvslvm_definitions.h.in ├── libvslvm_error.c ├── libvslvm_error.h ├── libvslvm_extern.h ├── libvslvm_handle.c ├── libvslvm_handle.h ├── libvslvm_io_handle.c ├── libvslvm_io_handle.h ├── libvslvm_libbfio.h ├── libvslvm_libcdata.h ├── libvslvm_libcerror.h ├── libvslvm_libclocale.h ├── libvslvm_libcnotify.h ├── libvslvm_libcsplit.h ├── libvslvm_libcthreads.h ├── libvslvm_libfcache.h ├── libvslvm_libfdata.h ├── libvslvm_libfvalue.h ├── libvslvm_logical_volume.c ├── libvslvm_logical_volume.h ├── libvslvm_logical_volume_values.c ├── libvslvm_logical_volume_values.h ├── libvslvm_metadata.c ├── libvslvm_metadata.h ├── libvslvm_metadata_area.c ├── libvslvm_metadata_area.h ├── libvslvm_notify.c ├── libvslvm_notify.h ├── libvslvm_physical_volume.c ├── libvslvm_physical_volume.h ├── libvslvm_raw_location_descriptor.c ├── libvslvm_raw_location_descriptor.h ├── libvslvm_segment.c ├── libvslvm_segment.h ├── libvslvm_stripe.c ├── libvslvm_stripe.h ├── libvslvm_support.c ├── libvslvm_support.h ├── libvslvm_types.h ├── libvslvm_unused.h ├── libvslvm_volume_group.c ├── libvslvm_volume_group.h ├── vslvm_metadata_area.h └── vslvm_physical_volume_label.h ├── m4 ├── common.m4 ├── libbfio.m4 ├── libcdata.m4 ├── libcerror.m4 ├── libcfile.m4 ├── libclocale.m4 ├── libcnotify.m4 ├── libcpath.m4 ├── libcsplit.m4 ├── libcthreads.m4 ├── libfcache.m4 ├── libfdata.m4 ├── libfuse.m4 ├── libfvalue.m4 ├── libuna.m4 ├── pthread.m4 ├── python.m4 ├── tests.m4 └── types.m4 ├── manuals ├── Makefile.am ├── libvslvm.3 └── vslvminfo.1 ├── msvscpp ├── Makefile.am ├── libbfio │ └── libbfio.vcproj ├── libcdata │ └── libcdata.vcproj ├── libcerror │ └── libcerror.vcproj ├── libcfile │ └── libcfile.vcproj ├── libclocale │ └── libclocale.vcproj ├── libcnotify │ └── libcnotify.vcproj ├── libcpath │ └── libcpath.vcproj ├── libcsplit │ └── libcsplit.vcproj ├── libcthreads │ └── libcthreads.vcproj ├── libfcache │ └── libfcache.vcproj ├── libfdata │ └── libfdata.vcproj ├── libfvalue │ └── libfvalue.vcproj ├── libuna │ └── libuna.vcproj ├── libvslvm.sln ├── libvslvm │ └── libvslvm.vcproj ├── pyvslvm │ └── pyvslvm.vcproj ├── vslvm_test_checksum │ └── vslvm_test_checksum.vcproj ├── vslvm_test_chunk_data │ └── vslvm_test_chunk_data.vcproj ├── vslvm_test_data_area_descriptor │ └── vslvm_test_data_area_descriptor.vcproj ├── vslvm_test_error │ └── vslvm_test_error.vcproj ├── vslvm_test_handle │ └── vslvm_test_handle.vcproj ├── vslvm_test_io_handle │ └── vslvm_test_io_handle.vcproj ├── vslvm_test_logical_volume │ └── vslvm_test_logical_volume.vcproj ├── vslvm_test_logical_volume_values │ └── vslvm_test_logical_volume_values.vcproj ├── vslvm_test_metadata │ └── vslvm_test_metadata.vcproj ├── vslvm_test_metadata_area │ └── vslvm_test_metadata_area.vcproj ├── vslvm_test_notify │ └── vslvm_test_notify.vcproj ├── vslvm_test_physical_volume │ └── vslvm_test_physical_volume.vcproj ├── vslvm_test_raw_location_descriptor │ └── vslvm_test_raw_location_descriptor.vcproj ├── vslvm_test_segment │ └── vslvm_test_segment.vcproj ├── vslvm_test_stripe │ └── vslvm_test_stripe.vcproj ├── vslvm_test_support │ └── vslvm_test_support.vcproj ├── vslvm_test_tools_info_handle │ └── vslvm_test_tools_info_handle.vcproj ├── vslvm_test_tools_output │ └── vslvm_test_tools_output.vcproj ├── vslvm_test_tools_signal │ └── vslvm_test_tools_signal.vcproj ├── vslvm_test_volume_group │ └── vslvm_test_volume_group.vcproj ├── vslvminfo │ └── vslvminfo.vcproj └── vslvmmount │ └── vslvmmount.vcproj ├── ossfuzz ├── Makefile.am ├── handle_fuzzer.cc ├── logical_volume_fuzzer.cc ├── ossfuzz_libbfio.h └── ossfuzz_libvslvm.h ├── po ├── ChangeLog ├── Makevars.in └── POTFILES.in ├── pyproject.toml ├── pyvslvm ├── Makefile.am ├── pyvslvm.c ├── pyvslvm.h ├── pyvslvm_error.c ├── pyvslvm_error.h ├── pyvslvm_file_object_io_handle.c ├── pyvslvm_file_object_io_handle.h ├── pyvslvm_file_objects_io_pool.c ├── pyvslvm_file_objects_io_pool.h ├── pyvslvm_handle.c ├── pyvslvm_handle.h ├── pyvslvm_integer.c ├── pyvslvm_integer.h ├── pyvslvm_libbfio.h ├── pyvslvm_libcerror.h ├── pyvslvm_libclocale.h ├── pyvslvm_libvslvm.h ├── pyvslvm_logical_volume.c ├── pyvslvm_logical_volume.h ├── pyvslvm_logical_volumes.c ├── pyvslvm_logical_volumes.h ├── pyvslvm_physical_volume.c ├── pyvslvm_physical_volume.h ├── pyvslvm_physical_volumes.c ├── pyvslvm_physical_volumes.h ├── pyvslvm_python.h ├── pyvslvm_segment.c ├── pyvslvm_segment.h ├── pyvslvm_segments.c ├── pyvslvm_segments.h ├── pyvslvm_stripe.c ├── pyvslvm_stripe.h ├── pyvslvm_stripes.c ├── pyvslvm_stripes.h ├── pyvslvm_unused.h ├── pyvslvm_volume_group.c └── pyvslvm_volume_group.h ├── runtests.ps1 ├── runtests.sh ├── setup.cfg.in ├── setup.py ├── syncdokan.ps1 ├── synclibs.ps1 ├── synclibs.sh ├── synctestdata.ps1 ├── synctestdata.sh ├── tests ├── Makefile.am ├── build.sh ├── data │ ├── metadata_area.1 │ ├── physical_volume_header.1 │ ├── physical_volume_label.1 │ └── raw_location_descriptor.1 ├── lsan.suppressions ├── pkgbuild.sh ├── pyvslvm_test_handle.py ├── pyvslvm_test_support.py ├── runtests.py ├── runtests.sh ├── syncsharedlibs.sh ├── test_library.ps1 ├── test_library.sh ├── test_manpage.sh ├── test_python_module.sh ├── test_runner.sh ├── test_tools.ps1 ├── test_tools.sh ├── test_vslvminfo.ps1 ├── test_vslvminfo.sh ├── vslvm_test_checksum.c ├── vslvm_test_chunk_data.c ├── vslvm_test_data_area_descriptor.c ├── vslvm_test_error.c ├── vslvm_test_functions.c ├── vslvm_test_functions.h ├── vslvm_test_getopt.c ├── vslvm_test_getopt.h ├── vslvm_test_handle.c ├── vslvm_test_io_handle.c ├── vslvm_test_libbfio.h ├── vslvm_test_libcerror.h ├── vslvm_test_libclocale.h ├── vslvm_test_libcnotify.h ├── vslvm_test_libuna.h ├── vslvm_test_libvslvm.h ├── vslvm_test_logical_volume.c ├── vslvm_test_logical_volume_values.c ├── vslvm_test_macros.h ├── vslvm_test_memory.c ├── vslvm_test_memory.h ├── vslvm_test_metadata.c ├── vslvm_test_metadata_area.c ├── vslvm_test_notify.c ├── vslvm_test_physical_volume.c ├── vslvm_test_raw_location_descriptor.c ├── vslvm_test_segment.c ├── vslvm_test_stripe.c ├── vslvm_test_support.c ├── vslvm_test_tools_info_handle.c ├── vslvm_test_tools_output.c ├── vslvm_test_tools_signal.c ├── vslvm_test_unused.h └── vslvm_test_volume_group.c ├── tox.ini └── vslvmtools ├── Makefile.am ├── byte_size_string.c ├── byte_size_string.h ├── info_handle.c ├── info_handle.h ├── mount_dokan.c ├── mount_dokan.h ├── mount_file_entry.c ├── mount_file_entry.h ├── mount_file_system.c ├── mount_file_system.h ├── mount_fuse.c ├── mount_fuse.h ├── mount_handle.c ├── mount_handle.h ├── vslvminfo.c ├── vslvmmount.c ├── vslvmtools_getopt.c ├── vslvmtools_getopt.h ├── vslvmtools_i18n.h ├── vslvmtools_libbfio.h ├── vslvmtools_libcdata.h ├── vslvmtools_libcerror.h ├── vslvmtools_libclocale.h ├── vslvmtools_libcnotify.h ├── vslvmtools_libcpath.h ├── vslvmtools_libuna.h ├── vslvmtools_libvslvm.h ├── vslvmtools_output.c ├── vslvmtools_output.h ├── vslvmtools_signal.c ├── vslvmtools_signal.h └── vslvmtools_unused.h /.codecov.yml: -------------------------------------------------------------------------------- 1 | coverage: 2 | precision: 2 3 | round: down 4 | range: 70...100 5 | status: 6 | project: true 7 | patch: true 8 | changes: false 9 | ignore: 10 | - "libbfio/*" 11 | - "libcdata/*" 12 | - "libcerror/*" 13 | - "libcfile/*" 14 | - "libclocale/*" 15 | - "libcnotify/*" 16 | - "libcpath/*" 17 | - "libcsplit/*" 18 | - "libcthreads/*" 19 | - "libfcache/*" 20 | - "libfdata/*" 21 | - "libfvalue/*" 22 | - "libuna/*" 23 | - "tests/*" 24 | -------------------------------------------------------------------------------- /.github/workflows/build_freebsd.yml: -------------------------------------------------------------------------------- 1 | # Build from source on FreeBSD. 2 | name: build_freebsd 3 | on: [push] 4 | permissions: read-all 5 | jobs: 6 | build_freebsd: 7 | runs-on: ubuntu-22.04 8 | steps: 9 | - uses: actions/checkout@v4 10 | - name: Building from source 11 | id: build_freebsd 12 | uses: vmactions/freebsd-vm@v1 13 | with: 14 | usesh: true 15 | mem: 4096 16 | # Note that the test scripts require bash 17 | prepare: | 18 | pkg install -y autoconf automake bash fusefs-libs gettext git libtool pkgconf 19 | run: | 20 | tests/build.sh 21 | tests/runtests.sh 22 | -------------------------------------------------------------------------------- /.github/workflows/build_ossfuzz.yml: -------------------------------------------------------------------------------- 1 | # Build OSSFuzz fuzz targets from source. 2 | name: build_ossfuzz 3 | on: 4 | push: 5 | branches: [main] 6 | permissions: read-all 7 | jobs: 8 | build_ossfuzz: 9 | runs-on: ubuntu-22.04 10 | strategy: 11 | matrix: 12 | include: 13 | - architecture: 'x64' 14 | compiler: 'gcc' 15 | configure_options: '' 16 | steps: 17 | - name: Install build dependencies 18 | run: | 19 | sudo apt-get -y install git 20 | - uses: actions/checkout@v4 21 | with: 22 | repository: google/oss-fuzz 23 | path: oss-fuzz 24 | - name: Build OSSFuzz fuzz targets 25 | working-directory: oss-fuzz 26 | run: | 27 | mkdir -p projects/libvslvm 28 | cp projects/libyal/build.sh projects/libvslvm/ 29 | cp projects/libyal/project.yaml projects/libvslvm/ 30 | head -n 20 projects/libyal/Dockerfile > projects/libvslvm/Dockerfile 31 | echo "RUN git clone --depth 1 https://github.com/libyal/libvslvm.git libvslvm" >> projects/libvslvm/Dockerfile 32 | tail -n 3 projects/libyal/Dockerfile >> projects/libvslvm/Dockerfile 33 | python3 infra/helper.py build_image --pull libvslvm 34 | python3 infra/helper.py build_fuzzers --sanitizer address libvslvm 35 | python3 infra/helper.py check_build libvslvm 36 | -------------------------------------------------------------------------------- /.github/workflows/build_shared.yml: -------------------------------------------------------------------------------- 1 | # Build from source with libyal dependencies as shared libraries. 2 | name: build_shared 3 | on: 4 | push: 5 | branches: [main] 6 | permissions: read-all 7 | jobs: 8 | build_shared_ubuntu: 9 | runs-on: ubuntu-22.04 10 | strategy: 11 | matrix: 12 | include: 13 | - architecture: 'x64' 14 | compiler: 'gcc' 15 | configure_options: '--enable-wide-character-type' 16 | steps: 17 | - uses: actions/checkout@v4 18 | - name: Install build dependencies 19 | run: | 20 | sudo apt-get -y install autoconf automake autopoint build-essential git libfuse3-dev libtool pkg-config 21 | - name: Download test data 22 | run: | 23 | if test -x "synctestdata.sh"; then ./synctestdata.sh; fi 24 | - name: Prepare shared libraries 25 | run: | 26 | tests/syncsharedlibs.sh --use-head 27 | - name: Building from source 28 | env: 29 | CC: ${{ matrix.compiler }} 30 | run: | 31 | tests/build.sh ${{ matrix.configure_options }} 32 | - name: Run tests 33 | run: | 34 | tests/runtests.sh 35 | -------------------------------------------------------------------------------- /.github/workflows/build_wheel.yml: -------------------------------------------------------------------------------- 1 | # Build wheel from source using tox. 2 | name: build_wheel 3 | on: [push, pull_request] 4 | permissions: read-all 5 | jobs: 6 | build_wheel: 7 | runs-on: ubuntu-22.04 8 | strategy: 9 | matrix: 10 | include: 11 | - python-version: '3.7' 12 | toxenv: 'py37' 13 | - python-version: '3.8' 14 | toxenv: 'py38' 15 | - python-version: '3.9' 16 | toxenv: 'py39' 17 | - python-version: '3.10' 18 | toxenv: 'py310' 19 | - python-version: '3.11' 20 | toxenv: 'py311' 21 | - python-version: '3.12' 22 | toxenv: 'py312' 23 | steps: 24 | - uses: actions/checkout@v4 25 | - name: Install build dependencies 26 | run: | 27 | sudo add-apt-repository universe && 28 | sudo add-apt-repository -y ppa:deadsnakes/ppa && 29 | sudo apt-get update && 30 | sudo apt-get install -y autoconf automake autopoint build-essential git libtool pkg-config python${{ matrix.python-version }} python${{ matrix.python-version }}-dev python${{ matrix.python-version }}-venv python3-distutils python3-pip python3-setuptools 31 | - name: Install tox 32 | run: | 33 | python3 -m pip install tox 34 | - name: Download test data 35 | run: | 36 | if test -x "synctestdata.sh"; then ./synctestdata.sh; fi 37 | - name: Prepare build 38 | run: | 39 | ./synclibs.sh --use-head && ./autogen.sh && ./configure && make sources >/dev/null 40 | - name: Build Python wheel 41 | run: | 42 | tox -e${{ matrix.toxenv }} 43 | -------------------------------------------------------------------------------- /AUTHORS: -------------------------------------------------------------------------------- 1 | Acknowledgements: libvslvm 2 | 3 | Copyright (C) 2014-2024, Joachim Metz 4 | 5 | -------------------------------------------------------------------------------- /ChangeLog: -------------------------------------------------------------------------------- 1 | TODO 2 | * check signature 3 | - check the first 4 sectors 4 | - update documentation regarding PV signature 5 | * pyvslvm 6 | - complete segment object methods 7 | - complete stripe object methods 8 | - complete volume group object methods 9 | * finish: 10 | - libvslvm_internal_logical_volume_read_buffer_from_file_io_handle 11 | - make sure to set the right offset in internal_logical_volume->chunks_vector 12 | 13 | Library: 14 | * add support to specify metadata in external configuration file 15 | * implement multi physical volume files support 16 | - map pv names to file IO pool? 17 | * logical volume 18 | - expose creation_host 19 | - expose creation_time 20 | - implement multi stripe support 21 | * metadata 22 | - parse and expose global values 23 | - make sure metadata is cleaned on close - also if no data files were set! 24 | - metadata: handle trailing comment in more places? 25 | * API 26 | - allow for multiple input images (physical volumes) 27 | - allow open to read a text file with the metadata 28 | 29 | Tools: 30 | * vslvminfo 31 | - print stripes and in-volume offsets 32 | * vslvmmount 33 | - allow use of logical volume names instead of lvm#? 34 | 35 | Tests: 36 | * add tests for library 37 | * add tests for Python bindings 38 | * add tests for tools 39 | 40 | Deployment: 41 | * update manuals 42 | 43 | 20141001 44 | * see `git log' for more recent change log 45 | * removed README.macosx 46 | 47 | 20140725 48 | * worked on API 49 | 50 | 20140724 51 | * worked on API 52 | 53 | 20140723 54 | * worked on API 55 | 56 | 20140722 57 | * worked on API 58 | * moved metadata to separate code file 59 | 60 | 20140721 61 | * worked on API 62 | 63 | 20140720 64 | * worked on format support 65 | 66 | 20140201 67 | * initial version based on libvsmbr 68 | 69 | -------------------------------------------------------------------------------- /Makefile.am: -------------------------------------------------------------------------------- 1 | ACLOCAL_AMFLAGS = -I m4 2 | 3 | SUBDIRS = \ 4 | include \ 5 | common \ 6 | libcerror \ 7 | libcthreads \ 8 | libcdata \ 9 | libclocale \ 10 | libcnotify \ 11 | libcsplit \ 12 | libuna \ 13 | libcfile \ 14 | libcpath \ 15 | libbfio \ 16 | libfcache \ 17 | libfdata \ 18 | libfvalue \ 19 | libvslvm \ 20 | vslvmtools \ 21 | pyvslvm \ 22 | po \ 23 | manuals \ 24 | tests \ 25 | ossfuzz \ 26 | msvscpp 27 | 28 | DPKG_FILES = \ 29 | dpkg/changelog \ 30 | dpkg/changelog.in \ 31 | dpkg/compat \ 32 | dpkg/control \ 33 | dpkg/copyright \ 34 | dpkg/rules \ 35 | dpkg/libvslvm.install \ 36 | dpkg/libvslvm-dev.install \ 37 | dpkg/libvslvm-python3.install \ 38 | dpkg/libvslvm-tools.install \ 39 | dpkg/source/format 40 | 41 | GETTEXT_FILES = \ 42 | config.rpath \ 43 | po/Makevars.in 44 | 45 | PKGCONFIG_FILES = \ 46 | libvslvm.pc.in 47 | 48 | SETUP_PY_FILES = \ 49 | pyproject.toml \ 50 | setup.cfg \ 51 | setup.cfg.in \ 52 | setup.py 53 | 54 | SPEC_FILES = \ 55 | libvslvm.spec \ 56 | libvslvm.spec.in 57 | 58 | EXTRA_DIST = \ 59 | $(DPKG_FILES) \ 60 | $(GETTEXT_FILES) \ 61 | $(PKGCONFIG_FILES) \ 62 | $(SETUP_PY_FILES) \ 63 | $(SPEC_FILES) 64 | 65 | DISTCLEANFILES = \ 66 | config.status \ 67 | config.cache \ 68 | config.log \ 69 | libvslvm.pc \ 70 | libvslvm.spec \ 71 | Makefile \ 72 | Makefile.in \ 73 | po/Makevars 74 | 75 | pkgconfigdir = $(libdir)/pkgconfig 76 | 77 | pkgconfig_DATA = \ 78 | libvslvm.pc 79 | 80 | libtool: @LIBTOOL_DEPS@ 81 | cd $(srcdir) && $(SHELL) ./config.status --recheck 82 | 83 | lib: library 84 | 85 | library: 86 | (cd $(srcdir)/common && $(MAKE) $(AM_MAKEFLAGS)) 87 | (cd $(srcdir)/libcerror && $(MAKE) $(AM_MAKEFLAGS)) 88 | (cd $(srcdir)/libcthreads && $(MAKE) $(AM_MAKEFLAGS)) 89 | (cd $(srcdir)/libcdata && $(MAKE) $(AM_MAKEFLAGS)) 90 | (cd $(srcdir)/libclocale && $(MAKE) $(AM_MAKEFLAGS)) 91 | (cd $(srcdir)/libcnotify && $(MAKE) $(AM_MAKEFLAGS)) 92 | (cd $(srcdir)/libcsplit && $(MAKE) $(AM_MAKEFLAGS)) 93 | (cd $(srcdir)/libuna && $(MAKE) $(AM_MAKEFLAGS)) 94 | (cd $(srcdir)/libcfile && $(MAKE) $(AM_MAKEFLAGS)) 95 | (cd $(srcdir)/libcpath && $(MAKE) $(AM_MAKEFLAGS)) 96 | (cd $(srcdir)/libbfio && $(MAKE) $(AM_MAKEFLAGS)) 97 | (cd $(srcdir)/libfcache && $(MAKE) $(AM_MAKEFLAGS)) 98 | (cd $(srcdir)/libfdata && $(MAKE) $(AM_MAKEFLAGS)) 99 | (cd $(srcdir)/libfvalue && $(MAKE) $(AM_MAKEFLAGS)) 100 | (cd $(srcdir)/libvslvm && $(MAKE) $(AM_MAKEFLAGS)) 101 | (cd $(srcdir)/po && $(MAKE) $(AM_MAKEFLAGS)) 102 | 103 | -------------------------------------------------------------------------------- /NEWS: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/libyal/libvslvm/19ea14299e45d066f3eeb9c3ff2be2887b9836ed/NEWS -------------------------------------------------------------------------------- /README: -------------------------------------------------------------------------------- 1 | libvslvm is a library to access the Linux Logical Volume Manager (LVM) format. 2 | 3 | Project information: 4 | 5 | * Status: experimental 6 | * Licence: LGPLv3+ 7 | 8 | Not supported: 9 | 10 | * multiple physical volumes 11 | * multiple segments 12 | * non-linear stripes 13 | * snapshots 14 | 15 | For more information see: 16 | 17 | * Project documentation: https://github.com/libyal/libvslvm/wiki/Home 18 | * How to build from source: https://github.com/libyal/libvslvm/wiki/Building 19 | 20 | -------------------------------------------------------------------------------- /acinclude.m4: -------------------------------------------------------------------------------- 1 | dnl Checks for required headers and functions 2 | dnl 3 | dnl Version: 20200713 4 | 5 | dnl Function to detect if libvslvm dependencies are available 6 | AC_DEFUN([AX_LIBVSLVM_CHECK_LOCAL], 7 | [dnl Check for internationalization functions in libvslvm/libvslvm_i18n.c 8 | AC_CHECK_FUNCS([bindtextdomain]) 9 | ]) 10 | 11 | dnl Function to detect if vslvmtools dependencies are available 12 | AC_DEFUN([AX_VSLVMTOOLS_CHECK_LOCAL], 13 | [AC_CHECK_HEADERS([signal.h sys/signal.h unistd.h]) 14 | 15 | AC_CHECK_FUNCS([close getopt setvbuf]) 16 | 17 | AS_IF( 18 | [test "x$ac_cv_func_close" != xyes], 19 | [AC_MSG_FAILURE( 20 | [Missing function: close], 21 | [1]) 22 | ]) 23 | 24 | dnl Headers included in vslvmtools/vslvmmount.c 25 | AC_CHECK_HEADERS([errno.h sys/time.h]) 26 | 27 | dnl Functions included in vslvmtools/mount_file_system.c and vslvmtools/mount_file_entry.c 28 | AS_IF( 29 | [test "x$ac_cv_enable_winapi" = xno], 30 | [AC_CHECK_FUNCS([clock_gettime getegid geteuid time]) 31 | ]) 32 | ]) 33 | 34 | dnl Function to check if DLL support is needed 35 | AC_DEFUN([AX_LIBVSLVM_CHECK_DLL_SUPPORT], 36 | [AS_IF( 37 | [test "x$enable_shared" = xyes && test "x$ac_cv_enable_static_executables" = xno], 38 | [AS_CASE( 39 | [$host], 40 | [*cygwin* | *mingw* | *msys*], 41 | [AC_DEFINE( 42 | [HAVE_DLLMAIN], 43 | [1], 44 | [Define to 1 to enable the DllMain function.]) 45 | AC_SUBST( 46 | [HAVE_DLLMAIN], 47 | [1]) 48 | 49 | AC_SUBST( 50 | [LIBVSLVM_DLL_EXPORT], 51 | ["-DLIBVSLVM_DLL_EXPORT"]) 52 | 53 | AC_SUBST( 54 | [LIBVSLVM_DLL_IMPORT], 55 | ["-DLIBVSLVM_DLL_IMPORT"]) 56 | ]) 57 | ]) 58 | ]) 59 | 60 | -------------------------------------------------------------------------------- /builddokan.ps1: -------------------------------------------------------------------------------- 1 | # Script that builds dokan 2 | # 3 | # Version: 20180322 4 | 5 | Param ( 6 | [string]$Configuration = ${Env:Configuration}, 7 | [string]$Platform = ${Env:Platform}, 8 | [switch]$UseLegacyVersion = $false 9 | ) 10 | 11 | If (-not ${Configuration}) 12 | { 13 | $Configuration = "Release" 14 | } 15 | If (-not ${Platform}) 16 | { 17 | $Platform = "Win32" 18 | } 19 | 20 | If (${Env:AppVeyor} -eq "True") 21 | { 22 | $MSBuild = "MSBuild.exe" 23 | } 24 | ElseIf (${Env:VisualStudioVersion} -eq "15.0") 25 | { 26 | $MSBuild = "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\MSBuild\15.0\Bin\amd64\MSBuild.exe" 27 | } 28 | ElseIf (${Env:VisualStudioVersion} -eq "9.0") 29 | { 30 | $MSBuild = "C:\\Windows\Microsoft.NET\Framework\v3.5\MSBuild.exe" 31 | } 32 | Else 33 | { 34 | $MSBuild = "C:\\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe" 35 | } 36 | $MSBuildOptions = "/verbosity:quiet /target:Build /property:Configuration=${Configuration},Platform=${Platform}" 37 | 38 | If ($UseLegacyVersion) 39 | { 40 | $DokanPath = "../dokan" 41 | $ProjectFile = "msvscpp\dokan.sln" 42 | } 43 | Else 44 | { 45 | $DokanPath = "../dokany" 46 | $ProjectFile = "dokan\dokan.vcxproj" 47 | } 48 | 49 | Push-Location ${DokanPath} 50 | 51 | Try 52 | { 53 | Write-Host "${MSBuild} ${MSBuildOptions} ${ProjectFile}" 54 | 55 | Invoke-Expression -Command "& '${MSBuild}' ${MSBuildOptions} ${ProjectFile}" 56 | } 57 | Finally 58 | { 59 | Pop-Location 60 | } 61 | 62 | -------------------------------------------------------------------------------- /common/Makefile.am: -------------------------------------------------------------------------------- 1 | AM_CPPFLAGS = \ 2 | -I../include -I$(top_srcdir)/include 3 | 4 | EXTRA_DIST = \ 5 | byte_stream.h \ 6 | common.h \ 7 | config.h \ 8 | config_borlandc.h \ 9 | config_msc.h \ 10 | config_winapi.h \ 11 | file_stream.h \ 12 | memory.h \ 13 | narrow_string.h \ 14 | system_string.h \ 15 | types.h \ 16 | types.h.in \ 17 | wide_string.h 18 | 19 | DISTCLEANFILES = \ 20 | config.h \ 21 | types.h \ 22 | Makefile \ 23 | Makefile.in 24 | 25 | -------------------------------------------------------------------------------- /common/common.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Common include file 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _COMMON_H ) 23 | #define _COMMON_H 24 | 25 | #if defined( HAVE_CONFIG_H ) 26 | #include "config.h" 27 | #endif 28 | 29 | /* Include the Borland/CodeGear C++ Builder compiler specific configuration 30 | */ 31 | #if defined( __BORLANDC__ ) 32 | #include "config_borlandc.h" 33 | 34 | /* Include the Microsoft Visual Studio C++ compiler specific configuration 35 | */ 36 | #elif defined( _MSC_VER ) 37 | #include "config_msc.h" 38 | #endif 39 | 40 | #include "config_winapi.h" 41 | 42 | #endif /* !defined( _COMMON_H ) */ 43 | 44 | -------------------------------------------------------------------------------- /common/config_borlandc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Configuration for the Borland/CodeGear C++ Builder compiler 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _CONFIG_BORLANDC_H ) 23 | #define _CONFIG_BORLANDC_H 24 | 25 | #endif /* !defined( _CONFIG_BORLANDC_H ) */ 26 | 27 | -------------------------------------------------------------------------------- /common/config_msc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Configuration for the Microsoft Visual Studio C++ compiler 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _CONFIG_MSC_H ) 23 | #define _CONFIG_MSC_H 24 | 25 | /* Disable warning C4127: conditional expression is constant 26 | */ 27 | #pragma warning( disable : 4127 ) 28 | 29 | /* Disable warning C4201: nonstandard extension used : nameless struct/union 30 | */ 31 | #pragma warning( disable : 4201 ) 32 | 33 | #endif /* !defined( _CONFIG_MSC_H ) */ 34 | 35 | -------------------------------------------------------------------------------- /common/config_winapi.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Configuration file for WINAPI 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _CONFIG_WINAPI_H ) 23 | #define _CONFIG_WINAPI_H 24 | 25 | /* Define the earliest supported WINAPI version 26 | #define WINVER 0x0501 27 | */ 28 | 29 | /* If necessary make sure WINAPI is defined 30 | */ 31 | #if defined( HAVE_WINDOWS_H ) || defined( __BORLANDC__ ) || defined( _MSC_VER ) 32 | #include 33 | #endif 34 | 35 | #if defined( WINAPI ) 36 | 37 | /* Define to the address where bug reports for this package should be sent. 38 | */ 39 | #define PACKAGE_BUGREPORT "joachim.metz@gmail.com" 40 | 41 | /* Define the size of the integer for WINAPI 42 | */ 43 | #if !defined( SIZEOF_INT ) 44 | #define SIZEOF_INT 4 45 | #endif 46 | 47 | /* Define the size of size_t for WINAPI 48 | * Do not define when pyconfig.h has been included via python.h 49 | */ 50 | #if !defined( HAVE_PYCONFIG_H ) 51 | 52 | #if !defined( SIZEOF_SIZE_T ) 53 | #if __WORDSIZE == 64 54 | #define SIZEOF_SIZE_T 8 55 | #else 56 | #define SIZEOF_SIZE_T 4 57 | #endif 58 | #endif 59 | 60 | #endif /* !defined( HAVE_PYCONFIG_H ) */ 61 | 62 | /* Define the size of the wide character for WINAPI 63 | */ 64 | #if !defined( SIZEOF_WCHAR_T ) 65 | #define SIZEOF_WCHAR_T 2 66 | #endif 67 | 68 | /* Enable the DllMain function 69 | */ 70 | #define HAVE_DLLMAIN 1 71 | 72 | /* Enable verbose output 73 | #define HAVE_VERBOSE_OUTPUT 1 74 | */ 75 | 76 | /* Enable debug output 77 | #define HAVE_DEBUG_OUTPUT 1 78 | */ 79 | 80 | /* Enable both the narrow and wide character functions 81 | */ 82 | #if !defined( HAVE_WIDE_CHARACTER_TYPE ) 83 | #define HAVE_WIDE_CHARACTER_TYPE 1 84 | #endif 85 | 86 | /* If not controlled by config.h enable multi-thread support 87 | */ 88 | #if !defined( HAVE_CONFIG_H ) && !defined( HAVE_MULTI_THREAD_SUPPORT ) 89 | #define HAVE_MULTI_THREAD_SUPPORT 1 90 | #endif 91 | 92 | #endif /* defined( WINAPI ) */ 93 | 94 | #endif /* !defined( _CONFIG_WINAPI_H ) */ 95 | 96 | -------------------------------------------------------------------------------- /dpkg/changelog.in: -------------------------------------------------------------------------------- 1 | libvslvm (@VERSION@-1) unstable; urgency=low 2 | 3 | * Auto-generated 4 | 5 | -- Joachim Metz @DPKG_DATE@ 6 | -------------------------------------------------------------------------------- /dpkg/compat: -------------------------------------------------------------------------------- 1 | 10 2 | -------------------------------------------------------------------------------- /dpkg/control: -------------------------------------------------------------------------------- 1 | Source: libvslvm 2 | Priority: extra 3 | Maintainer: Joachim Metz 4 | Build-Depends: debhelper (>= 9), dh-autoreconf, dh-python, pkg-config, python3-dev, python3-setuptools, libfuse-dev 5 | Standards-Version: 4.1.4 6 | Section: libs 7 | Homepage: https://github.com/libyal/libvslvm 8 | Vcs-Git: https://github.com/libyal/libvslvm.git 9 | 10 | Package: libvslvm 11 | Architecture: any 12 | Depends: ${shlibs:Depends}, ${misc:Depends} 13 | Conflicts: libvslvm1 14 | Replaces: libvslvm1 15 | Suggests: libvslvm-dbg 16 | Description: Library to access the Linux Logical Volume Manager (LVM) volume system 17 | libvslvm is a library to access the Linux Logical Volume Manager (LVM) volume system. 18 | 19 | Package: libvslvm-dbg 20 | Architecture: any 21 | Section: debug 22 | Depends: libvslvm (= ${binary:Version}), ${misc:Depends} 23 | Description: Debugging symbols for libvslvm 24 | Debugging symbols for libvslvm. 25 | 26 | Package: libvslvm-dev 27 | Section: libdevel 28 | Architecture: any 29 | Depends: libvslvm (= ${binary:Version}), ${misc:Depends} 30 | Description: Header files and libraries for developing applications for libvslvm 31 | Header files and libraries for developing applications for libvslvm. 32 | 33 | Package: libvslvm-tools 34 | Section: utils 35 | Architecture: any 36 | Depends: libvslvm (= ${binary:Version}), ${shlibs:Depends}, ${misc:Depends} 37 | Conflicts: libvslvm-utils 38 | Replaces: libvslvm-utils 39 | Description: Several tools for Several tools for reading Linux Logical Volume Manager (LVM) volume systems 40 | Several tools for Several tools for reading Linux Logical Volume Manager (LVM) volume systems. 41 | 42 | Package: libvslvm-tools-dbg 43 | Section: debug 44 | Architecture: any 45 | Depends: libvslvm-tools (= ${binary:Version}), ${misc:Depends} 46 | Description: Debugging symbols for libvslvm-tools 47 | Debugging symbols for libvslvm-tools. 48 | 49 | Package: libvslvm-python3 50 | Section: python 51 | Architecture: any 52 | Depends: libvslvm (= ${binary:Version}), ${shlibs:Depends}, ${misc:Depends} 53 | Conflicts: python3-libvslvm 54 | Replaces: python3-libvslvm 55 | Suggests: libvslvm-python3-dbg 56 | Description: Python 3 bindings for libvslvm 57 | Python 3 bindings for libvslvm. 58 | 59 | Package: libvslvm-python3-dbg 60 | Section: debug 61 | Architecture: any 62 | Depends: libvslvm-python3 (= ${binary:Version}), ${misc:Depends} 63 | Description: Debugging symbols for libvslvm-python3 64 | Debugging symbols for libvslvm-python3. 65 | 66 | -------------------------------------------------------------------------------- /dpkg/copyright: -------------------------------------------------------------------------------- 1 | Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ 2 | Upstream-Name: libvslvm 3 | Source: https://github.com/libyal/libvslvm 4 | 5 | Files: * 6 | Copyright: 2014-2024, Joachim Metz 7 | License: LGPL-3.0+ 8 | 9 | License: LGPL-3.0+ 10 | This package is free software; you can redistribute it and/or 11 | modify it under the terms of the GNU Lesser General Public 12 | License as published by the Free Software Foundation; either 13 | version 3 of the License, or (at your option) any later version. 14 | . 15 | This package is distributed in the hope that it will be useful, 16 | but WITHOUT ANY WARRANTY; without even the implied warranty of 17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 | Lesser General Public License for more details. 19 | . 20 | You should have received a copy of the GNU General Public License 21 | along with this program. If not, see . 22 | . 23 | On Debian systems, the complete text of the GNU Lesser General 24 | Public License can be found in "/usr/share/common-licenses/LGPL-3". 25 | 26 | -------------------------------------------------------------------------------- /dpkg/libvslvm-dev.install: -------------------------------------------------------------------------------- 1 | usr/include/* 2 | usr/lib/*-*/lib*.a 3 | usr/lib/*-*/lib*.so 4 | usr/lib/*-*/pkgconfig/* 5 | usr/share/man/man3 6 | -------------------------------------------------------------------------------- /dpkg/libvslvm-python3.install: -------------------------------------------------------------------------------- 1 | /usr/lib/python3* 2 | -------------------------------------------------------------------------------- /dpkg/libvslvm-tools.install: -------------------------------------------------------------------------------- 1 | usr/bin 2 | usr/share/man/man1 3 | -------------------------------------------------------------------------------- /dpkg/libvslvm.install: -------------------------------------------------------------------------------- 1 | usr/lib/*-*/lib*.so.* 2 | -------------------------------------------------------------------------------- /dpkg/rules: -------------------------------------------------------------------------------- 1 | #!/usr/bin/make -f 2 | # -*- makefile -*- 3 | 4 | # Uncomment for debhelper verbose output. 5 | # export DH_VERBOSE=1 6 | 7 | export SKIP_PYTHON_TESTS=1 8 | 9 | %: 10 | dh $@ --buildsystem=autoconf --with=autoreconf,python3 11 | 12 | .PHONY: override_dh_auto_configure 13 | override_dh_auto_configure: 14 | dh_auto_configure -- --enable-python CFLAGS="-g" 15 | 16 | .PHONY: override_dh_install 17 | override_dh_install: 18 | dh_install --fail-missing -X.la -X/pyvslvm.a 19 | 20 | .PHONY: override_dh_missing 21 | override_dh_missing: 22 | dh_missing -X.la -X/pyvslvm.a --fail-missing 23 | 24 | .PHONY: override_dh_strip 25 | override_dh_strip: 26 | ifeq (,$(filter nostrip,$(DEB_BUILD_OPTIONS))) 27 | dh_strip -plibvslvm --dbg-package=libvslvm-dbg 28 | dh_strip -plibvslvm-tools --dbg-package=libvslvm-tools-dbg 29 | dh_strip -plibvslvm-python3 --dbg-package=libvslvm-python3-dbg 30 | endif 31 | 32 | -------------------------------------------------------------------------------- /dpkg/source/format: -------------------------------------------------------------------------------- 1 | 3.0 (quilt) 2 | -------------------------------------------------------------------------------- /include/Makefile.am: -------------------------------------------------------------------------------- 1 | include_HEADERS = \ 2 | libvslvm.h 3 | 4 | pkginclude_HEADERS = \ 5 | libvslvm/codepage.h \ 6 | libvslvm/definitions.h \ 7 | libvslvm/error.h \ 8 | libvslvm/extern.h \ 9 | libvslvm/features.h \ 10 | libvslvm/types.h 11 | 12 | EXTRA_DIST = \ 13 | libvslvm.h.in \ 14 | libvslvm/definitions.h.in \ 15 | libvslvm/features.h.in \ 16 | libvslvm/types.h.in 17 | 18 | DISTCLEANFILES = \ 19 | libvslvm.h \ 20 | libvslvm/definitions.h \ 21 | libvslvm/features.h \ 22 | libvslvm/types.h \ 23 | Makefile \ 24 | Makefile.in 25 | 26 | -------------------------------------------------------------------------------- /include/libvslvm/definitions.h.in: -------------------------------------------------------------------------------- 1 | /* 2 | * Definitions for libvslvm 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_DEFINITIONS_H ) 23 | #define _LIBVSLVM_DEFINITIONS_H 24 | 25 | #include 26 | 27 | #define LIBVSLVM_VERSION @VERSION@ 28 | 29 | /* The version string 30 | */ 31 | #define LIBVSLVM_VERSION_STRING "@VERSION@" 32 | 33 | /* The byte order definitions 34 | */ 35 | enum LIBVSLVM_ENDIAN 36 | { 37 | LIBVSLVM_ENDIAN_BIG = (int) 'b', 38 | LIBVSLVM_ENDIAN_LITTLE = (int) 'l', 39 | }; 40 | 41 | /* The access flags definitions 42 | * bit 1 set to 1 for read access 43 | * bit 2 set to 1 for write access 44 | * bit 3-8 not used 45 | */ 46 | enum LIBVSLVM_ACCESS_FLAGS 47 | { 48 | LIBVSLVM_ACCESS_FLAG_READ = 0x01, 49 | /* Reserved: not supported yet */ 50 | LIBVSLVM_ACCESS_FLAG_WRITE = 0x02 51 | }; 52 | 53 | /* The file access macros 54 | */ 55 | #define LIBVSLVM_OPEN_READ ( LIBVSLVM_ACCESS_FLAG_READ ) 56 | /* Reserved: not supported yet */ 57 | #define LIBVSLVM_OPEN_WRITE ( LIBVSLVM_ACCESS_FLAG_WRITE ) 58 | /* Reserved: not supported yet */ 59 | #define LIBVSLVM_OPEN_READ_WRITE ( LIBVSLVM_ACCESS_FLAG_READ | LIBVSLVM_ACCESS_FLAG_WRITE ) 60 | 61 | #endif /* !defined( _LIBVSLVM_DEFINITIONS_H ) */ 62 | 63 | -------------------------------------------------------------------------------- /include/libvslvm/extern.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The extern definition 3 | * 4 | * This header should be included in header files that export or import 5 | * library functions 6 | * 7 | * Copyright (C) 2014-2024, Joachim Metz 8 | * 9 | * Refer to AUTHORS for acknowledgements. 10 | * 11 | * This program is free software: you can redistribute it and/or modify 12 | * it under the terms of the GNU Lesser General Public License as published by 13 | * the Free Software Foundation, either version 3 of the License, or 14 | * (at your option) any later version. 15 | * 16 | * This program is distributed in the hope that it will be useful, 17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 | * GNU General Public License for more details. 20 | * 21 | * You should have received a copy of the GNU Lesser General Public License 22 | * along with this program. If not, see . 23 | */ 24 | 25 | #if !defined( _LIBVSLVM_EXTERN_H ) 26 | #define _LIBVSLVM_EXTERN_H 27 | 28 | /* To export functions from the libvslvm DLL define LIBVSLVM_DLL_EXPORT 29 | * To import functions from the libvslvm DLL define LIBVSLVM_DLL_IMPORT 30 | * Otherwise use default extern statement 31 | */ 32 | #if defined( LIBVSLVM_DLL_EXPORT ) 33 | #define LIBVSLVM_EXTERN __declspec(dllexport) 34 | 35 | #elif defined( LIBVSLVM_DLL_IMPORT ) 36 | #define LIBVSLVM_EXTERN extern __declspec(dllimport) 37 | 38 | #else 39 | #define LIBVSLVM_EXTERN extern 40 | 41 | #endif 42 | 43 | #endif /* !defined( _LIBVSLVM_EXTERN_H ) */ 44 | 45 | -------------------------------------------------------------------------------- /include/libvslvm/features.h.in: -------------------------------------------------------------------------------- 1 | /* 2 | * Features of libvslvm 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_FEATURES_H ) 23 | #define _LIBVSLVM_FEATURES_H 24 | 25 | /* The libvslvm type support features 26 | */ 27 | #if defined( WINAPI ) || @HAVE_WIDE_CHARACTER_TYPE@ 28 | #define LIBVSLVM_HAVE_WIDE_CHARACTER_TYPE 1 29 | #endif 30 | 31 | #if defined( WINAPI ) || @HAVE_MULTI_THREAD_SUPPORT@ 32 | #define LIBVSLVM_HAVE_MULTI_THREAD_SUPPORT 1 33 | #endif 34 | 35 | #if defined( HAVE_LIBBFIO ) || ( !defined( WINAPI ) && @HAVE_LIBBFIO@ ) 36 | #define LIBVSLVM_HAVE_BFIO 1 37 | #endif 38 | 39 | #if !defined( LIBVSLVM_DEPRECATED ) 40 | #if defined( __GNUC__ ) && __GNUC__ >= 3 41 | #define LIBVSLVM_DEPRECATED __attribute__ ((__deprecated__)) 42 | #elif defined( _MSC_VER ) 43 | #define LIBVSLVM_DEPRECATED __declspec(deprecated) 44 | #else 45 | #define LIBVSLVM_DEPRECATED 46 | #endif 47 | #endif 48 | 49 | #endif /* !defined( _LIBVSLVM_FEATURES_H ) */ 50 | 51 | -------------------------------------------------------------------------------- /libvslvm.ini: -------------------------------------------------------------------------------- 1 | [project] 2 | name: "libvslvm" 3 | status: "experimental" 4 | year_of_creation: "2014" 5 | data_format: "Linux Logical Volume Manager (LVM)" 6 | documentation_url: "https://github.com/libyal/libvslvm/tree/main/documentation" 7 | features: ["debug_output", "nuget", "ossfuzz", "python_bindings", "tools"] 8 | 9 | [library] 10 | description: "Library to access the Linux Logical Volume Manager (LVM) volume system" 11 | features: ["pthread", "wide_character_type"] 12 | public_types: ["handle", "logical_volume", "physical_volume", "segment", "stripe", "volume_group"] 13 | 14 | [tools] 15 | build_dependencies: ["fuse"] 16 | description: "Several tools for Several tools for reading Linux Logical Volume Manager (LVM) volume systems" 17 | names: ["vslvminfo", "vslvmmount"] 18 | 19 | [info_tool] 20 | source_description: "a Linux Logical Volume Manager (LVM) volume system" 21 | source_type: "volume" 22 | 23 | [mount_tool] 24 | features: ["offset"] 25 | base_type: "handle" 26 | file_entry_type: "logical_volume" 27 | mounted_description: "a device file that provides the volumes contained in the LVM volume system" 28 | path_prefix: "lvm" 29 | source: "image.raw" 30 | source_description: "a LVM volume system" 31 | source_description_long: "a Linux Logical Volume Manager (LVM) volume system" 32 | source_type: "volume" 33 | 34 | [troubleshooting] 35 | example: "vslvminfo image.raw" 36 | 37 | [tests] 38 | profiles: ["libvslvm", "pyvslvm", "vslvminfo"] 39 | info_tool_options_per_profile: [""] 40 | info_tool_profiles: ["vslvminfo"] 41 | example_filename1: "image1.raw" 42 | example_filename2: "image2.raw" 43 | 44 | [pypi] 45 | appveyor_token: "VHuZiUWgTqTciKE2nsv/LqFdmVVk6C2d+44DWgBbH6mwos3UemqJt6quwYzUMTIe33qZH7049nu4/FqqrpOIgqNpt0cq8q0lC/VCJyYbU30PM5+bDxJRZfUZove2N5B3phgMYl9F6esdR2TnK+J6sgA7Ifj2/oHTaHxRLleFEzXvscn3x9C3l5pSAmNDFISz8w9f8g1Q6yvbg2e+Pa8jsqDvDgLQdvtaGcrzzuP0fcm28o8Ly756aOn5TelN39w74DlBAgVbdjXlzQAG1b212aLNlW+XN4FGnm1Vl0mXKEU=" 46 | 47 | -------------------------------------------------------------------------------- /libvslvm.nuspec: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | libvslvm 5 | 20240812 6 | Joachim Metz 7 | joachimmetz 8 | LGPL-3.0-or-later 9 | https://github.com/libyal/libvslvm 10 | false 11 | libvslvm 12 | Library to access the Linux Logical Volume Manager (LVM) volume system 13 | Release of libvslvm 20240812 14 | Copyright (C) 2014-2024 15 | native 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | -------------------------------------------------------------------------------- /libvslvm.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@prefix@ 2 | exec_prefix=@exec_prefix@ 3 | libdir=@libdir@ 4 | includedir=@includedir@ 5 | 6 | Name: libvslvm 7 | Description: Library to access the Linux Logical Volume Manager (LVM) volume system 8 | Version: @VERSION@ 9 | Libs: -L${libdir} -lvslvm 10 | Libs.private: @ax_libbfio_pc_libs_private@ @ax_libcdata_pc_libs_private@ @ax_libcerror_pc_libs_private@ @ax_libcfile_pc_libs_private@ @ax_libclocale_pc_libs_private@ @ax_libcnotify_pc_libs_private@ @ax_libcpath_pc_libs_private@ @ax_libcsplit_pc_libs_private@ @ax_libcthreads_pc_libs_private@ @ax_libfcache_pc_libs_private@ @ax_libfdata_pc_libs_private@ @ax_libfvalue_pc_libs_private@ @ax_libuna_pc_libs_private@ @ax_pthread_pc_libs_private@ 11 | Cflags: -I${includedir} 12 | 13 | -------------------------------------------------------------------------------- /libvslvm/Makefile.am: -------------------------------------------------------------------------------- 1 | AM_CPPFLAGS = \ 2 | -I../include -I$(top_srcdir)/include \ 3 | -I../common -I$(top_srcdir)/common \ 4 | @LIBCERROR_CPPFLAGS@ \ 5 | @LIBCTHREADS_CPPFLAGS@ \ 6 | @LIBCDATA_CPPFLAGS@ \ 7 | @LIBCLOCALE_CPPFLAGS@ \ 8 | @LIBCNOTIFY_CPPFLAGS@ \ 9 | @LIBCSPLIT_CPPFLAGS@ \ 10 | @LIBUNA_CPPFLAGS@ \ 11 | @LIBCFILE_CPPFLAGS@ \ 12 | @LIBCPATH_CPPFLAGS@ \ 13 | @LIBBFIO_CPPFLAGS@ \ 14 | @LIBFCACHE_CPPFLAGS@ \ 15 | @LIBFDATA_CPPFLAGS@ \ 16 | @LIBFVALUE_CPPFLAGS@ \ 17 | @PTHREAD_CPPFLAGS@ \ 18 | @LIBVSLVM_DLL_EXPORT@ 19 | 20 | lib_LTLIBRARIES = libvslvm.la 21 | 22 | libvslvm_la_SOURCES = \ 23 | libvslvm.c \ 24 | libvslvm_checksum.c libvslvm_checksum.h \ 25 | libvslvm_chunk_data.c libvslvm_chunk_data.h \ 26 | libvslvm_data_area_descriptor.c libvslvm_data_area_descriptor.h \ 27 | libvslvm_debug.c libvslvm_debug.h \ 28 | libvslvm_definitions.h \ 29 | libvslvm_error.c libvslvm_error.h \ 30 | libvslvm_extern.h \ 31 | libvslvm_handle.c libvslvm_handle.h \ 32 | libvslvm_io_handle.c libvslvm_io_handle.h \ 33 | libvslvm_libbfio.h \ 34 | libvslvm_libcdata.h \ 35 | libvslvm_libcerror.h \ 36 | libvslvm_libclocale.h \ 37 | libvslvm_libcnotify.h \ 38 | libvslvm_libcsplit.h \ 39 | libvslvm_libcthreads.h \ 40 | libvslvm_libfcache.h \ 41 | libvslvm_libfdata.h \ 42 | libvslvm_libfvalue.h \ 43 | libvslvm_logical_volume.c libvslvm_logical_volume.h \ 44 | libvslvm_logical_volume_values.c libvslvm_logical_volume_values.h \ 45 | libvslvm_metadata.c libvslvm_metadata.h \ 46 | libvslvm_metadata_area.c libvslvm_metadata_area.h \ 47 | libvslvm_notify.c libvslvm_notify.h \ 48 | libvslvm_physical_volume.c libvslvm_physical_volume.h \ 49 | libvslvm_raw_location_descriptor.c libvslvm_raw_location_descriptor.h \ 50 | libvslvm_segment.c libvslvm_segment.h \ 51 | libvslvm_stripe.c libvslvm_stripe.h \ 52 | libvslvm_support.c libvslvm_support.h \ 53 | libvslvm_types.h \ 54 | libvslvm_unused.h \ 55 | libvslvm_volume_group.c libvslvm_volume_group.h \ 56 | vslvm_metadata_area.h \ 57 | vslvm_physical_volume_label.h 58 | 59 | libvslvm_la_LIBADD = \ 60 | @LIBCERROR_LIBADD@ \ 61 | @LIBCTHREADS_LIBADD@ \ 62 | @LIBCDATA_LIBADD@ \ 63 | @LIBCLOCALE_LIBADD@ \ 64 | @LIBCNOTIFY_LIBADD@ \ 65 | @LIBCSPLIT_LIBADD@ \ 66 | @LIBUNA_LIBADD@ \ 67 | @LIBCFILE_LIBADD@ \ 68 | @LIBCPATH_LIBADD@ \ 69 | @LIBBFIO_LIBADD@ \ 70 | @LIBFCACHE_LIBADD@ \ 71 | @LIBFDATA_LIBADD@ \ 72 | @LIBFVALUE_LIBADD@ \ 73 | @PTHREAD_LIBADD@ 74 | 75 | libvslvm_la_LDFLAGS = -no-undefined -version-info 1:0:0 76 | 77 | EXTRA_DIST = \ 78 | libvslvm_definitions.h.in \ 79 | libvslvm.rc \ 80 | libvslvm.rc.in 81 | 82 | DISTCLEANFILES = \ 83 | libvslvm_definitions.h \ 84 | libvslvm.rc \ 85 | Makefile \ 86 | Makefile.in 87 | 88 | sources-local: $(BUILT_SOURCES) 89 | 90 | splint-local: 91 | @echo "Running splint on libvslvm ..." 92 | -splint -preproc -redef $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(libvslvm_la_SOURCES) 93 | 94 | -------------------------------------------------------------------------------- /libvslvm/libvslvm.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Library to access the Linux Logical Volume Manager (LVM) volume system 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #include 23 | 24 | #if defined( WINAPI ) 25 | #include 26 | #endif 27 | 28 | #include "libvslvm_unused.h" 29 | 30 | /* Define HAVE_LOCAL_LIBVSLVM for local use of libvslvm 31 | */ 32 | #if !defined( HAVE_LOCAL_LIBVSLVM ) 33 | 34 | #if defined( WINAPI ) && defined( HAVE_DLLMAIN ) 35 | 36 | #if defined( _MANAGED ) 37 | #pragma managed( push, off ) 38 | #endif 39 | 40 | /* Defines the entry point for the DLL 41 | */ 42 | BOOL WINAPI DllMain( 43 | HINSTANCE hinstDLL, 44 | DWORD fdwReason, 45 | LPVOID lpvReserved ) 46 | { 47 | LIBVSLVM_UNREFERENCED_PARAMETER( lpvReserved ) 48 | 49 | switch( fdwReason ) 50 | { 51 | case DLL_PROCESS_ATTACH: 52 | DisableThreadLibraryCalls( 53 | hinstDLL ); 54 | break; 55 | 56 | case DLL_THREAD_ATTACH: 57 | break; 58 | 59 | case DLL_THREAD_DETACH: 60 | break; 61 | 62 | case DLL_PROCESS_DETACH: 63 | break; 64 | } 65 | return( TRUE ); 66 | } 67 | 68 | /* Function that indicates the library is a DLL 69 | * Returns 1 70 | */ 71 | int libvslvm_is_dll( 72 | void ) 73 | { 74 | return( 1 ); 75 | } 76 | 77 | #endif /* defined( WINAPI ) && defined( HAVE_DLLMAIN ) */ 78 | 79 | #endif /* !defined( HAVE_LOCAL_LIBVSLVM ) */ 80 | 81 | -------------------------------------------------------------------------------- /libvslvm/libvslvm.rc.in: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #ifdef GCC_WINDRES 4 | VS_VERSION_INFO VERSIONINFO 5 | #else 6 | VS_VERSION_INFO VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE 7 | #endif 8 | FILEVERSION 1,0,0,0 9 | PRODUCTVERSION 1,0,0,0 10 | FILEFLAGSMASK VS_FFI_FILEFLAGSMASK 11 | #ifdef _DEBUG 12 | FILEFLAGS 0x1L 13 | #else 14 | FILEFLAGS 0x0L 15 | #endif 16 | FILEOS VOS__WINDOWS32 17 | FILETYPE VFT_DLL 18 | FILESUBTYPE 0x0L 19 | BEGIN 20 | BLOCK "StringFileInfo" 21 | BEGIN 22 | BLOCK "040904E4" 23 | BEGIN 24 | VALUE "FileDescription", "Library to access the Linux Logical Volume Manager (LVM) volume system\0" 25 | VALUE "FileVersion", "@VERSION@" "\0" 26 | VALUE "InternalName", "libvslvm.dll\0" 27 | VALUE "LegalCopyright", "(C) 2014-2024, Joachim Metz \0" 28 | VALUE "OriginalFilename", "libvslvm.dll\0" 29 | VALUE "ProductName", "libvslvm\0" 30 | VALUE "ProductVersion", "@VERSION@" "\0" 31 | VALUE "Comments", "For more information visit https://github.com/libyal/libvslvm/\0" 32 | END 33 | END 34 | BLOCK "VarFileInfo" 35 | BEGIN 36 | VALUE "Translation", 0x0409, 1200 37 | END 38 | END 39 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_checksum.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Checksum functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_CHECKSUM_H ) 23 | #define _LIBVSLVM_CHECKSUM_H 24 | 25 | #include 26 | #include 27 | 28 | #include "libvslvm_extern.h" 29 | #include "libvslvm_libcerror.h" 30 | 31 | #if defined( __cplusplus ) 32 | extern "C" { 33 | #endif 34 | 35 | LIBVSLVM_EXTERN_VARIABLE \ 36 | uint32_t libvslvm_checksum_crc32_table[ 256 ]; 37 | 38 | LIBVSLVM_EXTERN_VARIABLE \ 39 | int libvslvm_checksum_crc32_table_computed; 40 | 41 | void libvslvm_checksum_initialize_crc32_table( 42 | int ); 43 | 44 | int libvslvm_checksum_calculate_crc32( 45 | uint32_t *checksum, 46 | const uint8_t *buffer, 47 | size_t size, 48 | uint32_t initial_value, 49 | libcerror_error_t **error ); 50 | 51 | int libvslvm_checksum_calculate_weak_crc32( 52 | uint32_t *checksum, 53 | const uint8_t *buffer, 54 | size_t size, 55 | uint32_t initial_value, 56 | libcerror_error_t **error ); 57 | 58 | #if defined( __cplusplus ) 59 | } 60 | #endif 61 | 62 | #endif /* !defined( _LIBVSLVM_CHECKSUM_H ) */ 63 | 64 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_chunk_data.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Chunk data functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_CHUNK_DATA_H ) 23 | #define _LIBVSLVM_CHUNK_DATA_H 24 | 25 | #include 26 | #include 27 | 28 | #include "libvslvm_libbfio.h" 29 | #include "libvslvm_libcerror.h" 30 | 31 | #if defined( __cplusplus ) 32 | extern "C" { 33 | #endif 34 | 35 | typedef struct libvslvm_chunk_data libvslvm_chunk_data_t; 36 | 37 | struct libvslvm_chunk_data 38 | { 39 | /* The data 40 | */ 41 | uint8_t *data; 42 | 43 | /* The data size 44 | */ 45 | size_t data_size; 46 | }; 47 | 48 | int libvslvm_chunk_data_initialize( 49 | libvslvm_chunk_data_t **chunk_data, 50 | size_t data_size, 51 | libcerror_error_t **error ); 52 | 53 | int libvslvm_chunk_data_free( 54 | libvslvm_chunk_data_t **chunk_data, 55 | libcerror_error_t **error ); 56 | 57 | int libvslvm_chunk_data_read_file_io_pool( 58 | libvslvm_chunk_data_t *chunk_data, 59 | libbfio_pool_t *file_io_pool, 60 | int file_io_pool_entry, 61 | off64_t cluster_offset, 62 | libcerror_error_t **error ); 63 | 64 | #if defined( __cplusplus ) 65 | } 66 | #endif 67 | 68 | #endif /* !defined( _LIBVSLVM_CHUNK_DATA_H ) */ 69 | 70 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_data_area_descriptor.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Data area descriptor functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_DATA_AREA_DESCRIPTOR_H ) 23 | #define _LIBVSLVM_DATA_AREA_DESCRIPTOR_H 24 | 25 | #include 26 | #include 27 | 28 | #include "libvslvm_libcerror.h" 29 | 30 | #if defined( __cplusplus ) 31 | extern "C" { 32 | #endif 33 | 34 | typedef struct libvslvm_data_area_descriptor libvslvm_data_area_descriptor_t; 35 | 36 | struct libvslvm_data_area_descriptor 37 | { 38 | /* The offset 39 | */ 40 | uint64_t offset; 41 | 42 | /* The size 43 | */ 44 | uint64_t size; 45 | }; 46 | 47 | int libvslvm_data_area_descriptor_initialize( 48 | libvslvm_data_area_descriptor_t **data_area_descriptor, 49 | libcerror_error_t **error ); 50 | 51 | int libvslvm_data_area_descriptor_free( 52 | libvslvm_data_area_descriptor_t **data_area_descriptor, 53 | libcerror_error_t **error ); 54 | 55 | int libvslvm_data_area_descriptor_get( 56 | libvslvm_data_area_descriptor_t *data_area_descriptor, 57 | off64_t *offset, 58 | size64_t *size, 59 | libcerror_error_t **error ); 60 | 61 | int libvslvm_data_area_descriptor_set( 62 | libvslvm_data_area_descriptor_t *data_area_descriptor, 63 | off64_t offset, 64 | size64_t size, 65 | libcerror_error_t **error ); 66 | 67 | #if defined( __cplusplus ) 68 | } 69 | #endif 70 | 71 | #endif /* !defined( _LIBVSLVM_DATA_AREA_DESCRIPTOR_H ) */ 72 | 73 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_debug.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Debug functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #include 23 | #include 24 | 25 | #include "libvslvm_debug.h" 26 | #include "libvslvm_libbfio.h" 27 | #include "libvslvm_libcerror.h" 28 | #include "libvslvm_libcnotify.h" 29 | 30 | #if defined( HAVE_DEBUG_OUTPUT ) 31 | 32 | /* Prints the read offsets 33 | * Returns 1 if successful or -1 on error 34 | */ 35 | int libvslvm_debug_print_read_offsets( 36 | libbfio_handle_t *file_io_handle, 37 | libcerror_error_t **error ) 38 | { 39 | static char *function = "libvslvm_debug_print_read_offsets"; 40 | off64_t offset = 0; 41 | size64_t size = 0; 42 | int number_of_offsets = 0; 43 | int offset_iterator = 0; 44 | 45 | if( file_io_handle == NULL ) 46 | { 47 | libcerror_error_set( 48 | error, 49 | LIBCERROR_ERROR_DOMAIN_ARGUMENTS, 50 | LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, 51 | "%s: invalid file IO handle.", 52 | function ); 53 | 54 | return( -1 ); 55 | } 56 | if( libbfio_handle_get_number_of_offsets_read( 57 | file_io_handle, 58 | &number_of_offsets, 59 | error ) != 1 ) 60 | { 61 | libcerror_error_set( 62 | error, 63 | LIBCERROR_ERROR_DOMAIN_RUNTIME, 64 | LIBCERROR_RUNTIME_ERROR_GET_FAILED, 65 | "%s: unable to retrieve number of offsets read.", 66 | function ); 67 | 68 | return( -1 ); 69 | } 70 | libcnotify_printf( 71 | "Offsets read:\n" ); 72 | 73 | for( offset_iterator = 0; 74 | offset_iterator < number_of_offsets; 75 | offset_iterator++ ) 76 | { 77 | if( libbfio_handle_get_offset_read( 78 | file_io_handle, 79 | offset_iterator, 80 | &offset, 81 | &size, 82 | error ) != 1 ) 83 | { 84 | libcerror_error_set( 85 | error, 86 | LIBCERROR_ERROR_DOMAIN_RUNTIME, 87 | LIBCERROR_RUNTIME_ERROR_GET_FAILED, 88 | "%s: unable to retrieve offset: %d.", 89 | function, 90 | offset_iterator ); 91 | 92 | return( -1 ); 93 | } 94 | libcnotify_printf( 95 | "%08" PRIi64 " ( 0x%08" PRIx64 " ) - %08" PRIi64 " ( 0x%08" PRIx64 " ) size: %" PRIi64 "\n", 96 | offset, 97 | offset, 98 | offset + (off64_t) size, 99 | offset + (off64_t) size, 100 | size ); 101 | } 102 | libcnotify_printf( 103 | "\n" ); 104 | 105 | return( 1 ); 106 | } 107 | 108 | #endif 109 | 110 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_debug.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Debug functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_DEBUG_H ) 23 | #define _LIBVSLVM_DEBUG_H 24 | 25 | #include 26 | #include 27 | 28 | #include "libvslvm_libbfio.h" 29 | #include "libvslvm_libcerror.h" 30 | 31 | #if defined( __cplusplus ) 32 | extern "C" { 33 | #endif 34 | 35 | #if defined( HAVE_DEBUG_OUTPUT ) 36 | 37 | int libvslvm_debug_print_read_offsets( 38 | libbfio_handle_t *file_io_handle, 39 | libcerror_error_t **error ); 40 | 41 | #endif 42 | 43 | #if defined( __cplusplus ) 44 | } 45 | #endif 46 | 47 | #endif /* !defined( _LIBVSLVM_DEBUG_H ) */ 48 | 49 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_definitions.h.in: -------------------------------------------------------------------------------- 1 | /* 2 | * The internal definitions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_INTERNAL_DEFINITIONS_H ) 23 | #define _LIBVSLVM_INTERNAL_DEFINITIONS_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBVSLVM for local use of libvslvm 28 | */ 29 | #if !defined( HAVE_LOCAL_LIBVSLVM ) 30 | #include 31 | 32 | /* The definitions in are copied here 33 | * for local use of libvslvm 34 | */ 35 | #else 36 | #define LIBVSLVM_VERSION @VERSION@ 37 | 38 | /* The libvslvm version string 39 | */ 40 | #define LIBVSLVM_VERSION_STRING "@VERSION@" 41 | 42 | /* The endian definitions 43 | */ 44 | #define LIBVSLVM_ENDIAN_BIG _BYTE_STREAM_ENDIAN_BIG 45 | #define LIBVSLVM_ENDIAN_LITTLE _BYTE_STREAM_ENDIAN_LITTLE 46 | 47 | /* The access flags definitions 48 | * bit 1 set to 1 for read access 49 | * bit 2 set to 1 for write access 50 | * bit 3-8 not used 51 | */ 52 | enum LIBVSLVM_ACCESS_FLAGS 53 | { 54 | LIBVSLVM_ACCESS_FLAG_READ = 0x01, 55 | /* Reserved: not supported yet */ 56 | LIBVSLVM_ACCESS_FLAG_WRITE = 0x02 57 | }; 58 | 59 | /* The file access macros 60 | */ 61 | #define LIBVSLVM_OPEN_READ ( LIBVSLVM_ACCESS_FLAG_READ ) 62 | /* Reserved: not supported yet */ 63 | #define LIBVSLVM_OPEN_WRITE ( LIBVSLVM_ACCESS_FLAG_WRITE ) 64 | /* Reserved: not supported yet */ 65 | #define LIBVSLVM_OPEN_READ_WRITE ( LIBVSLVM_ACCESS_FLAG_READ | LIBVSLVM_ACCESS_FLAG_WRITE ) 66 | 67 | #endif /* !defined( HAVE_LOCAL_LIBVSLVM ) */ 68 | 69 | /* The raw location descriptor flags 70 | */ 71 | enum LIBVSLVM_RAW_LOCATION_DESCRIPTOR_FLAGS 72 | { 73 | LIBVSLVM_RAW_LOCATION_DESCRIPTOR_FLAG_IGNORE = 0x00000001UL 74 | }; 75 | 76 | #define LIBVSLVM_MAXIMUM_CACHE_ENTRIES_PHYSICAL_VOLUMES 4 77 | #define LIBVSLVM_MAXIMUM_CACHE_ENTRIES_CHUNKS 16 78 | 79 | #endif /* !defined( _LIBVSLVM_INTERNAL_DEFINITIONS_H ) */ 80 | 81 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_error.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Error functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_INTERNAL_ERROR_H ) 23 | #define _LIBVSLVM_INTERNAL_ERROR_H 24 | 25 | #include 26 | #include 27 | #include 28 | 29 | #if !defined( HAVE_LOCAL_LIBVSLVM ) 30 | #include 31 | #endif 32 | 33 | #include "libvslvm_extern.h" 34 | 35 | #if defined( __cplusplus ) 36 | extern "C" { 37 | #endif 38 | 39 | #if !defined( HAVE_LOCAL_LIBVSLVM ) 40 | 41 | LIBVSLVM_EXTERN \ 42 | void libvslvm_error_free( 43 | libvslvm_error_t **error ); 44 | 45 | LIBVSLVM_EXTERN \ 46 | int libvslvm_error_fprint( 47 | libvslvm_error_t *error, 48 | FILE *stream ); 49 | 50 | LIBVSLVM_EXTERN \ 51 | int libvslvm_error_sprint( 52 | libvslvm_error_t *error, 53 | char *string, 54 | size_t size ); 55 | 56 | LIBVSLVM_EXTERN \ 57 | int libvslvm_error_backtrace_fprint( 58 | libvslvm_error_t *error, 59 | FILE *stream ); 60 | 61 | LIBVSLVM_EXTERN \ 62 | int libvslvm_error_backtrace_sprint( 63 | libvslvm_error_t *error, 64 | char *string, 65 | size_t size ); 66 | 67 | #endif /* !defined( HAVE_LOCAL_LIBVSLVM ) */ 68 | 69 | #if defined( __cplusplus ) 70 | } 71 | #endif 72 | 73 | #endif /* !defined( _LIBVSLVM_INTERNAL_ERROR_H ) */ 74 | 75 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_extern.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The internal extern definition 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_INTERNAL_EXTERN_H ) 23 | #define _LIBVSLVM_INTERNAL_EXTERN_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBVSLVM for local use of libvslvm 28 | */ 29 | #if !defined( HAVE_LOCAL_LIBVSLVM ) 30 | 31 | #include 32 | 33 | #if defined( __CYGWIN__ ) || defined( __MINGW32__ ) 34 | #define LIBVSLVM_EXTERN_VARIABLE extern 35 | #else 36 | #define LIBVSLVM_EXTERN_VARIABLE LIBVSLVM_EXTERN 37 | #endif 38 | 39 | #else 40 | #define LIBVSLVM_EXTERN /* extern */ 41 | #define LIBVSLVM_EXTERN_VARIABLE extern 42 | 43 | #endif /* !defined( HAVE_LOCAL_LIBVSLVM ) */ 44 | 45 | #endif /* !defined( _LIBVSLVM_INTERNAL_EXTERN_H ) */ 46 | 47 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_io_handle.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The IO handle functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_IO_HANDLE_H ) 23 | #define _LIBVSLVM_IO_HANDLE_H 24 | 25 | #include 26 | #include 27 | 28 | #include "libvslvm_libcerror.h" 29 | 30 | #if defined( __cplusplus ) 31 | extern "C" { 32 | #endif 33 | 34 | typedef struct libvslvm_io_handle libvslvm_io_handle_t; 35 | 36 | struct libvslvm_io_handle 37 | { 38 | /* The number of bytes per sector 39 | */ 40 | size_t bytes_per_sector; 41 | 42 | /* Value to indicate if abort was signalled 43 | */ 44 | int abort; 45 | }; 46 | 47 | int libvslvm_io_handle_initialize( 48 | libvslvm_io_handle_t **io_handle, 49 | libcerror_error_t **error ); 50 | 51 | int libvslvm_io_handle_free( 52 | libvslvm_io_handle_t **io_handle, 53 | libcerror_error_t **error ); 54 | 55 | int libvslvm_io_handle_clear( 56 | libvslvm_io_handle_t *io_handle, 57 | libcerror_error_t **error ); 58 | 59 | #if defined( __cplusplus ) 60 | } 61 | #endif 62 | 63 | #endif /* !defined( _LIBVSLVM_IO_HANDLE_H ) */ 64 | 65 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_libbfio.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libbfio header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_LIBBFIO_H ) 23 | #define _LIBVSLVM_LIBBFIO_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBBFIO for local use of libbfio 28 | */ 29 | #if defined( HAVE_LOCAL_LIBBFIO ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | 40 | #else 41 | 42 | /* If libtool DLL support is enabled set LIBBFIO_DLL_IMPORT 43 | * before including libbfio.h 44 | */ 45 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 46 | #define LIBBFIO_DLL_IMPORT 47 | #endif 48 | 49 | #include 50 | 51 | #if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( LIBBFIO_HAVE_MULTI_THREAD_SUPPORT ) 52 | #error Multi-threading support requires libbfio with multi-threading support 53 | #endif 54 | 55 | #endif /* defined( HAVE_LOCAL_LIBBFIO ) */ 56 | 57 | #endif /* !defined( _LIBVSLVM_LIBBFIO_H ) */ 58 | 59 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_libcdata.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libcdata header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_LIBCDATA_H ) 23 | #define _LIBVSLVM_LIBCDATA_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCDATA for local use of libcdata 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCDATA ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | 40 | #else 41 | 42 | /* If libtool DLL support is enabled set LIBCDATA_DLL_IMPORT 43 | * before including libcdata.h 44 | */ 45 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 46 | #define LIBCDATA_DLL_IMPORT 47 | #endif 48 | 49 | #include 50 | 51 | #endif /* defined( HAVE_LOCAL_LIBCDATA ) */ 52 | 53 | #endif /* !defined( _LIBVSLVM_LIBCDATA_H ) */ 54 | 55 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_libcerror.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libcerror header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_LIBCERROR_H ) 23 | #define _LIBVSLVM_LIBCERROR_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCERROR for local use of libcerror 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCERROR ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | 36 | #else 37 | 38 | /* If libtool DLL support is enabled set LIBCERROR_DLL_IMPORT 39 | * before including libcerror.h 40 | */ 41 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 42 | #define LIBCERROR_DLL_IMPORT 43 | #endif 44 | 45 | #include 46 | 47 | #endif /* defined( HAVE_LOCAL_LIBCERROR ) */ 48 | 49 | #endif /* !defined( _LIBVSLVM_LIBCERROR_H ) */ 50 | 51 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_libclocale.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libclocale header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_LIBCLOCALE_H ) 23 | #define _LIBVSLVM_LIBCLOCALE_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCLOCALE for local use of libclocale 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCLOCALE ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | 36 | #else 37 | 38 | /* If libtool DLL support is enabled set LIBCLOCALE_DLL_IMPORT 39 | * before including libclocale.h 40 | */ 41 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 42 | #define LIBCLOCALE_DLL_IMPORT 43 | #endif 44 | 45 | #include 46 | 47 | #endif /* defined( HAVE_LOCAL_LIBCLOCALE ) */ 48 | 49 | #endif /* !defined( _LIBVSLVM_LIBCLOCALE_H ) */ 50 | 51 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_libcnotify.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libcnotify header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_LIBCNOTIFY_H ) 23 | #define _LIBVSLVM_LIBCNOTIFY_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCNOTIFY for local use of libcnotify 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCNOTIFY ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | 36 | #else 37 | 38 | /* If libtool DLL support is enabled set LIBCNOTIFY_DLL_IMPORT 39 | * before including libcnotify.h 40 | */ 41 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 42 | #define LIBCNOTIFY_DLL_IMPORT 43 | #endif 44 | 45 | #include 46 | 47 | #endif /* defined( HAVE_LOCAL_LIBCNOTIFY ) */ 48 | 49 | #endif /* !defined( _LIBVSLVM_LIBCNOTIFY_H ) */ 50 | 51 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_libcsplit.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The internal libcsplit header 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_LIBCSPLIT_H ) 23 | #define _LIBVSLVM_LIBCSPLIT_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCSPLIT for local use of libcsplit 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCSPLIT ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | 38 | #else 39 | 40 | /* If libtool DLL support is enabled set LIBCSPLIT_DLL_IMPORT 41 | * before including libcsplit.h 42 | */ 43 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 44 | #define LIBCSPLIT_DLL_IMPORT 45 | #endif 46 | 47 | #include 48 | 49 | #endif 50 | 51 | #endif 52 | 53 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_libcthreads.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libcthreads header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_LIBCTHREADS_H ) 23 | #define _LIBVSLVM_LIBCTHREADS_H 24 | 25 | #include 26 | 27 | #if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBVSLVM ) 28 | #define HAVE_LIBVSLVM_MULTI_THREAD_SUPPORT 29 | #endif 30 | 31 | #if defined( HAVE_LIBVSLVM_MULTI_THREAD_SUPPORT ) 32 | 33 | /* Define HAVE_LOCAL_LIBCTHREADS for local use of libcthreads 34 | */ 35 | #if defined( HAVE_LOCAL_LIBCTHREADS ) 36 | 37 | #include 38 | #include 39 | #include 40 | #include 41 | #include 42 | #include 43 | #include 44 | #include 45 | #include 46 | #include 47 | 48 | #else 49 | 50 | /* If libtool DLL support is enabled set LIBCTHREADS_DLL_IMPORT 51 | * before including libcthreads.h 52 | */ 53 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 54 | #define LIBCTHREADS_DLL_IMPORT 55 | #endif 56 | 57 | #include 58 | 59 | #endif /* defined( HAVE_LOCAL_LIBCTHREADS ) */ 60 | 61 | #endif /* defined( HAVE_LIBVSLVM_MULTI_THREAD_SUPPORT ) */ 62 | 63 | #endif /* !defined( _LIBVSLVM_LIBCTHREADS_H ) */ 64 | 65 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_libfcache.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libfcache header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_LIBFCACHE_H ) 23 | #define _LIBVSLVM_LIBFCACHE_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBFCACHE for local use of libfcache 28 | */ 29 | #if defined( HAVE_LOCAL_LIBFCACHE ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | 36 | #else 37 | 38 | /* If libtool DLL support is enabled set LIBFCACHE_DLL_IMPORT 39 | * before including libfcache.h 40 | */ 41 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 42 | #define LIBFCACHE_DLL_IMPORT 43 | #endif 44 | 45 | #include 46 | 47 | #endif /* defined( HAVE_LOCAL_LIBFCACHE ) */ 48 | 49 | #endif /* !defined( _LIBVSLVM_LIBFCACHE_H ) */ 50 | 51 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_libfdata.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libfdata header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_LIBFDATA_H ) 23 | #define _LIBVSLVM_LIBFDATA_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBFDATA for local use of libfdata 28 | */ 29 | #if defined( HAVE_LOCAL_LIBFDATA ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | 40 | #else 41 | 42 | /* If libtool DLL support is enabled set LIBFDATA_DLL_IMPORT 43 | * before including libfdata.h 44 | */ 45 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 46 | #define LIBFDATA_DLL_IMPORT 47 | #endif 48 | 49 | #include 50 | 51 | #endif /* defined( HAVE_LOCAL_LIBFDATA ) */ 52 | 53 | #endif /* !defined( _LIBVSLVM_LIBFDATA_H ) */ 54 | 55 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_libfvalue.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libfvalue header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_LIBFVALUE_H ) 23 | #define _LIBVSLVM_LIBFVALUE_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBFVALUE for local use of libfvalue 28 | */ 29 | #if defined( HAVE_LOCAL_LIBFVALUE ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | #include 40 | #include 41 | #include 42 | #include 43 | #include 44 | #include 45 | 46 | #else 47 | 48 | /* If libtool DLL support is enabled set LIBFVALUE_DLL_IMPORT 49 | * before including libfvalue.h 50 | */ 51 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 52 | #define LIBFVALUE_DLL_IMPORT 53 | #endif 54 | 55 | #include 56 | 57 | #endif /* defined( HAVE_LOCAL_LIBFVALUE ) */ 58 | 59 | #endif /* !defined( _LIBVSLVM_LIBFVALUE_H ) */ 60 | 61 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_metadata_area.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The metadata area functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_METADATA_AREA_H ) 23 | #define _LIBVSLVM_METADATA_AREA_H 24 | 25 | #include 26 | #include 27 | 28 | #include "libvslvm_libbfio.h" 29 | #include "libvslvm_libcdata.h" 30 | #include "libvslvm_libcerror.h" 31 | 32 | #if defined( __cplusplus ) 33 | extern "C" { 34 | #endif 35 | 36 | typedef struct libvslvm_metadata_area libvslvm_metadata_area_t; 37 | 38 | struct libvslvm_metadata_area 39 | { 40 | /* The raw location descriptors array 41 | */ 42 | libcdata_array_t *raw_location_descriptors_array; 43 | }; 44 | 45 | int libvslvm_metadata_area_initialize( 46 | libvslvm_metadata_area_t **metadata_area, 47 | libcerror_error_t **error ); 48 | 49 | int libvslvm_metadata_area_free( 50 | libvslvm_metadata_area_t **metadata_area, 51 | libcerror_error_t **error ); 52 | 53 | int libvslvm_metadata_area_read_data( 54 | libvslvm_metadata_area_t *metadata_area, 55 | const uint8_t *data, 56 | size_t data_size, 57 | off64_t file_offset, 58 | libcerror_error_t **error ); 59 | 60 | int libvslvm_metadata_area_read_file_io_handle( 61 | libvslvm_metadata_area_t *metadata_area, 62 | libbfio_handle_t *file_io_handle, 63 | off64_t file_offset, 64 | libcerror_error_t **error ); 65 | 66 | #if defined( __cplusplus ) 67 | } 68 | #endif 69 | 70 | #endif /* !defined( _LIBVSLVM_METADATA_AREA_H ) */ 71 | 72 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_notify.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Notification functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_NOTIFY_H ) 23 | #define _LIBVSLVM_NOTIFY_H 24 | 25 | #include 26 | #include 27 | #include 28 | 29 | #include "libvslvm_extern.h" 30 | #include "libvslvm_libcerror.h" 31 | 32 | #if defined( __cplusplus ) 33 | extern "C" { 34 | #endif 35 | 36 | #if !defined( HAVE_LOCAL_LIBVSLVM ) 37 | 38 | LIBVSLVM_EXTERN \ 39 | void libvslvm_notify_set_verbose( 40 | int verbose ); 41 | 42 | LIBVSLVM_EXTERN \ 43 | int libvslvm_notify_set_stream( 44 | FILE *stream, 45 | libcerror_error_t **error ); 46 | 47 | LIBVSLVM_EXTERN \ 48 | int libvslvm_notify_stream_open( 49 | const char *filename, 50 | libcerror_error_t **error ); 51 | 52 | LIBVSLVM_EXTERN \ 53 | int libvslvm_notify_stream_close( 54 | libcerror_error_t **error ); 55 | 56 | #endif /* !defined( HAVE_LOCAL_LIBVSLVM ) */ 57 | 58 | #if defined( __cplusplus ) 59 | } 60 | #endif 61 | 62 | #endif /* !defined( _LIBVSLVM_NOTIFY_H ) */ 63 | 64 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_raw_location_descriptor.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Raw location descriptor functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_RAW_LOCATION_DESCRIPTOR_H ) 23 | #define _LIBVSLVM_RAW_LOCATION_DESCRIPTOR_H 24 | 25 | #include 26 | #include 27 | 28 | #include "libvslvm_libcerror.h" 29 | 30 | #if defined( __cplusplus ) 31 | extern "C" { 32 | #endif 33 | 34 | typedef struct libvslvm_raw_location_descriptor libvslvm_raw_location_descriptor_t; 35 | 36 | struct libvslvm_raw_location_descriptor 37 | { 38 | /* The offset 39 | */ 40 | uint64_t offset; 41 | 42 | /* The size 43 | */ 44 | uint64_t size; 45 | 46 | /* The checksum 47 | */ 48 | uint32_t checksum; 49 | 50 | /* The flags 51 | */ 52 | uint32_t flags; 53 | }; 54 | 55 | int libvslvm_raw_location_descriptor_initialize( 56 | libvslvm_raw_location_descriptor_t **raw_location_descriptor, 57 | libcerror_error_t **error ); 58 | 59 | int libvslvm_raw_location_descriptor_free( 60 | libvslvm_raw_location_descriptor_t **raw_location_descriptor, 61 | libcerror_error_t **error ); 62 | 63 | int libvslvm_raw_location_descriptor_get( 64 | libvslvm_raw_location_descriptor_t *raw_location_descriptor, 65 | off64_t *offset, 66 | size64_t *size, 67 | uint32_t *checksum, 68 | uint32_t *flags, 69 | libcerror_error_t **error ); 70 | 71 | int libvslvm_raw_location_descriptor_set( 72 | libvslvm_raw_location_descriptor_t *raw_location_descriptor, 73 | off64_t offset, 74 | size64_t size, 75 | uint32_t checksum, 76 | uint32_t flags, 77 | libcerror_error_t **error ); 78 | 79 | #if defined( __cplusplus ) 80 | } 81 | #endif 82 | 83 | #endif /* !defined( _LIBVSLVM_RAW_LOCATION_DESCRIPTOR_H ) */ 84 | 85 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_stripe.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Stripe functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_INTERNAL_STRIPE_H ) 23 | #define _LIBVSLVM_INTERNAL_STRIPE_H 24 | 25 | #include 26 | #include 27 | 28 | #include "libvslvm_extern.h" 29 | #include "libvslvm_libcerror.h" 30 | #include "libvslvm_types.h" 31 | 32 | #if defined( __cplusplus ) 33 | extern "C" { 34 | #endif 35 | 36 | typedef struct libvslvm_internal_stripe libvslvm_internal_stripe_t; 37 | 38 | struct libvslvm_internal_stripe 39 | { 40 | /* The physical volume name 41 | */ 42 | char *physical_volume_name; 43 | 44 | /* The physical volume name size 45 | */ 46 | size_t physical_volume_name_size; 47 | 48 | /* The data area offset 49 | */ 50 | off64_t data_area_offset; 51 | }; 52 | 53 | int libvslvm_stripe_initialize( 54 | libvslvm_stripe_t **stripe, 55 | libcerror_error_t **error ); 56 | 57 | LIBVSLVM_EXTERN \ 58 | int libvslvm_stripe_free( 59 | libvslvm_stripe_t **stripe, 60 | libcerror_error_t **error ); 61 | 62 | int libvslvm_internal_stripe_free( 63 | libvslvm_internal_stripe_t **internal_stripe, 64 | libcerror_error_t **error ); 65 | 66 | LIBVSLVM_EXTERN \ 67 | int libvslvm_stripe_get_physical_volume_name_size( 68 | libvslvm_stripe_t *stripe, 69 | size_t *physical_volume_name_size, 70 | libcerror_error_t **error ); 71 | 72 | LIBVSLVM_EXTERN \ 73 | int libvslvm_stripe_get_physical_volume_name( 74 | libvslvm_stripe_t *stripe, 75 | char *physical_volume_name, 76 | size_t physical_volume_name_size, 77 | libcerror_error_t **error ); 78 | 79 | int libvslvm_internal_stripe_set_physical_volume_name( 80 | libvslvm_internal_stripe_t *internal_stripe, 81 | const char *physical_volume_name, 82 | size_t physical_volume_name_size, 83 | libcerror_error_t **error ); 84 | 85 | LIBVSLVM_EXTERN \ 86 | int libvslvm_stripe_get_data_area_offset( 87 | libvslvm_stripe_t *stripe, 88 | off64_t *data_area_offset, 89 | libcerror_error_t **error ); 90 | 91 | int libvslvm_stripe_set_data_area_offset( 92 | libvslvm_stripe_t *stripe, 93 | off64_t data_area_offset, 94 | libcerror_error_t **error ); 95 | 96 | #if defined( __cplusplus ) 97 | } 98 | #endif 99 | 100 | #endif /* !defined( _LIBVSLVM_INTERNAL_STRIPE_H ) */ 101 | 102 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_support.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Support functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_SUPPORT_H ) 23 | #define _LIBVSLVM_SUPPORT_H 24 | 25 | #include 26 | #include 27 | 28 | #include "libvslvm_extern.h" 29 | #include "libvslvm_libbfio.h" 30 | #include "libvslvm_libcerror.h" 31 | 32 | #if defined( __cplusplus ) 33 | extern "C" { 34 | #endif 35 | 36 | #if !defined( HAVE_LOCAL_LIBVSLVM ) 37 | 38 | LIBVSLVM_EXTERN \ 39 | const char *libvslvm_get_version( 40 | void ); 41 | 42 | LIBVSLVM_EXTERN \ 43 | int libvslvm_get_access_flags_read( 44 | void ); 45 | 46 | LIBVSLVM_EXTERN \ 47 | int libvslvm_get_access_flags_read_write( 48 | void ); 49 | 50 | LIBVSLVM_EXTERN \ 51 | int libvslvm_get_access_flags_write( 52 | void ); 53 | 54 | LIBVSLVM_EXTERN \ 55 | int libvslvm_get_codepage( 56 | int *codepage, 57 | libcerror_error_t **error ); 58 | 59 | LIBVSLVM_EXTERN \ 60 | int libvslvm_set_codepage( 61 | int codepage, 62 | libcerror_error_t **error ); 63 | 64 | #endif /* !defined( HAVE_LOCAL_LIBVSLVM ) */ 65 | 66 | LIBVSLVM_EXTERN \ 67 | int libvslvm_check_volume_signature( 68 | const char *filename, 69 | libcerror_error_t **error ); 70 | 71 | #if defined( HAVE_WIDE_CHARACTER_TYPE ) 72 | LIBVSLVM_EXTERN \ 73 | int libvslvm_check_volume_signature_wide( 74 | const wchar_t *filename, 75 | libcerror_error_t **error ); 76 | #endif 77 | 78 | LIBVSLVM_EXTERN \ 79 | int libvslvm_check_volume_signature_file_io_handle( 80 | libbfio_handle_t *file_io_handle, 81 | libcerror_error_t **error ); 82 | 83 | #if defined( __cplusplus ) 84 | } 85 | #endif 86 | 87 | #endif /* !defined( _LIBVSLVM_SUPPORT_H ) */ 88 | 89 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_types.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The internal type definitions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_INTERNAL_TYPES_H ) 23 | #define _LIBVSLVM_INTERNAL_TYPES_H 24 | 25 | #include 26 | #include 27 | 28 | /* Define HAVE_LOCAL_LIBVSLVM for local use of libvslvm 29 | * The definitions in are copied here 30 | * for local use of libvslvm 31 | */ 32 | #if defined( HAVE_LOCAL_LIBVSLVM ) 33 | 34 | /* The following type definitions hide internal data structures 35 | */ 36 | #if defined( HAVE_DEBUG_OUTPUT ) && !defined( WINAPI ) 37 | typedef struct libvslvm_handle {} libvslvm_handle_t; 38 | typedef struct libvslvm_logical_volume {} libvslvm_logical_volume_t; 39 | typedef struct libvslvm_physical_volume {} libvslvm_physical_volume_t; 40 | typedef struct libvslvm_segment {} libvslvm_segment_t; 41 | typedef struct libvslvm_stripe {} libvslvm_stripe_t; 42 | typedef struct libvslvm_volume_group {} libvslvm_volume_group_t; 43 | 44 | #else 45 | typedef intptr_t libvslvm_handle_t; 46 | typedef intptr_t libvslvm_logical_volume_t; 47 | typedef intptr_t libvslvm_physical_volume_t; 48 | typedef intptr_t libvslvm_segment_t; 49 | typedef intptr_t libvslvm_stripe_t; 50 | typedef intptr_t libvslvm_volume_group_t; 51 | 52 | #endif /* defined( HAVE_DEBUG_OUTPUT ) && !defined( WINAPI ) */ 53 | 54 | #endif /* defined( HAVE_LOCAL_LIBVSLVM ) */ 55 | 56 | #endif /* !defined( _LIBVSLVM_INTERNAL_TYPES_H ) */ 57 | 58 | -------------------------------------------------------------------------------- /libvslvm/libvslvm_unused.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Definitions to silence compiler warnings about unused function attributes/parameters. 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _LIBVSLVM_UNUSED_H ) 23 | #define _LIBVSLVM_UNUSED_H 24 | 25 | #include 26 | 27 | #if !defined( LIBVSLVM_ATTRIBUTE_UNUSED ) 28 | #if defined( __GNUC__ ) && __GNUC__ >= 3 29 | #define LIBVSLVM_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 30 | #else 31 | #define LIBVSLVM_ATTRIBUTE_UNUSED 32 | #endif 33 | #endif 34 | 35 | #if defined( _MSC_VER ) 36 | #define LIBVSLVM_UNREFERENCED_PARAMETER( parameter ) \ 37 | UNREFERENCED_PARAMETER( parameter ); 38 | #else 39 | #define LIBVSLVM_UNREFERENCED_PARAMETER( parameter ) \ 40 | /* parameter */ 41 | #endif 42 | 43 | #endif /* !defined( _LIBVSLVM_UNUSED_H ) */ 44 | 45 | -------------------------------------------------------------------------------- /libvslvm/vslvm_metadata_area.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Metadata area definitions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVM_METADATA_AREA_H ) 23 | #define _VSLVM_METADATA_AREA_H 24 | 25 | #include 26 | #include 27 | 28 | #if defined( __cplusplus ) 29 | extern "C" { 30 | #endif 31 | 32 | typedef struct vslvm_metadata_area_header vslvm_metadata_area_header_t; 33 | 34 | struct vslvm_metadata_area_header 35 | { 36 | /* The checksum 37 | * Consists of 4 bytes 38 | */ 39 | uint8_t checksum[ 4 ]; 40 | 41 | /* The signature 42 | * Consists of 16 bytes 43 | * Contains: "\x20LVM2\x20x[5A%r0N*>" 44 | */ 45 | uint8_t signature[ 16 ]; 46 | 47 | /* The version 48 | * Consists of 4 bytes 49 | */ 50 | uint8_t version[ 4 ]; 51 | 52 | /* The data offset 53 | * Consists of 8 bytes 54 | */ 55 | uint8_t data_offset[ 8 ]; 56 | 57 | /* The data size 58 | * Consists of 8 bytes 59 | */ 60 | uint8_t data_size[ 8 ]; 61 | }; 62 | 63 | typedef struct vslvm_raw_location_descriptor vslvm_raw_location_descriptor_t; 64 | 65 | struct vslvm_raw_location_descriptor 66 | { 67 | /* The offset 68 | * Consists of 8 bytes 69 | */ 70 | uint8_t offset[ 8 ]; 71 | 72 | /* The size 73 | * Consists of 8 bytes 74 | */ 75 | uint8_t size[ 8 ]; 76 | 77 | /* The checksum 78 | * Consists of 4 bytes 79 | */ 80 | uint8_t checksum[ 4 ]; 81 | 82 | /* The flags 83 | * Consists of 4 bytes 84 | */ 85 | uint8_t flags[ 4 ]; 86 | }; 87 | 88 | #if defined( __cplusplus ) 89 | } 90 | #endif 91 | 92 | #endif /* !defined( _VSLVM_METADATA_AREA_H ) */ 93 | 94 | -------------------------------------------------------------------------------- /libvslvm/vslvm_physical_volume_label.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Physical volume label definitions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVM_PHYSICAL_VOLUME_LABEL_H ) 23 | #define _VSLVM_PHYSICAL_VOLUME_LABEL_H 24 | 25 | #include 26 | #include 27 | 28 | #if defined( __cplusplus ) 29 | extern "C" { 30 | #endif 31 | 32 | typedef struct vslvm_physical_volume_label_header vslvm_physical_volume_label_header_t; 33 | 34 | struct vslvm_physical_volume_label_header 35 | { 36 | /* The signature 37 | * Consists of 8 bytes 38 | * Contains: "LABELONE" 39 | */ 40 | uint8_t signature[ 8 ]; 41 | 42 | /* The sector number 43 | * Consists of 8 bytes 44 | */ 45 | uint8_t sector_number[ 8 ]; 46 | 47 | /* The checksum 48 | * Consists of 4 bytes 49 | */ 50 | uint8_t checksum[ 4 ]; 51 | 52 | /* The data offset 53 | * Consists of 4 bytes 54 | */ 55 | uint8_t data_offset[ 4 ]; 56 | 57 | /* The type indicator 58 | * Consists of 8 bytes 59 | * Contains: "LVM2\x20001" 60 | */ 61 | uint8_t type_indicator[ 8 ]; 62 | }; 63 | 64 | typedef struct vslvm_physical_volume_header vslvm_physical_volume_header_t; 65 | 66 | struct vslvm_physical_volume_header 67 | { 68 | /* The identifier 69 | * Consists of 32 bytes 70 | */ 71 | uint8_t identifier[ 32 ]; 72 | 73 | /* The volume size 74 | * Consists of 8 bytes 75 | */ 76 | uint8_t volume_size[ 8 ]; 77 | }; 78 | 79 | typedef struct vslvm_data_area_descriptor vslvm_data_area_descriptor_t; 80 | 81 | struct vslvm_data_area_descriptor 82 | { 83 | /* The offset 84 | * Consists of 8 bytes 85 | */ 86 | uint8_t offset[ 8 ]; 87 | 88 | /* The size 89 | * Consists of 8 bytes 90 | */ 91 | uint8_t size[ 8 ]; 92 | }; 93 | 94 | #if defined( __cplusplus ) 95 | } 96 | #endif 97 | 98 | #endif /* !defined( _VSLVM_PHYSICAL_VOLUME_LABEL_H ) */ 99 | 100 | -------------------------------------------------------------------------------- /m4/tests.m4: -------------------------------------------------------------------------------- 1 | dnl Functions for testing 2 | dnl 3 | dnl Version: 20200712 4 | 5 | dnl Function to detect if tests dependencies are available 6 | AC_DEFUN([AX_TESTS_CHECK_LOCAL], 7 | [AC_CHECK_HEADERS([dlfcn.h]) 8 | 9 | AC_CHECK_FUNCS([fmemopen getopt mkstemp setenv tzset unlink]) 10 | 11 | AC_CHECK_LIB( 12 | dl, 13 | dlsym) 14 | 15 | AS_IF( 16 | [test "x$lt_cv_prog_gnu_ld" = xyes && test "x$ac_cv_lib_dl_dlsym" = xyes], 17 | [AC_DEFINE( 18 | [HAVE_GNU_DL_DLSYM], 19 | [1], 20 | [Define to 1 if dlsym function is available in GNU dl.]) 21 | ]) 22 | ]) 23 | 24 | dnl Function to detect if OSS-Fuzz build environment is available 25 | AC_DEFUN([AX_TESTS_CHECK_OSSFUZZ], 26 | [AM_CONDITIONAL( 27 | HAVE_LIB_FUZZING_ENGINE, 28 | [test "x${LIB_FUZZING_ENGINE}" != x]) 29 | AC_SUBST( 30 | [LIB_FUZZING_ENGINE], 31 | ["${LIB_FUZZING_ENGINE}"]) 32 | ]) 33 | 34 | -------------------------------------------------------------------------------- /m4/types.m4: -------------------------------------------------------------------------------- 1 | dnl Functions for type definitions 2 | dnl 3 | dnl Version: 20180727 4 | 5 | dnl Function to detect if type definitions are available 6 | AC_DEFUN([AX_TYPES_CHECK_LOCAL], 7 | [AS_IF( 8 | [test "x$ac_cv_enable_winapi" = xyes], 9 | [ac_cv_enable_wide_character_type=yes]) 10 | 11 | AS_IF( 12 | [test "x$ac_cv_enable_wide_character_type" = xyes], 13 | [AC_DEFINE( 14 | [HAVE_WIDE_CHARACTER_TYPE], 15 | [1], 16 | [Define to 1 if wide character type should be used.]) 17 | AC_SUBST( 18 | [HAVE_WIDE_CHARACTER_TYPE], 19 | [1]) ], 20 | [AC_SUBST( 21 | [HAVE_WIDE_CHARACTER_TYPE], 22 | [0]) 23 | ]) 24 | 25 | AC_CHECK_HEADERS([sys/types.h inttypes.h stdint.h wchar.h]) 26 | 27 | AS_IF( 28 | [test "x$ac_cv_header_sys_types_h" = xyes], 29 | [AC_SUBST( 30 | [HAVE_SYS_TYPES_H], 31 | [1])], 32 | [AC_SUBST( 33 | [HAVE_SYS_TYPES_H], 34 | [0]) 35 | ]) 36 | 37 | AS_IF( 38 | [test "x$ac_cv_header_inttypes_h" = xyes], 39 | [AC_SUBST( 40 | [HAVE_INTTYPES_H], 41 | [1])], 42 | [AC_SUBST( 43 | [HAVE_INTTYPES_H], 44 | [0]) 45 | ]) 46 | 47 | AS_IF( 48 | [test "x$ac_cv_header_stdint_h" = xyes], 49 | [AC_SUBST( 50 | [HAVE_STDINT_H], 51 | [1])], 52 | [AC_SUBST( 53 | [HAVE_STDINT_H], 54 | [0]) 55 | ]) 56 | 57 | AS_IF( 58 | [test "x$ac_cv_header_wchar_h" = xyes], 59 | [AC_SUBST( 60 | [HAVE_WCHAR_H], 61 | [1]) ], 62 | [AC_SUBST( 63 | [HAVE_WCHAR_H], 64 | [0]) 65 | ]) 66 | 67 | AC_TYPE_MODE_T 68 | AC_TYPE_OFF_T 69 | AC_TYPE_SIZE_T 70 | 71 | AC_CHECK_TYPE( 72 | [size32_t], 73 | [AC_SUBST( 74 | [HAVE_SIZE32_T], 75 | [1])], 76 | [AC_SUBST( 77 | [HAVE_SIZE32_T], 78 | [0]) 79 | ]) 80 | 81 | AC_CHECK_TYPE( 82 | [ssize32_t], 83 | [AC_SUBST( 84 | [HAVE_SSIZE32_T], 85 | [1])], 86 | [AC_SUBST( 87 | [HAVE_SSIZE32_T], 88 | [0]) 89 | ]) 90 | 91 | AC_CHECK_TYPE( 92 | [size64_t], 93 | [AC_SUBST( 94 | [HAVE_SIZE64_T], 95 | [1])], 96 | [AC_SUBST( 97 | [HAVE_SIZE64_T], 98 | [0]) 99 | ]) 100 | 101 | AC_CHECK_TYPE( 102 | [ssize64_t], 103 | [AC_SUBST( 104 | [HAVE_SSIZE64_T], 105 | [1])], 106 | [AC_SUBST( 107 | [HAVE_SSIZE64_T], 108 | [0]) 109 | ]) 110 | 111 | AC_CHECK_TYPE( 112 | [off64_t], 113 | [AC_SUBST( 114 | [HAVE_OFF64_T], 115 | [1])], 116 | [AC_SUBST( 117 | [HAVE_OFF64_T], 118 | [0]) 119 | ]) 120 | 121 | AC_CHECK_TYPE([ssize_t]) 122 | AC_CHECK_TYPE([u64]) 123 | 124 | AC_CHECK_SIZEOF([int]) 125 | AC_CHECK_SIZEOF([long]) 126 | AC_CHECK_SIZEOF([off_t]) 127 | AC_CHECK_SIZEOF([size_t]) 128 | 129 | AS_IF( 130 | [test "x$ac_cv_header_wchar_h" = xyes], 131 | [AC_CHECK_SIZEOF([wchar_t])]) 132 | ]) 133 | 134 | -------------------------------------------------------------------------------- /manuals/Makefile.am: -------------------------------------------------------------------------------- 1 | man_MANS = \ 2 | vslvminfo.1 \ 3 | libvslvm.3 4 | 5 | EXTRA_DIST = \ 6 | vslvminfo.1 \ 7 | libvslvm.3 8 | 9 | DISTCLEANFILES = \ 10 | Makefile \ 11 | Makefile.in 12 | 13 | -------------------------------------------------------------------------------- /manuals/vslvminfo.1: -------------------------------------------------------------------------------- 1 | .Dd March 6, 2019 2 | .Dt vslvminfo 3 | .Os libvslvm 4 | .Sh NAME 5 | .Nm vslvminfo 6 | .Nd determines information about a Linux Logical Volume Manager (LVM) volume system 7 | .Sh SYNOPSIS 8 | .Nm vslvminfo 9 | .Op Fl o Ar offset 10 | .Op Fl hvV 11 | .Ar source 12 | .Sh DESCRIPTION 13 | .Nm vslvminfo 14 | is a utility to determine information about a Linux Logical Volume Manager (LVM) volume system 15 | .Pp 16 | .Nm vslvminfo 17 | is part of the 18 | .Nm libvslvm 19 | package. 20 | .Nm libvslvm 21 | is a library to access the Linux Logical Volume Manager (LVM) volume system format 22 | .Pp 23 | .Ar source 24 | is the source file. 25 | .Pp 26 | The options are as follows: 27 | .Bl -tag -width Ds 28 | .It Fl h 29 | shows this help 30 | .It Fl o Ar offset 31 | specify the volume offset in bytes 32 | .It Fl v 33 | verbose output to stderr 34 | .It Fl V 35 | print version 36 | .El 37 | .Sh ENVIRONMENT 38 | None 39 | .Sh FILES 40 | None 41 | .Sh EXAMPLES 42 | .Bd -literal 43 | # vslvminfo /dev/sda1 44 | vslvminfo 20160109 45 | 46 | Linux Logical Volume Manager (LVM) information: 47 | Volume Group (VG): 48 | Name: vg_test 49 | Identifier: 5eR8zl-q5VX-Qtiw-FmDd-6yBE-I8qe-0sjQf9 50 | Sequence number: 4 51 | Extent size: 4194304 bytes 52 | Number of physical volumes: 1 53 | Number of logical volumes: 1 54 | 55 | Physical Volume (PV): 1 56 | Name: pv0 57 | Identifier: 2TdWwb-R5um-UZnU-3Yb6-K2MF-bTtr-AgVQfp 58 | Device path: /dev/loop1 59 | Volume size: 268435456 bytes 60 | 61 | Logical Volume (LV): 1 62 | Name: lv_test1 63 | Identifier: Lt5rVq-Ksgd-p8kx-XYP4-6uTq-Mlh4-yxOiL4 64 | Number of segments: 1 65 | Segment: 1 66 | Offset: 0x00000000 (0) 67 | Size: 76 MiB (79691776 bytes) 68 | Number of stripes: 1 69 | Stripe: 1 70 | Physical volume: pv0 71 | Data area offset: 0x00000000 (0) 72 | 73 | .Ed 74 | .Sh DIAGNOSTICS 75 | Errors, verbose and debug output are printed to stderr when verbose output \-v is enabled. 76 | Verbose and debug output are only printed when enabled at compilation. 77 | .Sh BUGS 78 | Please report bugs of any kind to or on the project website: 79 | https://github.com/libyal/libvslvm/ 80 | .Sh AUTHOR 81 | These man pages were written by Joachim Metz. 82 | .Sh COPYRIGHT 83 | Copyright (C) 2014-2024, Joachim Metz . 84 | This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 85 | -------------------------------------------------------------------------------- /msvscpp/Makefile.am: -------------------------------------------------------------------------------- 1 | MSVSCPP_FILES = \ 2 | libbfio/libbfio.vcproj \ 3 | libcdata/libcdata.vcproj \ 4 | libcerror/libcerror.vcproj \ 5 | libcfile/libcfile.vcproj \ 6 | libclocale/libclocale.vcproj \ 7 | libcnotify/libcnotify.vcproj \ 8 | libcpath/libcpath.vcproj \ 9 | libcsplit/libcsplit.vcproj \ 10 | libcthreads/libcthreads.vcproj \ 11 | libfcache/libfcache.vcproj \ 12 | libfdata/libfdata.vcproj \ 13 | libfvalue/libfvalue.vcproj \ 14 | libuna/libuna.vcproj \ 15 | libvslvm/libvslvm.vcproj \ 16 | pyvslvm/pyvslvm.vcproj \ 17 | vslvm_test_checksum/vslvm_test_checksum.vcproj \ 18 | vslvm_test_chunk_data/vslvm_test_chunk_data.vcproj \ 19 | vslvm_test_data_area_descriptor/vslvm_test_data_area_descriptor.vcproj \ 20 | vslvm_test_error/vslvm_test_error.vcproj \ 21 | vslvm_test_handle/vslvm_test_handle.vcproj \ 22 | vslvm_test_io_handle/vslvm_test_io_handle.vcproj \ 23 | vslvm_test_logical_volume/vslvm_test_logical_volume.vcproj \ 24 | vslvm_test_logical_volume_values/vslvm_test_logical_volume_values.vcproj \ 25 | vslvm_test_metadata/vslvm_test_metadata.vcproj \ 26 | vslvm_test_metadata_area/vslvm_test_metadata_area.vcproj \ 27 | vslvm_test_notify/vslvm_test_notify.vcproj \ 28 | vslvm_test_physical_volume/vslvm_test_physical_volume.vcproj \ 29 | vslvm_test_raw_location_descriptor/vslvm_test_raw_location_descriptor.vcproj \ 30 | vslvm_test_segment/vslvm_test_segment.vcproj \ 31 | vslvm_test_stripe/vslvm_test_stripe.vcproj \ 32 | vslvm_test_support/vslvm_test_support.vcproj \ 33 | vslvm_test_tools_info_handle/vslvm_test_tools_info_handle.vcproj \ 34 | vslvm_test_tools_output/vslvm_test_tools_output.vcproj \ 35 | vslvm_test_tools_signal/vslvm_test_tools_signal.vcproj \ 36 | vslvm_test_volume_group/vslvm_test_volume_group.vcproj \ 37 | vslvminfo/vslvminfo.vcproj \ 38 | vslvmmount/vslvmmount.vcproj \ 39 | libvslvm.sln 40 | 41 | EXTRA_DIST = \ 42 | $(MSVSCPP_FILES) 43 | 44 | DISTCLEANFILES = \ 45 | Makefile \ 46 | Makefile.in 47 | 48 | -------------------------------------------------------------------------------- /ossfuzz/Makefile.am: -------------------------------------------------------------------------------- 1 | if HAVE_LIB_FUZZING_ENGINE 2 | AM_CPPFLAGS = \ 3 | -I../include -I$(top_srcdir)/include \ 4 | -I../common -I$(top_srcdir)/common \ 5 | @LIBCERROR_CPPFLAGS@ \ 6 | @LIBCDATA_CPPFLAGS@ \ 7 | @LIBCLOCALE_CPPFLAGS@ \ 8 | @LIBCNOTIFY_CPPFLAGS@ \ 9 | @LIBUNA_CPPFLAGS@ \ 10 | @LIBCFILE_CPPFLAGS@ \ 11 | @LIBCPATH_CPPFLAGS@ \ 12 | @LIBBFIO_CPPFLAGS@ 13 | 14 | bin_PROGRAMS = \ 15 | handle_fuzzer \ 16 | logical_volume_fuzzer 17 | 18 | handle_fuzzer_SOURCES = \ 19 | handle_fuzzer.cc \ 20 | ossfuzz_libbfio.h \ 21 | ossfuzz_libvslvm.h 22 | 23 | handle_fuzzer_LDADD = \ 24 | @LIB_FUZZING_ENGINE@ \ 25 | @LIBBFIO_LIBADD@ \ 26 | @LIBCPATH_LIBADD@ \ 27 | @LIBCFILE_LIBADD@ \ 28 | @LIBUNA_LIBADD@ \ 29 | @LIBCDATA_LIBADD@ \ 30 | ../libvslvm/libvslvm.la \ 31 | @LIBCNOTIFY_LIBADD@ \ 32 | @LIBCLOCALE_LIBADD@ \ 33 | @LIBCERROR_LIBADD@ \ 34 | @LIBINTL@ 35 | 36 | logical_volume_fuzzer_SOURCES = \ 37 | logical_volume_fuzzer.cc \ 38 | ossfuzz_libbfio.h \ 39 | ossfuzz_libvslvm.h 40 | 41 | logical_volume_fuzzer_LDADD = \ 42 | @LIB_FUZZING_ENGINE@ \ 43 | @LIBBFIO_LIBADD@ \ 44 | @LIBCPATH_LIBADD@ \ 45 | @LIBCFILE_LIBADD@ \ 46 | @LIBUNA_LIBADD@ \ 47 | @LIBCDATA_LIBADD@ \ 48 | ../libvslvm/libvslvm.la \ 49 | @LIBCNOTIFY_LIBADD@ \ 50 | @LIBCLOCALE_LIBADD@ \ 51 | @LIBCERROR_LIBADD@ \ 52 | @LIBINTL@ 53 | endif 54 | 55 | DISTCLEANFILES = \ 56 | Makefile \ 57 | Makefile.in 58 | 59 | splint-local: 60 | @echo "Running splint on handle_fuzzer ..." 61 | -splint -preproc -redef $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(handle_fuzzer_SOURCES) 62 | @echo "Running splint on logical_volume_fuzzer ..." 63 | -splint -preproc -redef $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(logical_volume_fuzzer_SOURCES) 64 | 65 | -------------------------------------------------------------------------------- /ossfuzz/ossfuzz_libbfio.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libbfio header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _OSSFUZZ_LIBBFIO_H ) 23 | #define _OSSFUZZ_LIBBFIO_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBBFIO for local use of libbfio 28 | */ 29 | #if defined( HAVE_LOCAL_LIBBFIO ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | 40 | #else 41 | 42 | /* If libtool DLL support is enabled set LIBBFIO_DLL_IMPORT 43 | * before including libbfio.h 44 | */ 45 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) && !defined( HAVE_STATIC_EXECUTABLES ) 46 | #define LIBBFIO_DLL_IMPORT 47 | #endif 48 | 49 | #include 50 | 51 | #if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( LIBBFIO_HAVE_MULTI_THREAD_SUPPORT ) 52 | #error Multi-threading support requires libbfio with multi-threading support 53 | #endif 54 | 55 | #endif /* defined( HAVE_LOCAL_LIBBFIO ) */ 56 | 57 | #endif /* !defined( _OSSFUZZ_LIBBFIO_H ) */ 58 | 59 | -------------------------------------------------------------------------------- /ossfuzz/ossfuzz_libvslvm.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libvslvm header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _OSSFUZZ_LIBVSLVM_H ) 23 | #define _OSSFUZZ_LIBVSLVM_H 24 | 25 | #include 26 | 27 | #include 28 | 29 | #endif /* !defined( _OSSFUZZ_LIBVSLVM_H ) */ 30 | 31 | -------------------------------------------------------------------------------- /po/ChangeLog: -------------------------------------------------------------------------------- 1 | 2016-11-09 gettextize 2 | -------------------------------------------------------------------------------- /po/Makevars.in: -------------------------------------------------------------------------------- 1 | # Makefile variables for PO directory in any package using GNU gettext. 2 | 3 | # Usually the message domain is the same as the package name. 4 | DOMAIN = @PACKAGE@ 5 | 6 | # These two variables depend on the location of this directory. 7 | subdir = po 8 | top_builddir = .. 9 | 10 | # These options get passed to xgettext. 11 | XGETTEXT_OPTIONS = --keyword=_ --keyword=N_ 12 | 13 | # This is the copyright holder that gets inserted into the header of the 14 | # $(DOMAIN).pot file. Set this to the copyright holder of the surrounding 15 | # package. (Note that the msgstr strings, extracted from the package's 16 | # sources, belong to the copyright holder of the package.) Translators are 17 | # expected to transfer the copyright for their translations to this person 18 | # or entity, or to disclaim their copyright. The empty string stands for 19 | # the public domain; in this case the translators are expected to disclaim 20 | # their copyright. 21 | COPYRIGHT_HOLDER = Joachim Metz 22 | 23 | # This is the email address or URL to which the translators shall report 24 | # bugs in the untranslated strings: 25 | # - Strings which are not entire sentences, see the maintainer guidelines 26 | # in the GNU gettext documentation, section 'Preparing Strings'. 27 | # - Strings which use unclear terms or require additional context to be 28 | # understood. 29 | # - Strings which make invalid assumptions about notation of date, time or 30 | # money. 31 | # - Pluralisation problems. 32 | # - Incorrect English spelling. 33 | # - Incorrect formatting. 34 | # It can be your email address, or a mailing list address where translators 35 | # can write to without being subscribed, or the URL of a web page through 36 | # which the translators can contact you. 37 | MSGID_BUGS_ADDRESS = @PACKAGE_BUGREPORT@ 38 | 39 | # This is the list of locale categories, beyond LC_MESSAGES, for which the 40 | # message catalogs shall be used. It is usually empty. 41 | EXTRA_LOCALE_CATEGORIES = 42 | 43 | # Additional make targets. 44 | sources splint: 45 | 46 | -------------------------------------------------------------------------------- /po/POTFILES.in: -------------------------------------------------------------------------------- 1 | # List of source files which contain translatable strings. 2 | -------------------------------------------------------------------------------- /pyproject.toml: -------------------------------------------------------------------------------- 1 | [build-system] 2 | requires = ["setuptools", "wheel"] 3 | build-backend = "setuptools.build_meta" 4 | 5 | -------------------------------------------------------------------------------- /pyvslvm/Makefile.am: -------------------------------------------------------------------------------- 1 | if HAVE_PYTHON 2 | AM_CFLAGS = \ 3 | -I../include -I$(top_srcdir)/include \ 4 | -I../common -I$(top_srcdir)/common \ 5 | @LIBCERROR_CPPFLAGS@ \ 6 | @LIBCDATA_CPPFLAGS@ \ 7 | @LIBCLOCALE_CPPFLAGS@ \ 8 | @LIBCSPLIT_CPPFLAGS@ \ 9 | @LIBUNA_CPPFLAGS@ \ 10 | @LIBCFILE_CPPFLAGS@ \ 11 | @LIBCPATH_CPPFLAGS@ \ 12 | @LIBBFIO_CPPFLAGS@ \ 13 | @LIBVSLVM_DLL_IMPORT@ 14 | 15 | pyexec_LTLIBRARIES = pyvslvm.la 16 | 17 | pyvslvm_la_SOURCES = \ 18 | pyvslvm.c pyvslvm.h \ 19 | pyvslvm_error.c pyvslvm_error.h \ 20 | pyvslvm_file_object_io_handle.c pyvslvm_file_object_io_handle.h \ 21 | pyvslvm_file_objects_io_pool.c pyvslvm_file_objects_io_pool.h \ 22 | pyvslvm_handle.c pyvslvm_handle.h \ 23 | pyvslvm_integer.c pyvslvm_integer.h \ 24 | pyvslvm_libbfio.h \ 25 | pyvslvm_libcerror.h \ 26 | pyvslvm_libclocale.h \ 27 | pyvslvm_libvslvm.h \ 28 | pyvslvm_logical_volume.c pyvslvm_logical_volume.h \ 29 | pyvslvm_logical_volumes.c pyvslvm_logical_volumes.h \ 30 | pyvslvm_physical_volume.c pyvslvm_physical_volume.h \ 31 | pyvslvm_physical_volumes.c pyvslvm_physical_volumes.h \ 32 | pyvslvm_python.h \ 33 | pyvslvm_segment.c pyvslvm_segment.h \ 34 | pyvslvm_segments.c pyvslvm_segments.h \ 35 | pyvslvm_stripe.c pyvslvm_stripe.h \ 36 | pyvslvm_stripes.c pyvslvm_stripes.h \ 37 | pyvslvm_unused.h \ 38 | pyvslvm_volume_group.c pyvslvm_volume_group.h 39 | 40 | pyvslvm_la_LIBADD = \ 41 | @LIBCERROR_LIBADD@ \ 42 | ../libvslvm/libvslvm.la \ 43 | @LIBCDATA_LIBADD@ \ 44 | @LIBCLOCALE_LIBADD@ \ 45 | @LIBCSPLIT_LIBADD@ \ 46 | @LIBUNA_LIBADD@ \ 47 | @LIBCFILE_LIBADD@ \ 48 | @LIBCPATH_LIBADD@ \ 49 | @LIBBFIO_LIBADD@ 50 | 51 | pyvslvm_la_CPPFLAGS = $(PYTHON_CPPFLAGS) 52 | pyvslvm_la_LDFLAGS = -module -avoid-version $(PYTHON_LDFLAGS) 53 | 54 | endif 55 | 56 | DISTCLEANFILES = \ 57 | Makefile \ 58 | Makefile.in 59 | 60 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Python bindings module for libvslvm (pyvslvm) 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_H ) 23 | #define _PYVSLVM_H 24 | 25 | #include 26 | #include 27 | 28 | #include "pyvslvm_python.h" 29 | 30 | #if defined( __cplusplus ) 31 | extern "C" { 32 | #endif 33 | 34 | PyObject *pyvslvm_get_version( 35 | PyObject *self, 36 | PyObject *arguments ); 37 | 38 | PyObject *pyvslvm_check_volume_signature( 39 | PyObject *self, 40 | PyObject *arguments, 41 | PyObject *keywords ); 42 | 43 | PyObject *pyvslvm_check_volume_signature_file_object( 44 | PyObject *self, 45 | PyObject *arguments, 46 | PyObject *keywords ); 47 | 48 | PyObject *pyvslvm_open_new_handle( 49 | PyObject *self, 50 | PyObject *arguments, 51 | PyObject *keywords ); 52 | 53 | PyObject *pyvslvm_open_new_handle_with_file_object( 54 | PyObject *self, 55 | PyObject *arguments, 56 | PyObject *keywords ); 57 | 58 | #if PY_MAJOR_VERSION >= 3 59 | PyMODINIT_FUNC PyInit_pyvslvm( 60 | void ); 61 | #else 62 | PyMODINIT_FUNC initpyvslvm( 63 | void ); 64 | #endif 65 | 66 | #if defined( __cplusplus ) 67 | } 68 | #endif 69 | 70 | #endif /* !defined( _PYVSLVM_H ) */ 71 | 72 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_error.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Error functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_ERROR_H ) 23 | #define _PYVSLVM_ERROR_H 24 | 25 | #include 26 | #include 27 | 28 | #include "pyvslvm_libcerror.h" 29 | #include "pyvslvm_python.h" 30 | 31 | #define PYVSLVM_ERROR_STRING_SIZE 2048 32 | 33 | #if defined( __cplusplus ) 34 | extern "C" { 35 | #endif 36 | 37 | void pyvslvm_error_fetch( 38 | libcerror_error_t **error, 39 | int error_domain, 40 | int error_code, 41 | const char *format_string, 42 | ... ); 43 | 44 | void pyvslvm_error_fetch_and_raise( 45 | PyObject *exception_object, 46 | const char *format_string, 47 | ... ); 48 | 49 | void pyvslvm_error_raise( 50 | libcerror_error_t *error, 51 | PyObject *exception_object, 52 | const char *format_string, 53 | ... ); 54 | 55 | #if defined( __cplusplus ) 56 | } 57 | #endif 58 | 59 | #endif /* !defined( _PYVSLVM_ERROR_H ) */ 60 | 61 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_file_objects_io_pool.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Python file objects IO pool functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_FILE_OBJECTS_IO_POOL_H ) 23 | #define _PYVSLVM_FILE_OBJECTS_IO_POOL_H 24 | 25 | #include 26 | #include 27 | 28 | #include "pyvslvm_libbfio.h" 29 | #include "pyvslvm_libcerror.h" 30 | #include "pyvslvm_python.h" 31 | 32 | #if defined( __cplusplus ) 33 | extern "C" { 34 | #endif 35 | 36 | int pyvslvm_file_objects_pool_initialize( 37 | libbfio_pool_t **pool, 38 | PyObject *sequence_object, 39 | int access_flags, 40 | libcerror_error_t **error ); 41 | 42 | #if defined( __cplusplus ) 43 | } 44 | #endif 45 | 46 | #endif /* !defined( _PYVSLVM_FILE_OBJECTS_IO_POOL_H ) */ 47 | 48 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_integer.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Integer functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_INTEGER_H ) 23 | #define _PYVSLVM_INTEGER_H 24 | 25 | #include 26 | #include 27 | 28 | #include "pyvslvm_libcerror.h" 29 | #include "pyvslvm_python.h" 30 | 31 | #if defined( __cplusplus ) 32 | extern "C" { 33 | #endif 34 | 35 | PyObject *pyvslvm_integer_signed_new_from_64bit( 36 | int64_t value_64bit ); 37 | 38 | PyObject *pyvslvm_integer_unsigned_new_from_64bit( 39 | uint64_t value_64bit ); 40 | 41 | int pyvslvm_integer_signed_copy_to_64bit( 42 | PyObject *integer_object, 43 | int64_t *value_64bit, 44 | libcerror_error_t **error ); 45 | 46 | int pyvslvm_integer_unsigned_copy_to_64bit( 47 | PyObject *integer_object, 48 | uint64_t *value_64bit, 49 | libcerror_error_t **error ); 50 | 51 | #if defined( __cplusplus ) 52 | } 53 | #endif 54 | 55 | #endif /* !defined( _PYVSLVM_INTEGER_H ) */ 56 | 57 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_libbfio.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libbfio header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_LIBBFIO_H ) 23 | #define _PYVSLVM_LIBBFIO_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBBFIO for local use of libbfio 28 | */ 29 | #if defined( HAVE_LOCAL_LIBBFIO ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | 40 | #else 41 | 42 | /* If libtool DLL support is enabled set LIBBFIO_DLL_IMPORT 43 | * before including libbfio.h 44 | */ 45 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 46 | #define LIBBFIO_DLL_IMPORT 47 | #endif 48 | 49 | #include 50 | 51 | #endif /* defined( HAVE_LOCAL_LIBBFIO ) */ 52 | 53 | #endif /* !defined( _PYVSLVM_LIBBFIO_H ) */ 54 | 55 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_libcerror.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libcerror header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_LIBCERROR_H ) 23 | #define _PYVSLVM_LIBCERROR_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCERROR for local use of libcerror 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCERROR ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | 36 | #else 37 | 38 | /* If libtool DLL support is enabled set LIBCERROR_DLL_IMPORT 39 | * before including libcerror.h 40 | */ 41 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 42 | #define LIBCERROR_DLL_IMPORT 43 | #endif 44 | 45 | #include 46 | 47 | #endif /* defined( HAVE_LOCAL_LIBCERROR ) */ 48 | 49 | #endif /* !defined( _PYVSLVM_LIBCERROR_H ) */ 50 | 51 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_libclocale.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libclocale header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_LIBCLOCALE_H ) 23 | #define _PYVSLVM_LIBCLOCALE_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCLOCALE for local use of libclocale 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCLOCALE ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | 36 | #else 37 | 38 | /* If libtool DLL support is enabled set LIBCLOCALE_DLL_IMPORT 39 | * before including libclocale.h 40 | */ 41 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 42 | #define LIBCLOCALE_DLL_IMPORT 43 | #endif 44 | 45 | #include 46 | 47 | #endif /* defined( HAVE_LOCAL_LIBCLOCALE ) */ 48 | 49 | #endif /* !defined( _PYVSLVM_LIBCLOCALE_H ) */ 50 | 51 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_libvslvm.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The internal libvslvm header 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_LIBVSLVM_H ) 23 | #define _PYVSLVM_LIBVSLVM_H 24 | 25 | #include 26 | 27 | #include 28 | 29 | #endif /* !defined( _PYVSLVM_LIBVSLVM_H ) */ 30 | 31 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_logical_volumes.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Python object definition of the sequence and iterator object of logical volumes 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_LOGICAL_VOLUMES_H ) 23 | #define _PYVSLVM_LOGICAL_VOLUMES_H 24 | 25 | #include 26 | #include 27 | 28 | #include "pyvslvm_libvslvm.h" 29 | #include "pyvslvm_python.h" 30 | 31 | #if defined( __cplusplus ) 32 | extern "C" { 33 | #endif 34 | 35 | typedef struct pyvslvm_logical_volumes pyvslvm_logical_volumes_t; 36 | 37 | struct pyvslvm_logical_volumes 38 | { 39 | /* Python object initialization 40 | */ 41 | PyObject_HEAD 42 | 43 | /* The parent object 44 | */ 45 | PyObject *parent_object; 46 | 47 | /* The get item by index callback function 48 | */ 49 | PyObject* (*get_item_by_index)( 50 | PyObject *parent_object, 51 | int index ); 52 | 53 | /* The current index 54 | */ 55 | int current_index; 56 | 57 | /* The number of items 58 | */ 59 | int number_of_items; 60 | }; 61 | 62 | extern PyTypeObject pyvslvm_logical_volumes_type_object; 63 | 64 | PyObject *pyvslvm_logical_volumes_new( 65 | PyObject *parent_object, 66 | PyObject* (*get_item_by_index)( 67 | PyObject *parent_object, 68 | int index ), 69 | int number_of_items ); 70 | 71 | int pyvslvm_logical_volumes_init( 72 | pyvslvm_logical_volumes_t *sequence_object ); 73 | 74 | void pyvslvm_logical_volumes_free( 75 | pyvslvm_logical_volumes_t *sequence_object ); 76 | 77 | Py_ssize_t pyvslvm_logical_volumes_len( 78 | pyvslvm_logical_volumes_t *sequence_object ); 79 | 80 | PyObject *pyvslvm_logical_volumes_getitem( 81 | pyvslvm_logical_volumes_t *sequence_object, 82 | Py_ssize_t item_index ); 83 | 84 | PyObject *pyvslvm_logical_volumes_iter( 85 | pyvslvm_logical_volumes_t *sequence_object ); 86 | 87 | PyObject *pyvslvm_logical_volumes_iternext( 88 | pyvslvm_logical_volumes_t *sequence_object ); 89 | 90 | #if defined( __cplusplus ) 91 | } 92 | #endif 93 | 94 | #endif /* !defined( _PYVSLVM_LOGICAL_VOLUMES_H ) */ 95 | 96 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_physical_volume.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Python object wrapper of libvslvm_physical_volume_t 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_PHYSICAL_VOLUME_H ) 23 | #define _PYVSLVM_PHYSICAL_VOLUME_H 24 | 25 | #include 26 | #include 27 | 28 | #include "pyvslvm_libvslvm.h" 29 | #include "pyvslvm_python.h" 30 | #include "pyvslvm_volume_group.h" 31 | 32 | #if defined( __cplusplus ) 33 | extern "C" { 34 | #endif 35 | 36 | typedef struct pyvslvm_physical_volume pyvslvm_physical_volume_t; 37 | 38 | struct pyvslvm_physical_volume 39 | { 40 | /* Python object initialization 41 | */ 42 | PyObject_HEAD 43 | 44 | /* The libvslvm physical volume 45 | */ 46 | libvslvm_physical_volume_t *physical_volume; 47 | 48 | /* The pyvslvm volume group object 49 | */ 50 | pyvslvm_volume_group_t *volume_group_object; 51 | }; 52 | 53 | extern PyMethodDef pyvslvm_physical_volume_object_methods[]; 54 | extern PyTypeObject pyvslvm_physical_volume_type_object; 55 | 56 | PyObject *pyvslvm_physical_volume_new( 57 | libvslvm_physical_volume_t *physical_volume, 58 | pyvslvm_volume_group_t *volume_group_object ); 59 | 60 | int pyvslvm_physical_volume_init( 61 | pyvslvm_physical_volume_t *pyvslvm_physical_volume ); 62 | 63 | void pyvslvm_physical_volume_free( 64 | pyvslvm_physical_volume_t *pyvslvm_physical_volume ); 65 | 66 | PyObject *pyvslvm_physical_volume_get_name( 67 | pyvslvm_physical_volume_t *pyvslvm_physical_volume, 68 | PyObject *arguments ); 69 | 70 | PyObject *pyvslvm_physical_volume_get_identifier( 71 | pyvslvm_physical_volume_t *pyvslvm_physical_volume, 72 | PyObject *arguments ); 73 | 74 | PyObject *pyvslvm_physical_volume_get_device_path( 75 | pyvslvm_physical_volume_t *pyvslvm_physical_volume, 76 | PyObject *arguments ); 77 | 78 | PyObject *pyvslvm_physical_volume_get_size( 79 | pyvslvm_physical_volume_t *pyvslvm_physical_volume, 80 | PyObject *arguments ); 81 | 82 | #if defined( __cplusplus ) 83 | } 84 | #endif 85 | 86 | #endif 87 | 88 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_physical_volumes.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Python object definition of the sequence and iterator object of physical volumes 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_PHYSICAL_VOLUMES_H ) 23 | #define _PYVSLVM_PHYSICAL_VOLUMES_H 24 | 25 | #include 26 | #include 27 | 28 | #include "pyvslvm_libvslvm.h" 29 | #include "pyvslvm_python.h" 30 | 31 | #if defined( __cplusplus ) 32 | extern "C" { 33 | #endif 34 | 35 | typedef struct pyvslvm_physical_volumes pyvslvm_physical_volumes_t; 36 | 37 | struct pyvslvm_physical_volumes 38 | { 39 | /* Python object initialization 40 | */ 41 | PyObject_HEAD 42 | 43 | /* The parent object 44 | */ 45 | PyObject *parent_object; 46 | 47 | /* The get item by index callback function 48 | */ 49 | PyObject* (*get_item_by_index)( 50 | PyObject *parent_object, 51 | int index ); 52 | 53 | /* The current index 54 | */ 55 | int current_index; 56 | 57 | /* The number of items 58 | */ 59 | int number_of_items; 60 | }; 61 | 62 | extern PyTypeObject pyvslvm_physical_volumes_type_object; 63 | 64 | PyObject *pyvslvm_physical_volumes_new( 65 | PyObject *parent_object, 66 | PyObject* (*get_item_by_index)( 67 | PyObject *parent_object, 68 | int index ), 69 | int number_of_items ); 70 | 71 | int pyvslvm_physical_volumes_init( 72 | pyvslvm_physical_volumes_t *sequence_object ); 73 | 74 | void pyvslvm_physical_volumes_free( 75 | pyvslvm_physical_volumes_t *sequence_object ); 76 | 77 | Py_ssize_t pyvslvm_physical_volumes_len( 78 | pyvslvm_physical_volumes_t *sequence_object ); 79 | 80 | PyObject *pyvslvm_physical_volumes_getitem( 81 | pyvslvm_physical_volumes_t *sequence_object, 82 | Py_ssize_t item_index ); 83 | 84 | PyObject *pyvslvm_physical_volumes_iter( 85 | pyvslvm_physical_volumes_t *sequence_object ); 86 | 87 | PyObject *pyvslvm_physical_volumes_iternext( 88 | pyvslvm_physical_volumes_t *sequence_object ); 89 | 90 | #if defined( __cplusplus ) 91 | } 92 | #endif 93 | 94 | #endif /* !defined( _PYVSLVM_PHYSICAL_VOLUMES_H ) */ 95 | 96 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_python.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The python header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_PYTHON_H ) 23 | #define _PYVSLVM_PYTHON_H 24 | 25 | #include 26 | 27 | #if PY_MAJOR_VERSION < 3 28 | 29 | /* Fix defines in pyconfig.h 30 | */ 31 | #undef _POSIX_C_SOURCE 32 | #undef _XOPEN_SOURCE 33 | 34 | /* Fix defines in pyport.h 35 | */ 36 | #undef HAVE_FSTAT 37 | #undef HAVE_STAT 38 | #undef HAVE_SSIZE_T 39 | #undef HAVE_INT32_T 40 | #undef HAVE_UINT32_T 41 | #undef HAVE_INT64_T 42 | #undef HAVE_UINT64_T 43 | 44 | #endif /* PY_MAJOR_VERSION < 3 */ 45 | 46 | /* Define PY_SSIZE_T_CLEAN to silence: 47 | * DeprecationWarning: PY_SSIZE_T_CLEAN will be required for '#' formats 48 | * 49 | * PY_SSIZE_T_CLEAN was introduced in Python 2.5 50 | */ 51 | #define PY_SSIZE_T_CLEAN 52 | 53 | #include 54 | 55 | /* Python compatibility macros 56 | */ 57 | #if !defined( PyMODINIT_FUNC ) 58 | #if PY_MAJOR_VERSION >= 3 59 | #define PyMODINIT_FUNC PyObject * 60 | #else 61 | #define PyMODINIT_FUNC void 62 | #endif 63 | #endif /* !defined( PyMODINIT_FUNC ) */ 64 | 65 | #if !defined( PyVarObject_HEAD_INIT ) 66 | #define PyVarObject_HEAD_INIT( type, size ) \ 67 | PyObject_HEAD_INIT( type ) \ 68 | size, 69 | 70 | #endif /* !defined( PyVarObject_HEAD_INIT ) */ 71 | 72 | #if PY_MAJOR_VERSION >= 3 73 | #define Py_TPFLAGS_HAVE_ITER 0 74 | #endif 75 | 76 | #if !defined( Py_TYPE ) 77 | #define Py_TYPE( object ) \ 78 | ( ( (PyObject *) object )->ob_type ) 79 | 80 | #endif /* !defined( Py_TYPE ) */ 81 | 82 | #endif /* !defined( _PYVSLVM_PYTHON_H ) */ 83 | 84 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_segment.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Python object wrapper of libvslvm_segment_t 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_SEGMENT_H ) 23 | #define _PYVSLVM_SEGMENT_H 24 | 25 | #include 26 | #include 27 | 28 | #include "pyvslvm_libvslvm.h" 29 | #include "pyvslvm_logical_volume.h" 30 | #include "pyvslvm_python.h" 31 | 32 | #if defined( __cplusplus ) 33 | extern "C" { 34 | #endif 35 | 36 | typedef struct pyvslvm_segment pyvslvm_segment_t; 37 | 38 | struct pyvslvm_segment 39 | { 40 | /* Python object initialization 41 | */ 42 | PyObject_HEAD 43 | 44 | /* The libvslvm segment 45 | */ 46 | libvslvm_segment_t *segment; 47 | 48 | /* The pyvslvm logical volume object 49 | */ 50 | pyvslvm_logical_volume_t *logical_volume_object; 51 | }; 52 | 53 | extern PyMethodDef pyvslvm_segment_object_methods[]; 54 | extern PyTypeObject pyvslvm_segment_type_object; 55 | 56 | PyObject *pyvslvm_segment_new( 57 | libvslvm_segment_t *segment, 58 | pyvslvm_logical_volume_t *logical_volume_object ); 59 | 60 | int pyvslvm_segment_init( 61 | pyvslvm_segment_t *pyvslvm_segment ); 62 | 63 | void pyvslvm_segment_free( 64 | pyvslvm_segment_t *pyvslvm_segment ); 65 | 66 | #if defined( __cplusplus ) 67 | } 68 | #endif 69 | 70 | #endif 71 | 72 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_segments.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Python object definition of the sequence and iterator object of segments 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_SEGMENTS_H ) 23 | #define _PYVSLVM_SEGMENTS_H 24 | 25 | #include 26 | #include 27 | 28 | #include "pyvslvm_libvslvm.h" 29 | #include "pyvslvm_python.h" 30 | 31 | #if defined( __cplusplus ) 32 | extern "C" { 33 | #endif 34 | 35 | typedef struct pyvslvm_segments pyvslvm_segments_t; 36 | 37 | struct pyvslvm_segments 38 | { 39 | /* Python object initialization 40 | */ 41 | PyObject_HEAD 42 | 43 | /* The parent object 44 | */ 45 | PyObject *parent_object; 46 | 47 | /* The get item by index callback function 48 | */ 49 | PyObject* (*get_item_by_index)( 50 | PyObject *parent_object, 51 | int index ); 52 | 53 | /* The current index 54 | */ 55 | int current_index; 56 | 57 | /* The number of items 58 | */ 59 | int number_of_items; 60 | }; 61 | 62 | extern PyTypeObject pyvslvm_segments_type_object; 63 | 64 | PyObject *pyvslvm_segments_new( 65 | PyObject *parent_object, 66 | PyObject* (*get_item_by_index)( 67 | PyObject *parent_object, 68 | int index ), 69 | int number_of_items ); 70 | 71 | int pyvslvm_segments_init( 72 | pyvslvm_segments_t *sequence_object ); 73 | 74 | void pyvslvm_segments_free( 75 | pyvslvm_segments_t *sequence_object ); 76 | 77 | Py_ssize_t pyvslvm_segments_len( 78 | pyvslvm_segments_t *sequence_object ); 79 | 80 | PyObject *pyvslvm_segments_getitem( 81 | pyvslvm_segments_t *sequence_object, 82 | Py_ssize_t item_index ); 83 | 84 | PyObject *pyvslvm_segments_iter( 85 | pyvslvm_segments_t *sequence_object ); 86 | 87 | PyObject *pyvslvm_segments_iternext( 88 | pyvslvm_segments_t *sequence_object ); 89 | 90 | #if defined( __cplusplus ) 91 | } 92 | #endif 93 | 94 | #endif /* !defined( _PYVSLVM_SEGMENTS_H ) */ 95 | 96 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_stripe.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Python object wrapper of libvslvm_stripe_t 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_STRIPE_H ) 23 | #define _PYVSLVM_STRIPE_H 24 | 25 | #include 26 | #include 27 | 28 | #include "pyvslvm_libvslvm.h" 29 | #include "pyvslvm_python.h" 30 | #include "pyvslvm_segment.h" 31 | 32 | #if defined( __cplusplus ) 33 | extern "C" { 34 | #endif 35 | 36 | typedef struct pyvslvm_stripe pyvslvm_stripe_t; 37 | 38 | struct pyvslvm_stripe 39 | { 40 | /* Python object initialization 41 | */ 42 | PyObject_HEAD 43 | 44 | /* The libvslvm stripe 45 | */ 46 | libvslvm_stripe_t *stripe; 47 | 48 | /* The pyvslvm segment object 49 | */ 50 | pyvslvm_segment_t *segment_object; 51 | }; 52 | 53 | extern PyMethodDef pyvslvm_stripe_object_methods[]; 54 | extern PyTypeObject pyvslvm_stripe_type_object; 55 | 56 | PyObject *pyvslvm_stripe_new( 57 | libvslvm_stripe_t *stripe, 58 | pyvslvm_segment_t *segment_object ); 59 | 60 | int pyvslvm_stripe_init( 61 | pyvslvm_stripe_t *pyvslvm_stripe ); 62 | 63 | void pyvslvm_stripe_free( 64 | pyvslvm_stripe_t *pyvslvm_stripe ); 65 | 66 | #if defined( __cplusplus ) 67 | } 68 | #endif 69 | 70 | #endif 71 | 72 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_stripes.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Python object definition of the sequence and iterator object of stripes 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_STRIPES_H ) 23 | #define _PYVSLVM_STRIPES_H 24 | 25 | #include 26 | #include 27 | 28 | #include "pyvslvm_libvslvm.h" 29 | #include "pyvslvm_python.h" 30 | 31 | #if defined( __cplusplus ) 32 | extern "C" { 33 | #endif 34 | 35 | typedef struct pyvslvm_stripes pyvslvm_stripes_t; 36 | 37 | struct pyvslvm_stripes 38 | { 39 | /* Python object initialization 40 | */ 41 | PyObject_HEAD 42 | 43 | /* The parent object 44 | */ 45 | PyObject *parent_object; 46 | 47 | /* The get item by index callback function 48 | */ 49 | PyObject* (*get_item_by_index)( 50 | PyObject *parent_object, 51 | int index ); 52 | 53 | /* The current index 54 | */ 55 | int current_index; 56 | 57 | /* The number of items 58 | */ 59 | int number_of_items; 60 | }; 61 | 62 | extern PyTypeObject pyvslvm_stripes_type_object; 63 | 64 | PyObject *pyvslvm_stripes_new( 65 | PyObject *parent_object, 66 | PyObject* (*get_item_by_index)( 67 | PyObject *parent_object, 68 | int index ), 69 | int number_of_items ); 70 | 71 | int pyvslvm_stripes_init( 72 | pyvslvm_stripes_t *sequence_object ); 73 | 74 | void pyvslvm_stripes_free( 75 | pyvslvm_stripes_t *sequence_object ); 76 | 77 | Py_ssize_t pyvslvm_stripes_len( 78 | pyvslvm_stripes_t *sequence_object ); 79 | 80 | PyObject *pyvslvm_stripes_getitem( 81 | pyvslvm_stripes_t *sequence_object, 82 | Py_ssize_t item_index ); 83 | 84 | PyObject *pyvslvm_stripes_iter( 85 | pyvslvm_stripes_t *sequence_object ); 86 | 87 | PyObject *pyvslvm_stripes_iternext( 88 | pyvslvm_stripes_t *sequence_object ); 89 | 90 | #if defined( __cplusplus ) 91 | } 92 | #endif 93 | 94 | #endif /* !defined( _PYVSLVM_STRIPES_H ) */ 95 | 96 | -------------------------------------------------------------------------------- /pyvslvm/pyvslvm_unused.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Definitions to silence compiler warnings about unused function attributes/parameters. 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _PYVSLVM_UNUSED_H ) 23 | #define _PYVSLVM_UNUSED_H 24 | 25 | #include 26 | 27 | #if !defined( PYVSLVM_ATTRIBUTE_UNUSED ) 28 | #if defined( __GNUC__ ) && __GNUC__ >= 3 29 | #define PYVSLVM_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 30 | #else 31 | #define PYVSLVM_ATTRIBUTE_UNUSED 32 | #endif 33 | #endif 34 | 35 | #if defined( _MSC_VER ) 36 | #define PYVSLVM_UNREFERENCED_PARAMETER( parameter ) \ 37 | UNREFERENCED_PARAMETER( parameter ); 38 | #else 39 | #define PYVSLVM_UNREFERENCED_PARAMETER( parameter ) \ 40 | /* parameter */ 41 | #endif 42 | 43 | #endif /* !defined( _PYVSLVM_UNUSED_H ) */ 44 | 45 | -------------------------------------------------------------------------------- /runtests.ps1: -------------------------------------------------------------------------------- 1 | # Script that runs the tests 2 | # 3 | # Version: 20220103 4 | 5 | $ExitSuccess = 0 6 | $ExitFailure = 1 7 | $ExitIgnore = 77 8 | 9 | Set-Location -Path "tests" 10 | 11 | $Result = ${ExitSuccess} 12 | 13 | $Lines = Get-Content "Makefile.am" 14 | $InTests = $FALSE 15 | 16 | Foreach (${Line} in ${Lines}) 17 | { 18 | If (${InTests}) 19 | { 20 | If (-Not ${Line}) 21 | { 22 | ${InTests} = $FALSE 23 | 24 | Continue 25 | } 26 | ${Line} = ${Line}.TrimStart() 27 | 28 | If (${Line}.EndsWith(" \")) 29 | { 30 | ${Line} = ${Line}.Substring(0, ${Line}.Length - 2) 31 | } 32 | If (-Not (${Line}.EndsWith(".sh"))) 33 | { 34 | Continue 35 | } 36 | ${Line} = ${Line}.Substring(0, ${Line}.Length - 3) 37 | ${Line} = ".\${Line}.ps1" 38 | 39 | Try 40 | { 41 | Invoke-Expression ${Line} 42 | } 43 | Catch 44 | { 45 | $LastExitCode = ${ExitIgnore} 46 | } 47 | If (${LastExitCode} -eq ${ExitFailure}) 48 | { 49 | $Result = ${ExitFailure} 50 | Write-Host "FAIL" -foreground Red -nonewline 51 | } 52 | ElseIf (${LastExitCode} -eq ${ExitIgnore}) 53 | { 54 | Write-Host "SKIP" -foreground Cyan -nonewline 55 | } 56 | Else 57 | { 58 | Write-Host "PASS" -foreground Green -nonewline 59 | } 60 | Write-Host ": ${Line}" 61 | } 62 | ElseIf (${Line}.StartsWith("TESTS = ")) 63 | { 64 | ${InTests} = $TRUE 65 | } 66 | } 67 | 68 | Set-Location -Path ".." 69 | 70 | Exit ${Result} 71 | -------------------------------------------------------------------------------- /setup.cfg.in: -------------------------------------------------------------------------------- 1 | [metadata] 2 | name = libvslvm-python 3 | version = @VERSION@ 4 | description = Python bindings module for libvslvm 5 | long_description = Python bindings module for libvslvm 6 | long_description_content_type = text/plain 7 | author = Joachim Metz 8 | author_email = joachim.metz@gmail.com 9 | license = GNU Lesser General Public License v3 or later (LGPLv3+) 10 | license_files = COPYING COPYING.LESSER 11 | classifiers = 12 | Development Status :: 2 - Pre-Alpha 13 | Programming Language :: Python 14 | 15 | [options] 16 | python_requires = >=3.7 17 | -------------------------------------------------------------------------------- /syncdokan.ps1: -------------------------------------------------------------------------------- 1 | # Script that synchronizes dokan 2 | # 3 | # Version: 20190810 4 | 5 | Param ( 6 | [switch]$UseHead = $false, 7 | [switch]$UseLegacyVersion = $false 8 | ) 9 | 10 | $Git = "git" 11 | 12 | If (${UseLegacyVersion}) 13 | { 14 | # Patched version of dokan 0.6.0 15 | $GitUrl = "https://github.com/joachimmetz/dokan.git" 16 | $Destination = "..\dokan" 17 | } 18 | Else 19 | { 20 | $GitUrl = "https://github.com/dokan-dev/dokany.git" 21 | $Destination = "..\dokany" 22 | } 23 | 24 | # PowerShell will raise NativeCommandError if git writes to stdout or stderr 25 | # therefore 2>&1 is added and the output is stored in a variable. 26 | $Output = Invoke-Expression -Command "${Git} clone ${GitUrl} ${Destination} 2>&1" 27 | 28 | Push-Location ${Destination} 29 | 30 | Try 31 | { 32 | $Output = Invoke-Expression -Command "${Git} fetch --quiet --all --tags --prune 2>&1" 33 | 34 | $LatestTag = Invoke-Expression -Command "${Git} describe --tags --abbrev=0 2>&1" 35 | 36 | If (${LatestTag} -and -not ${UseHead}) 37 | { 38 | Write-Host "Synchronizing: dokan from ${GitUrl} tag ${LatestTag}" 39 | 40 | $Output = Invoke-Expression -Command "${Git} checkout --quiet tags/${LatestTag} 2>&1" 41 | } 42 | Else 43 | { 44 | Write-Host "Synchronizing: dokan from ${GitUrl} HEAD" 45 | } 46 | If (-Not ${UseLegacyVersion}) 47 | { 48 | # AppVeyor does not come with platform toolset version 142 49 | ((Get-Content -Path "..\dokany\dokan\dokan.vcxproj" -Raw) -Replace 'v142','v141') | Set-Content -Path "..\dokany\dokan\dokan.vcxproj" 50 | } 51 | } 52 | Finally 53 | { 54 | Pop-Location 55 | } 56 | 57 | -------------------------------------------------------------------------------- /synctestdata.ps1: -------------------------------------------------------------------------------- 1 | # Script that synchronizes the local test data 2 | # 3 | # Version: 20230709 4 | 5 | $TestSet = "public" 6 | $TestInputDirectory = "tests/input" 7 | $TestFiles = "lvm.raw" 8 | 9 | If (-Not (Test-Path ${TestInputDirectory})) 10 | { 11 | New-Item -Name ${TestInputDirectory} -ItemType "directory" | Out-Null 12 | } 13 | If (-Not (Test-Path "${TestInputDirectory}\${TestSet}")) 14 | { 15 | New-Item -Name "${TestInputDirectory}\${TestSet}" -ItemType "directory" | Out-Null 16 | } 17 | ForEach ($TestFile in ${TestFiles} -split " ") 18 | { 19 | $Url = "https://github.com/log2timeline/dfvfs/blob/main/test_data/${TestFile}?raw=true" 20 | 21 | Invoke-WebRequest -Uri ${Url} -OutFile "${TestInputDirectory}\${TestSet}\${TestFile}" 22 | } 23 | 24 | -------------------------------------------------------------------------------- /synctestdata.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | # Script that synchronizes the local test data 3 | # 4 | # Version: 20161009 5 | 6 | TEST_SET="public"; 7 | TEST_INPUT_DIRECTORY="tests/input"; 8 | TEST_FILES="lvm.raw"; 9 | 10 | mkdir -p "${TEST_INPUT_DIRECTORY}/${TEST_SET}"; 11 | 12 | for TEST_FILE in ${TEST_FILES}; 13 | do 14 | URL="https://github.com/log2timeline/dfvfs/blob/main/test_data/${TEST_FILE}?raw=true"; 15 | 16 | curl -L -o "${TEST_INPUT_DIRECTORY}/${TEST_SET}/${TEST_FILE}" ${URL}; 17 | done 18 | 19 | -------------------------------------------------------------------------------- /tests/build.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | # Script to build from source 3 | # 4 | # Version: 20201121 5 | 6 | set -e 7 | 8 | ./synclibs.sh --use-head 9 | ./autogen.sh 10 | ./configure "$@" 11 | make > /dev/null 12 | 13 | -------------------------------------------------------------------------------- /tests/data/metadata_area.1: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/libyal/libvslvm/19ea14299e45d066f3eeb9c3ff2be2887b9836ed/tests/data/metadata_area.1 -------------------------------------------------------------------------------- /tests/data/physical_volume_header.1: -------------------------------------------------------------------------------- 1 | btEzLai0aLsfS8Ae9PQKGUIhtACkpWm7 -------------------------------------------------------------------------------- /tests/data/physical_volume_label.1: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/libyal/libvslvm/19ea14299e45d066f3eeb9c3ff2be2887b9836ed/tests/data/physical_volume_label.1 -------------------------------------------------------------------------------- /tests/data/raw_location_descriptor.1: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/lsan.suppressions: -------------------------------------------------------------------------------- 1 | leak:/lib*/libpython* 2 | -------------------------------------------------------------------------------- /tests/pkgbuild.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | # Script to build a MacOS pkg 3 | # 4 | # Version: 20201121 5 | 6 | set -e 7 | 8 | make install DESTDIR=${PWD}/osx-pkg 9 | mkdir -p ${PWD}/osx-pkg/usr/share/doc/libvslvm 10 | cp AUTHORS COPYING COPYING.LESSER NEWS README ${PWD}/osx-pkg/usr/share/doc/libvslvm 11 | 12 | VERSION=`sed '5!d; s/^ \[//;s/\],$//' configure.ac` 13 | pkgbuild --root osx-pkg --identifier com.github.libyal.libvslvm --version ${VERSION} --ownership recommended ../libvslvm-${VERSION}.pkg 14 | 15 | -------------------------------------------------------------------------------- /tests/runtests.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # 3 | # Script to run Python test scripts. 4 | # 5 | # Version: 20231024 6 | 7 | import glob 8 | import os 9 | import sys 10 | import unittest 11 | 12 | 13 | test_profile = ".pyvslvm" 14 | input_glob = "*" 15 | option_sets = [] 16 | 17 | 18 | def ReadIgnoreList(test_profile): 19 | """Reads the test profile ignore file if it exists. 20 | 21 | Args: 22 | test_profile (str): test profile. 23 | 24 | Returns: 25 | set[str]: ignore list. 26 | """ 27 | ignore_file_path = os.path.join("tests", "input", test_profile, "ignore") 28 | if os.path.isfile(ignore_file_path): 29 | with open(ignore_file_path, "r", encoding="utf-8") as file_object: 30 | return set([line.strip() for line in file_object.readlines()]) 31 | 32 | return set() 33 | 34 | 35 | if __name__ == "__main__": 36 | print(f"Using Python version {sys.version!s}") 37 | 38 | test_loader = unittest.TestLoader() 39 | test_runner = unittest.TextTestRunner(verbosity=2) 40 | 41 | test_scripts = test_loader.discover("tests", pattern="*.py") 42 | 43 | ignore_list = ReadIgnoreList(test_profile) 44 | 45 | test_set = None 46 | source_file = None 47 | 48 | for test_set in glob.glob(os.path.join("tests", "input", "*")): 49 | test_set = test_set.rsplit(os.path.sep, maxsplit=1)[-1] 50 | if not test_set or test_set[0] == '.' or test_set in ignore_list: 51 | continue 52 | 53 | source_files = glob.glob(os.path.join( 54 | "tests", "input", test_set, input_glob)) 55 | if source_files: 56 | source_file = source_files[0] 57 | break 58 | 59 | setattr(unittest, "source", source_file) 60 | 61 | if source_file: 62 | for option_set in option_sets: 63 | test_file = os.path.basename(source_file) 64 | test_options_file_path = os.path.join( 65 | "tests", "input", test_profile, test_set, 66 | f"{test_file:s}.{option_set:s}") 67 | if os.path.isfile(test_options_file_path): 68 | with open(test_options_file_path, "r", encoding="utf-8") as file_object: 69 | lines = [line.strip() for line in file_object.readlines()] 70 | if lines[0] == "# libyal test data options": 71 | for line in lines[1:]: 72 | key, value = line.split("=", maxsplit=1) 73 | if key == 'offset': 74 | value = int(value) 75 | 76 | setattr(unittest, key, value) 77 | 78 | test_results = test_runner.run(test_scripts) 79 | if not test_results.wasSuccessful(): 80 | sys.exit(1) 81 | -------------------------------------------------------------------------------- /tests/runtests.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | # Script to run tests 3 | # 4 | # Version: 20201121 5 | 6 | if test -f ${PWD}/libvslvm/.libs/libvslvm.1.dylib && test -f ./pyvslvm/.libs/pyvslvm.so; 7 | then 8 | install_name_tool -change /usr/local/lib/libvslvm.1.dylib ${PWD}/libvslvm/.libs/libvslvm.1.dylib ./pyvslvm/.libs/pyvslvm.so; 9 | fi 10 | 11 | make check CHECK_WITH_STDERR=1; 12 | RESULT=$?; 13 | 14 | if test ${RESULT} -ne 0 && test -f tests/test-suite.log; 15 | then 16 | cat tests/test-suite.log; 17 | fi 18 | exit ${RESULT}; 19 | 20 | -------------------------------------------------------------------------------- /tests/syncsharedlibs.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | # Script that synchronizes the shared library dependencies 3 | # 4 | # Version: 20201121 5 | 6 | EXIT_SUCCESS=0; 7 | EXIT_FAILURE=1; 8 | 9 | GIT_URL_PREFIX="https://github.com/libyal"; 10 | SHARED_LIBS="libcerror libcthreads libcdata libclocale libcnotify libcsplit libuna libcfile libcpath libbfio libfcache libfdata libfvalue"; 11 | 12 | USE_HEAD=""; 13 | 14 | if test "$1" = "--use-head"; 15 | then 16 | USE_HEAD="--use-head"; 17 | fi 18 | 19 | OLDIFS=$IFS; 20 | IFS=" "; 21 | 22 | for SHARED_LIB in ${SHARED_LIBS}; 23 | do 24 | GIT_URL="${GIT_URL_PREFIX}/${SHARED_LIB}.git"; 25 | 26 | git clone --quiet ${GIT_URL} ${SHARED_LIB}-$$; 27 | 28 | if ! test -d ${SHARED_LIB}-$$; 29 | then 30 | echo "Unable to git clone: ${GIT_URL}"; 31 | 32 | IFS=$OLDIFS; 33 | 34 | exit ${EXIT_FAILURE}; 35 | fi 36 | (cd ${SHARED_LIB}-$$ && git fetch --quiet --all --tags --prune) 37 | 38 | LATEST_TAG=`cd ${SHARED_LIB}-$$ && git describe --tags --abbrev=0`; 39 | 40 | if test -n ${LATEST_TAG} && test -z ${USE_HEAD}; 41 | then 42 | echo "Synchronizing: ${SHARED_LIB} from ${GIT_URL} tag ${LATEST_TAG}"; 43 | 44 | (cd ${SHARED_LIB}-$$ && git checkout --quiet tags/${LATEST_TAG}); 45 | else 46 | echo "Synchronizing: ${SHARED_LIB} from ${GIT_URL} HEAD"; 47 | fi 48 | 49 | (cd ${SHARED_LIB}-$$ && ./synclibs.sh ${USE_HEAD} && ./autogen.sh); 50 | 51 | CONFIGURE_OPTIONS=""; 52 | 53 | (cd ${SHARED_LIB}-$$ && ./configure --help | grep -- '--enable-wide-character-type' > /dev/null); 54 | 55 | if test $? -eq 0; 56 | then 57 | CONFIGURE_OPTIONS="${CONFIGURE_OPTIONS} --enable-wide-character-type"; 58 | fi 59 | 60 | (cd ${SHARED_LIB}-$$ && ./configure --prefix=/usr ${CONFIGURE_OPTIONS} && make && sudo make install); 61 | 62 | rm -rf ${SHARED_LIB}-$$; 63 | done 64 | 65 | IFS=$OLDIFS; 66 | 67 | exit ${EXIT_SUCCESS}; 68 | 69 | -------------------------------------------------------------------------------- /tests/test_manpage.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Tests man pages. 3 | # 4 | # Version: 20240413 5 | 6 | EXIT_SUCCESS=0; 7 | EXIT_FAILURE=1; 8 | EXIT_IGNORE=77; 9 | 10 | run_test() 11 | { 12 | local INPUT_FILE=$1; 13 | local RESULT=0 14 | 15 | TEST_NAME=`basename ${INPUT_FILE}`; 16 | echo -n "Testing man with input: ${TEST_NAME}"; 17 | 18 | LC_ALL=en_US.UTF-8 MANROFFSEQ='' MANWIDTH=80 man --warnings -E UTF-8 -l -Tutf8 -Z ${INPUT_FILE} > /dev/null 2> ${TMPDIR}/${TEST_NAME}.warnings; 19 | RESULT=$?; 20 | 21 | # For now line break warnings are ignored. 22 | if test -f ${TMPDIR}/${TEST_NAME}.warnings; 23 | then 24 | sed "/can't break line/ d" -i ${TMPDIR}/${TEST_NAME}.warnings; 25 | fi 26 | if test -s ${TMPDIR}/${TEST_NAME}.warnings; 27 | then 28 | RESULT=${EXIT_FAILURE}; 29 | fi 30 | if test ${RESULT} -ne ${EXIT_SUCCESS}; 31 | then 32 | echo " (FAIL)"; 33 | else 34 | echo " (PASS)"; 35 | fi 36 | if test -s ${TMPDIR}/${TEST_NAME}.warnings; 37 | then 38 | cat ${TMPDIR}/${TEST_NAME}.warnings; 39 | fi 40 | return ${RESULT}; 41 | } 42 | 43 | if test "${OSTYPE}" = "msys"; 44 | then 45 | exit ${EXIT_IGNORE}; 46 | fi 47 | 48 | TEST_DIRECTORY=`dirname $0`; 49 | 50 | TEST_RUNNER="${TEST_DIRECTORY}/test_runner.sh"; 51 | 52 | if ! test -f "${TEST_RUNNER}"; 53 | then 54 | echo "Missing test runner: ${TEST_RUNNER}"; 55 | 56 | exit ${EXIT_FAILURE}; 57 | fi 58 | 59 | source ${TEST_RUNNER}; 60 | 61 | assert_availability_binary man; 62 | 63 | RESULT=${EXIT_IGNORE}; 64 | 65 | TMPDIR="tmp$$"; 66 | 67 | rm -rf ${TMPDIR}; 68 | mkdir ${TMPDIR}; 69 | 70 | MANUALS_PATH="../manuals"; 71 | 72 | if ! test -d ${MANUALS_PATH}; 73 | then 74 | MANUALS_PATH="manuals"; 75 | fi 76 | 77 | if ! test -d ${MANUALS_PATH}; 78 | then 79 | echo "Manuals directory not found."; 80 | 81 | exit ${EXIT_IGNORE}; 82 | fi 83 | 84 | for INPUT_FILE in ${MANUALS_PATH}/*.[13]; 85 | do 86 | run_test "${INPUT_FILE}"; 87 | RESULT=$?; 88 | 89 | if test ${RESULT} -ne ${EXIT_SUCCESS}; 90 | then 91 | break; 92 | fi 93 | done 94 | 95 | rm -rf ${TMPDIR}; 96 | 97 | exit ${RESULT}; 98 | 99 | -------------------------------------------------------------------------------- /tests/vslvm_test_functions.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Functions for testing 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVM_TEST_FUNCTIONS_H ) 23 | #define _VSLVM_TEST_FUNCTIONS_H 24 | 25 | #include 26 | #include 27 | 28 | #include "vslvm_test_libbfio.h" 29 | #include "vslvm_test_libcerror.h" 30 | 31 | #if defined( __cplusplus ) 32 | extern "C" { 33 | #endif 34 | 35 | int vslvm_test_get_narrow_source( 36 | const system_character_t *source, 37 | char *narrow_string, 38 | size_t narrow_string_size, 39 | libcerror_error_t **error ); 40 | 41 | #if defined( HAVE_WIDE_CHARACTER_TYPE ) 42 | 43 | int vslvm_test_get_wide_source( 44 | const system_character_t *source, 45 | wchar_t *wide_string, 46 | size_t wide_string_size, 47 | libcerror_error_t **error ); 48 | 49 | #endif /* defined( HAVE_WIDE_CHARACTER_TYPE ) */ 50 | 51 | int vslvm_test_open_file_io_handle( 52 | libbfio_handle_t **file_io_handle, 53 | uint8_t *data, 54 | size_t data_size, 55 | libcerror_error_t **error ); 56 | 57 | int vslvm_test_close_file_io_handle( 58 | libbfio_handle_t **file_io_handle, 59 | libcerror_error_t **error ); 60 | 61 | #if defined( __cplusplus ) 62 | } 63 | #endif 64 | 65 | #endif /* !defined( _VSLVM_TEST_FUNCTIONS_H ) */ 66 | 67 | -------------------------------------------------------------------------------- /tests/vslvm_test_getopt.h: -------------------------------------------------------------------------------- 1 | /* 2 | * GetOpt functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVM_TEST_GETOPT_H ) 23 | #define _VSLVM_TEST_GETOPT_H 24 | 25 | #include 26 | #include 27 | 28 | /* unistd.h is included here to export getopt, optarg, optind and optopt 29 | */ 30 | #if defined( HAVE_UNISTD_H ) 31 | #include 32 | #endif 33 | 34 | #if defined( __cplusplus ) 35 | extern "C" { 36 | #endif 37 | 38 | #if defined( HAVE_GETOPT ) 39 | #define vslvm_test_getopt( argument_count, argument_values, options_string ) \ 40 | getopt( argument_count, argument_values, options_string ) 41 | 42 | #else 43 | 44 | #if !defined( __CYGWIN__ ) 45 | extern int optind; 46 | extern system_character_t *optarg; 47 | extern system_integer_t optopt; 48 | 49 | #else 50 | int optind; 51 | system_character_t *optarg; 52 | system_integer_t optopt; 53 | 54 | #endif /* !defined( __CYGWIN__ ) */ 55 | 56 | system_integer_t vslvm_test_getopt( 57 | int argument_count, 58 | system_character_t * const argument_values[], 59 | const system_character_t *options_string ); 60 | 61 | #endif /* defined( HAVE_GETOPT ) */ 62 | 63 | #if defined( __cplusplus ) 64 | } 65 | #endif 66 | 67 | #endif /* !defined( _VSLVM_TEST_GETOPT_H ) */ 68 | 69 | -------------------------------------------------------------------------------- /tests/vslvm_test_libbfio.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libbfio header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVM_TEST_LIBBFIO_H ) 23 | #define _VSLVM_TEST_LIBBFIO_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBBFIO for local use of libbfio 28 | */ 29 | #if defined( HAVE_LOCAL_LIBBFIO ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | 40 | #else 41 | 42 | /* If libtool DLL support is enabled set LIBBFIO_DLL_IMPORT 43 | * before including libbfio.h 44 | */ 45 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 46 | #define LIBBFIO_DLL_IMPORT 47 | #endif 48 | 49 | #include 50 | 51 | #if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( LIBBFIO_HAVE_MULTI_THREAD_SUPPORT ) 52 | #error Multi-threading support requires libbfio with multi-threading support 53 | #endif 54 | 55 | #endif /* defined( HAVE_LOCAL_LIBBFIO ) */ 56 | 57 | #endif /* !defined( _VSLVM_TEST_LIBBFIO_H ) */ 58 | 59 | -------------------------------------------------------------------------------- /tests/vslvm_test_libcerror.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libcerror header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVM_TEST_LIBCERROR_H ) 23 | #define _VSLVM_TEST_LIBCERROR_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCERROR for local use of libcerror 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCERROR ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | 36 | #else 37 | 38 | /* If libtool DLL support is enabled set LIBCERROR_DLL_IMPORT 39 | * before including libcerror.h 40 | */ 41 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 42 | #define LIBCERROR_DLL_IMPORT 43 | #endif 44 | 45 | #include 46 | 47 | #endif /* defined( HAVE_LOCAL_LIBCERROR ) */ 48 | 49 | #endif /* !defined( _VSLVM_TEST_LIBCERROR_H ) */ 50 | 51 | -------------------------------------------------------------------------------- /tests/vslvm_test_libclocale.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libclocale header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVM_TEST_LIBCLOCALE_H ) 23 | #define _VSLVM_TEST_LIBCLOCALE_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCLOCALE for local use of libclocale 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCLOCALE ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | 36 | #else 37 | 38 | /* If libtool DLL support is enabled set LIBCLOCALE_DLL_IMPORT 39 | * before including libclocale.h 40 | */ 41 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 42 | #define LIBCLOCALE_DLL_IMPORT 43 | #endif 44 | 45 | #include 46 | 47 | #endif /* defined( HAVE_LOCAL_LIBCLOCALE ) */ 48 | 49 | #endif /* !defined( _VSLVM_TEST_LIBCLOCALE_H ) */ 50 | 51 | -------------------------------------------------------------------------------- /tests/vslvm_test_libcnotify.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libcnotify header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVM_TEST_LIBCNOTIFY_H ) 23 | #define _VSLVM_TEST_LIBCNOTIFY_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCNOTIFY for local use of libcnotify 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCNOTIFY ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | 36 | #else 37 | 38 | /* If libtool DLL support is enabled set LIBCNOTIFY_DLL_IMPORT 39 | * before including libcnotify.h 40 | */ 41 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 42 | #define LIBCNOTIFY_DLL_IMPORT 43 | #endif 44 | 45 | #include 46 | 47 | #endif /* defined( HAVE_LOCAL_LIBCNOTIFY ) */ 48 | 49 | #endif /* !defined( _VSLVM_TEST_LIBCNOTIFY_H ) */ 50 | 51 | -------------------------------------------------------------------------------- /tests/vslvm_test_libuna.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libuna header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVM_TEST_LIBUNA_H ) 23 | #define _VSLVM_TEST_LIBUNA_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBUNA for local use of libuna 28 | */ 29 | #if defined( HAVE_LOCAL_LIBUNA ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | #include 40 | #include 41 | #include 42 | #include 43 | #include 44 | #include 45 | 46 | #else 47 | 48 | /* If libtool DLL support is enabled set LIBUNA_DLL_IMPORT 49 | * before including libuna.h 50 | */ 51 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 52 | #define LIBUNA_DLL_IMPORT 53 | #endif 54 | 55 | #include 56 | 57 | #endif /* defined( HAVE_LOCAL_LIBUNA ) */ 58 | 59 | #endif /* !defined( _VSLVM_TEST_LIBUNA_H ) */ 60 | 61 | -------------------------------------------------------------------------------- /tests/vslvm_test_libvslvm.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libvslvm header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVM_TEST_LIBVSLVM_H ) 23 | #define _VSLVM_TEST_LIBVSLVM_H 24 | 25 | #include 26 | 27 | #include 28 | 29 | #endif /* !defined( _VSLVM_TEST_LIBVSLVM_H ) */ 30 | 31 | -------------------------------------------------------------------------------- /tests/vslvm_test_memory.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Memory allocation functions for testing 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVM_TEST_MEMORY_H ) 23 | #define _VSLVM_TEST_MEMORY_H 24 | 25 | #include 26 | 27 | #if defined( __cplusplus ) 28 | extern "C" { 29 | #endif 30 | 31 | #if defined( HAVE_GNU_DL_DLSYM ) && defined( __GNUC__ ) && !defined( LIBVSLVM_DLL_IMPORT ) && !defined( __arm__ ) && !defined( __clang__ ) && !defined( __CYGWIN__ ) && !defined( __hppa__ ) && !defined( __loongarch__ ) && !defined( __mips__ ) && !defined( __riscv ) && !defined( __sparc__ ) && !defined( HAVE_ASAN ) 32 | #define HAVE_VSLVM_TEST_MEMORY 1 33 | #endif 34 | 35 | #if defined( HAVE_VSLVM_TEST_MEMORY ) 36 | 37 | extern int vslvm_test_malloc_attempts_before_fail; 38 | 39 | extern int vslvm_test_memcpy_attempts_before_fail; 40 | 41 | extern int vslvm_test_memset_attempts_before_fail; 42 | 43 | extern int vslvm_test_realloc_attempts_before_fail; 44 | 45 | #endif /* defined( HAVE_VSLVM_TEST_MEMORY ) */ 46 | 47 | #if defined( __cplusplus ) 48 | } 49 | #endif 50 | 51 | #endif /* !defined( _VSLVM_TEST_MEMORY_H ) */ 52 | 53 | -------------------------------------------------------------------------------- /tests/vslvm_test_tools_output.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Tools output functions test program 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #include 23 | #include 24 | #include 25 | 26 | #include 27 | 28 | #if defined( HAVE_IO_H ) || defined( WINAPI ) 29 | #include 30 | #endif 31 | 32 | #if defined( HAVE_STDLIB_H ) || defined( WINAPI ) 33 | #include 34 | #endif 35 | 36 | #include "vslvm_test_libcerror.h" 37 | #include "vslvm_test_macros.h" 38 | #include "vslvm_test_unused.h" 39 | 40 | #include "../vslvmtools/vslvmtools_output.h" 41 | 42 | /* Tests the vslvmtools_output_initialize function 43 | * Returns 1 if successful or 0 if not 44 | */ 45 | int vslvm_test_tools_output_initialize( 46 | void ) 47 | { 48 | libcerror_error_t *error = NULL; 49 | int result = 0; 50 | 51 | result = vslvmtools_output_initialize( 52 | _IONBF, 53 | &error ); 54 | 55 | VSLVM_TEST_ASSERT_EQUAL_INT( 56 | "result", 57 | result, 58 | 1 ); 59 | 60 | VSLVM_TEST_ASSERT_IS_NULL( 61 | "error", 62 | error ); 63 | 64 | return( 1 ); 65 | 66 | on_error: 67 | if( error != NULL ) 68 | { 69 | libcerror_error_free( 70 | &error ); 71 | } 72 | return( 0 ); 73 | } 74 | 75 | /* The main program 76 | */ 77 | #if defined( HAVE_WIDE_SYSTEM_CHARACTER ) 78 | int wmain( 79 | int argc VSLVM_TEST_ATTRIBUTE_UNUSED, 80 | wchar_t * const argv[] VSLVM_TEST_ATTRIBUTE_UNUSED ) 81 | #else 82 | int main( 83 | int argc VSLVM_TEST_ATTRIBUTE_UNUSED, 84 | char * const argv[] VSLVM_TEST_ATTRIBUTE_UNUSED ) 85 | #endif 86 | { 87 | VSLVM_TEST_UNREFERENCED_PARAMETER( argc ) 88 | VSLVM_TEST_UNREFERENCED_PARAMETER( argv ) 89 | 90 | VSLVM_TEST_RUN( 91 | "vslvmtools_output_initialize", 92 | vslvm_test_tools_output_initialize ) 93 | 94 | /* TODO add tests for vslvmtools_output_copyright_fprint */ 95 | 96 | /* TODO add tests for vslvmtools_output_version_fprint */ 97 | 98 | /* TODO add tests for vslvmtools_output_version_detailed_fprint */ 99 | 100 | return( EXIT_SUCCESS ); 101 | 102 | on_error: 103 | return( EXIT_FAILURE ); 104 | } 105 | 106 | -------------------------------------------------------------------------------- /tests/vslvm_test_unused.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Definitions to silence compiler warnings about unused function attributes/parameters. 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVM_TEST_UNUSED_H ) 23 | #define _VSLVM_TEST_UNUSED_H 24 | 25 | #include 26 | 27 | #if !defined( VSLVM_TEST_ATTRIBUTE_UNUSED ) 28 | 29 | #if defined( __GNUC__ ) && __GNUC__ >= 3 30 | #define VSLVM_TEST_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 31 | 32 | #else 33 | #define VSLVM_TEST_ATTRIBUTE_UNUSED 34 | 35 | #endif /* defined( __GNUC__ ) && __GNUC__ >= 3 */ 36 | 37 | #endif /* !defined( VSLVM_TEST_ATTRIBUTE_UNUSED ) */ 38 | 39 | #if defined( _MSC_VER ) 40 | #define VSLVM_TEST_UNREFERENCED_PARAMETER( parameter ) \ 41 | UNREFERENCED_PARAMETER( parameter ); 42 | 43 | #else 44 | #define VSLVM_TEST_UNREFERENCED_PARAMETER( parameter ) \ 45 | /* parameter */ 46 | 47 | #endif /* defined( _MSC_VER ) */ 48 | 49 | #endif /* !defined( _VSLVM_TEST_UNUSED_H ) */ 50 | 51 | -------------------------------------------------------------------------------- /tox.ini: -------------------------------------------------------------------------------- 1 | [tox] 2 | envlist = auditwheel,py3{7,8,9,10,11,12} 3 | 4 | [testenv] 5 | usedevelop = True 6 | pip_pre = True 7 | passenv = 8 | CFLAGS 9 | CPPFLAGS 10 | INCLUDE 11 | LDFLAGS 12 | LIB 13 | deps = 14 | build 15 | setuptools >= 65 16 | wheel 17 | commands = 18 | python -m build --no-isolation --outdir=dist --wheel 19 | python -m pip install --no-index --find-links=dist libvslvm-python 20 | python tests/runtests.py 21 | 22 | [testenv:auditwheel] 23 | usedevelop = True 24 | pip_pre = True 25 | deps = 26 | auditwheel 27 | setuptools >= 65 28 | commands = 29 | python -m auditwheel repair {posargs} 30 | -------------------------------------------------------------------------------- /vslvmtools/Makefile.am: -------------------------------------------------------------------------------- 1 | AM_CPPFLAGS = \ 2 | -I../include -I$(top_srcdir)/include \ 3 | -I../common -I$(top_srcdir)/common \ 4 | @LIBCERROR_CPPFLAGS@ \ 5 | @LIBCDATA_CPPFLAGS@ \ 6 | @LIBCLOCALE_CPPFLAGS@ \ 7 | @LIBCNOTIFY_CPPFLAGS@ \ 8 | @LIBCSPLIT_CPPFLAGS@ \ 9 | @LIBUNA_CPPFLAGS@ \ 10 | @LIBCFILE_CPPFLAGS@ \ 11 | @LIBCPATH_CPPFLAGS@ \ 12 | @LIBBFIO_CPPFLAGS@ \ 13 | @LIBFUSE_CPPFLAGS@ \ 14 | @LIBVSLVM_DLL_IMPORT@ 15 | 16 | AM_LDFLAGS = @STATIC_LDFLAGS@ 17 | 18 | bin_PROGRAMS = \ 19 | vslvminfo \ 20 | vslvmmount 21 | 22 | vslvminfo_SOURCES = \ 23 | byte_size_string.c byte_size_string.h \ 24 | info_handle.c info_handle.h \ 25 | vslvminfo.c \ 26 | vslvmtools_getopt.c vslvmtools_getopt.h \ 27 | vslvmtools_i18n.h \ 28 | vslvmtools_libbfio.h \ 29 | vslvmtools_libcerror.h \ 30 | vslvmtools_libclocale.h \ 31 | vslvmtools_libcnotify.h \ 32 | vslvmtools_libvslvm.h \ 33 | vslvmtools_libuna.h \ 34 | vslvmtools_output.c vslvmtools_output.h \ 35 | vslvmtools_signal.c vslvmtools_signal.h \ 36 | vslvmtools_unused.h 37 | 38 | vslvminfo_LDADD = \ 39 | @LIBBFIO_LIBADD@ \ 40 | @LIBCPATH_LIBADD@ \ 41 | @LIBCFILE_LIBADD@ \ 42 | @LIBUNA_LIBADD@ \ 43 | @LIBCSPLIT_LIBADD@ \ 44 | @LIBCDATA_LIBADD@ \ 45 | @LIBCNOTIFY_LIBADD@ \ 46 | @LIBCLOCALE_LIBADD@ \ 47 | ../libvslvm/libvslvm.la \ 48 | @LIBCERROR_LIBADD@ \ 49 | @LIBINTL@ 50 | 51 | vslvmmount_SOURCES = \ 52 | mount_dokan.c mount_dokan.h \ 53 | mount_file_entry.c mount_file_entry.h \ 54 | mount_file_system.c mount_file_system.h \ 55 | mount_fuse.c mount_fuse.h \ 56 | mount_handle.c mount_handle.h \ 57 | vslvmmount.c \ 58 | vslvmtools_getopt.c vslvmtools_getopt.h \ 59 | vslvmtools_i18n.h \ 60 | vslvmtools_libbfio.h \ 61 | vslvmtools_libcdata.h \ 62 | vslvmtools_libcerror.h \ 63 | vslvmtools_libclocale.h \ 64 | vslvmtools_libcnotify.h \ 65 | vslvmtools_libcpath.h \ 66 | vslvmtools_libvslvm.h \ 67 | vslvmtools_libuna.h \ 68 | vslvmtools_output.c vslvmtools_output.h \ 69 | vslvmtools_signal.c vslvmtools_signal.h \ 70 | vslvmtools_unused.h 71 | 72 | vslvmmount_LDADD = \ 73 | @LIBFUSE_LIBADD@ \ 74 | @LIBBFIO_LIBADD@ \ 75 | @LIBCPATH_LIBADD@ \ 76 | @LIBCFILE_LIBADD@ \ 77 | @LIBUNA_LIBADD@ \ 78 | @LIBCSPLIT_LIBADD@ \ 79 | @LIBCDATA_LIBADD@ \ 80 | @LIBCNOTIFY_LIBADD@ \ 81 | @LIBCLOCALE_LIBADD@ \ 82 | ../libvslvm/libvslvm.la \ 83 | @LIBCERROR_LIBADD@ \ 84 | @LIBINTL@ 85 | 86 | DISTCLEANFILES = \ 87 | Makefile \ 88 | Makefile.in 89 | 90 | splint-local: 91 | @echo "Running splint on vslvminfo ..." 92 | -splint -preproc -redef $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(vslvminfo_SOURCES) 93 | 94 | -------------------------------------------------------------------------------- /vslvmtools/byte_size_string.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Byte size string functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _BYTE_SIZE_STRING_H ) 23 | #define _BYTE_SIZE_STRING_H 24 | 25 | #include 26 | #include 27 | 28 | #include "vslvmtools_libcerror.h" 29 | 30 | #if defined( __cplusplus ) 31 | extern "C" { 32 | #endif 33 | 34 | enum BYTE_SIZE_STRING_UNITS 35 | { 36 | BYTE_SIZE_STRING_UNIT_MEGABYTE = 1000, 37 | BYTE_SIZE_STRING_UNIT_MEBIBYTE = 1024 38 | }; 39 | 40 | int byte_size_string_create( 41 | system_character_t *byte_size_string, 42 | size_t byte_size_string_length, 43 | uint64_t size, 44 | int units, 45 | libcerror_error_t **error ); 46 | 47 | int byte_size_string_convert( 48 | const system_character_t *byte_size_string, 49 | size_t byte_size_string_length, 50 | uint64_t *size, 51 | libcerror_error_t **error ); 52 | 53 | #if defined( __cplusplus ) 54 | } 55 | #endif 56 | 57 | #endif /* !defined( _BYTE_SIZE_STRING_H ) */ 58 | 59 | -------------------------------------------------------------------------------- /vslvmtools/vslvmtools_getopt.h: -------------------------------------------------------------------------------- 1 | /* 2 | * GetOpt functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVMTOOLS_GETOPT_H ) 23 | #define _VSLVMTOOLS_GETOPT_H 24 | 25 | #include 26 | #include 27 | 28 | /* unistd.h is included here to export getopt, optarg, optind and optopt 29 | */ 30 | #if defined( HAVE_UNISTD_H ) 31 | #include 32 | #endif 33 | 34 | #if defined( __cplusplus ) 35 | extern "C" { 36 | #endif 37 | 38 | #if defined( HAVE_GETOPT ) 39 | #define vslvmtools_getopt( argument_count, argument_values, options_string ) \ 40 | getopt( argument_count, argument_values, options_string ) 41 | 42 | #else 43 | 44 | #if !defined( __CYGWIN__ ) 45 | extern int optind; 46 | extern system_character_t *optarg; 47 | extern system_integer_t optopt; 48 | 49 | #else 50 | int optind; 51 | system_character_t *optarg; 52 | system_integer_t optopt; 53 | 54 | #endif /* !defined( __CYGWIN__ ) */ 55 | 56 | system_integer_t vslvmtools_getopt( 57 | int argument_count, 58 | system_character_t * const argument_values[], 59 | const system_character_t *options_string ); 60 | 61 | #endif /* defined( HAVE_GETOPT ) */ 62 | 63 | #if defined( __cplusplus ) 64 | } 65 | #endif 66 | 67 | #endif /* !defined( _VSLVMTOOLS_GETOPT_H ) */ 68 | 69 | -------------------------------------------------------------------------------- /vslvmtools/vslvmtools_i18n.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Internationalization (i18n) functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVMTOOLS_I18N_H ) 23 | #define _VSLVMTOOLS_I18N_H 24 | 25 | #include 26 | 27 | #if defined( HAVE_LIBINTL_H ) 28 | #include 29 | #endif 30 | 31 | #if defined( __cplusplus ) 32 | extern "C" { 33 | #endif 34 | 35 | /* TODO for now do nothing i18n-like 36 | #define _( string ) \ 37 | gettext( string ) 38 | */ 39 | 40 | #define _( string ) \ 41 | string 42 | 43 | #if defined( __cplusplus ) 44 | } 45 | #endif 46 | 47 | #endif /* !defined( _VSLVMTOOLS_I18N_H ) */ 48 | 49 | -------------------------------------------------------------------------------- /vslvmtools/vslvmtools_libbfio.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libbfio header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVMTOOLS_LIBBFIO_H ) 23 | #define _VSLVMTOOLS_LIBBFIO_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBBFIO for local use of libbfio 28 | */ 29 | #if defined( HAVE_LOCAL_LIBBFIO ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | 40 | #else 41 | 42 | /* If libtool DLL support is enabled set LIBBFIO_DLL_IMPORT 43 | * before including libbfio.h 44 | */ 45 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) && !defined( HAVE_STATIC_EXECUTABLES ) 46 | #define LIBBFIO_DLL_IMPORT 47 | #endif 48 | 49 | #include 50 | 51 | #if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( LIBBFIO_HAVE_MULTI_THREAD_SUPPORT ) 52 | #error Multi-threading support requires libbfio with multi-threading support 53 | #endif 54 | 55 | #endif /* defined( HAVE_LOCAL_LIBBFIO ) */ 56 | 57 | #endif /* !defined( _VSLVMTOOLS_LIBBFIO_H ) */ 58 | 59 | -------------------------------------------------------------------------------- /vslvmtools/vslvmtools_libcdata.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libcdata header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVMTOOLS_LIBCDATA_H ) 23 | #define _VSLVMTOOLS_LIBCDATA_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCDATA for local use of libcdata 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCDATA ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | 40 | #else 41 | 42 | /* If libtool DLL support is enabled set LIBCDATA_DLL_IMPORT 43 | * before including libcdata.h 44 | */ 45 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) 46 | #define LIBCDATA_DLL_IMPORT 47 | #endif 48 | 49 | #include 50 | 51 | #endif /* defined( HAVE_LOCAL_LIBCDATA ) */ 52 | 53 | #endif /* !defined( _VSLVMTOOLS_LIBCDATA_H ) */ 54 | 55 | -------------------------------------------------------------------------------- /vslvmtools/vslvmtools_libcerror.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libcerror header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVMTOOLS_LIBCERROR_H ) 23 | #define _VSLVMTOOLS_LIBCERROR_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCERROR for local use of libcerror 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCERROR ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | 36 | #else 37 | 38 | /* If libtool DLL support is enabled set LIBCERROR_DLL_IMPORT 39 | * before including libcerror.h 40 | */ 41 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) && !defined( HAVE_STATIC_EXECUTABLES ) 42 | #define LIBCERROR_DLL_IMPORT 43 | #endif 44 | 45 | #include 46 | 47 | #endif /* defined( HAVE_LOCAL_LIBCERROR ) */ 48 | 49 | #endif /* !defined( _VSLVMTOOLS_LIBCERROR_H ) */ 50 | 51 | -------------------------------------------------------------------------------- /vslvmtools/vslvmtools_libclocale.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libclocale header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVMTOOLS_LIBCLOCALE_H ) 23 | #define _VSLVMTOOLS_LIBCLOCALE_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCLOCALE for local use of libclocale 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCLOCALE ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | 36 | #else 37 | 38 | /* If libtool DLL support is enabled set LIBCLOCALE_DLL_IMPORT 39 | * before including libclocale.h 40 | */ 41 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) && !defined( HAVE_STATIC_EXECUTABLES ) 42 | #define LIBCLOCALE_DLL_IMPORT 43 | #endif 44 | 45 | #include 46 | 47 | #endif /* defined( HAVE_LOCAL_LIBCLOCALE ) */ 48 | 49 | #endif /* !defined( _VSLVMTOOLS_LIBCLOCALE_H ) */ 50 | 51 | -------------------------------------------------------------------------------- /vslvmtools/vslvmtools_libcnotify.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libcnotify header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVMTOOLS_LIBCNOTIFY_H ) 23 | #define _VSLVMTOOLS_LIBCNOTIFY_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCNOTIFY for local use of libcnotify 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCNOTIFY ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | 36 | #else 37 | 38 | /* If libtool DLL support is enabled set LIBCNOTIFY_DLL_IMPORT 39 | * before including libcnotify.h 40 | */ 41 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) && !defined( HAVE_STATIC_EXECUTABLES ) 42 | #define LIBCNOTIFY_DLL_IMPORT 43 | #endif 44 | 45 | #include 46 | 47 | #endif /* defined( HAVE_LOCAL_LIBCNOTIFY ) */ 48 | 49 | #endif /* !defined( _VSLVMTOOLS_LIBCNOTIFY_H ) */ 50 | 51 | -------------------------------------------------------------------------------- /vslvmtools/vslvmtools_libcpath.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libcpath header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVMTOOLS_LIBCPATH_H ) 23 | #define _VSLVMTOOLS_LIBCPATH_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBCPATH for local use of libcpath 28 | */ 29 | #if defined( HAVE_LOCAL_LIBCPATH ) 30 | 31 | #include 32 | #include 33 | 34 | #else 35 | 36 | /* If libtool DLL support is enabled set LIBCPATH_DLL_IMPORT 37 | * before including libcpath.h 38 | */ 39 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) && !defined( HAVE_STATIC_EXECUTABLES ) 40 | #define LIBCPATH_DLL_IMPORT 41 | #endif 42 | 43 | #include 44 | 45 | #endif /* defined( HAVE_LOCAL_LIBCPATH ) */ 46 | 47 | #endif /* !defined( _VSLVMTOOLS_LIBCPATH_H ) */ 48 | 49 | -------------------------------------------------------------------------------- /vslvmtools/vslvmtools_libuna.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libuna header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVMTOOLS_LIBUNA_H ) 23 | #define _VSLVMTOOLS_LIBUNA_H 24 | 25 | #include 26 | 27 | /* Define HAVE_LOCAL_LIBUNA for local use of libuna 28 | */ 29 | #if defined( HAVE_LOCAL_LIBUNA ) 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | #include 40 | #include 41 | #include 42 | #include 43 | #include 44 | #include 45 | 46 | #else 47 | 48 | /* If libtool DLL support is enabled set LIBUNA_DLL_IMPORT 49 | * before including libuna.h 50 | */ 51 | #if defined( _WIN32 ) && defined( DLL_IMPORT ) && !defined( HAVE_STATIC_EXECUTABLES ) 52 | #define LIBUNA_DLL_IMPORT 53 | #endif 54 | 55 | #include 56 | 57 | #endif /* defined( HAVE_LOCAL_LIBUNA ) */ 58 | 59 | #endif /* !defined( _VSLVMTOOLS_LIBUNA_H ) */ 60 | 61 | -------------------------------------------------------------------------------- /vslvmtools/vslvmtools_libvslvm.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The libvslvm header wrapper 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVMTOOLS_LIBVSLVM_H ) 23 | #define _VSLVMTOOLS_LIBVSLVM_H 24 | 25 | #include 26 | 27 | #include 28 | 29 | #endif /* !defined( _VSLVMTOOLS_LIBVSLVM_H ) */ 30 | 31 | -------------------------------------------------------------------------------- /vslvmtools/vslvmtools_output.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Common output functions for the vslvmtools 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVMTOOLS_OUTPUT_H ) 23 | #define _VSLVMTOOLS_OUTPUT_H 24 | 25 | #include 26 | #include 27 | #include 28 | 29 | #include "vslvmtools_libcerror.h" 30 | 31 | #if defined( __cplusplus ) 32 | extern "C" { 33 | #endif 34 | 35 | int vslvmtools_output_initialize( 36 | int stdio_mode, 37 | libcerror_error_t **error ); 38 | 39 | void vslvmtools_output_copyright_fprint( 40 | FILE *stream ); 41 | 42 | void vslvmtools_output_version_fprint( 43 | FILE *stream, 44 | const char *program ); 45 | 46 | void vslvmtools_output_version_detailed_fprint( 47 | FILE *stream, 48 | const char *program ); 49 | 50 | #if defined( __cplusplus ) 51 | } 52 | #endif 53 | 54 | #endif /* !defined( _VSLVMTOOLS_OUTPUT_H ) */ 55 | 56 | -------------------------------------------------------------------------------- /vslvmtools/vslvmtools_signal.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Signal handling functions 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVMTOOLS_SIGNAL_H ) 23 | #define _VSLVMTOOLS_SIGNAL_H 24 | 25 | #include 26 | #include 27 | 28 | #include "vslvmtools_libcerror.h" 29 | 30 | #if defined( __cplusplus ) 31 | extern "C" { 32 | #endif 33 | 34 | #if !defined( HAVE_SIGNAL_H ) && !defined( WINAPI ) 35 | #error missing signal functions 36 | #endif 37 | 38 | #if defined( WINAPI ) 39 | typedef unsigned long vslvmtools_signal_t; 40 | 41 | #else 42 | typedef int vslvmtools_signal_t; 43 | 44 | #endif /* defined( WINAPI ) */ 45 | 46 | #if defined( WINAPI ) 47 | 48 | BOOL WINAPI vslvmtools_signal_handler( 49 | vslvmtools_signal_t signal ); 50 | 51 | #if defined( _MSC_VER ) 52 | 53 | void vslvmtools_signal_initialize_memory_debug( 54 | void ); 55 | 56 | #endif /* defined( _MSC_VER ) */ 57 | 58 | #endif /* defined( WINAPI ) */ 59 | 60 | int vslvmtools_signal_attach( 61 | void (*signal_handler)( vslvmtools_signal_t ), 62 | libcerror_error_t **error ); 63 | 64 | int vslvmtools_signal_detach( 65 | libcerror_error_t **error ); 66 | 67 | #if defined( __cplusplus ) 68 | } 69 | #endif 70 | 71 | #endif /* !defined( _VSLVMTOOLS_SIGNAL_H ) */ 72 | 73 | -------------------------------------------------------------------------------- /vslvmtools/vslvmtools_unused.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Definitions to silence compiler warnings about unused function attributes/parameters. 3 | * 4 | * Copyright (C) 2014-2024, Joachim Metz 5 | * 6 | * Refer to AUTHORS for acknowledgements. 7 | * 8 | * This program is free software: you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License as published by 10 | * the Free Software Foundation, either version 3 of the License, or 11 | * (at your option) any later version. 12 | * 13 | * This program is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | * GNU General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public License 19 | * along with this program. If not, see . 20 | */ 21 | 22 | #if !defined( _VSLVMTOOLS_UNUSED_H ) 23 | #define _VSLVMTOOLS_UNUSED_H 24 | 25 | #include 26 | 27 | #if !defined( VSLVMTOOLS_ATTRIBUTE_UNUSED ) 28 | 29 | #if defined( __GNUC__ ) && __GNUC__ >= 3 30 | #define VSLVMTOOLS_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 31 | 32 | #else 33 | #define VSLVMTOOLS_ATTRIBUTE_UNUSED 34 | 35 | #endif /* defined( __GNUC__ ) && __GNUC__ >= 3 */ 36 | 37 | #endif /* !defined( VSLVMTOOLS_ATTRIBUTE_UNUSED ) */ 38 | 39 | #if defined( _MSC_VER ) 40 | #define VSLVMTOOLS_UNREFERENCED_PARAMETER( parameter ) \ 41 | UNREFERENCED_PARAMETER( parameter ); 42 | 43 | #else 44 | #define VSLVMTOOLS_UNREFERENCED_PARAMETER( parameter ) \ 45 | /* parameter */ 46 | 47 | #endif /* defined( _MSC_VER ) */ 48 | 49 | #endif /* !defined( _VSLVMTOOLS_UNUSED_H ) */ 50 | 51 | --------------------------------------------------------------------------------