diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..3057801 --- /dev/null +++ b/.clang-format @@ -0,0 +1,135 @@ +# vim: filetype=yaml +# https://clang.llvm.org/docs/ClangFormatStyleOptions.html +--- +Language: Cpp +AccessModifierOffset: -4 +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: true +#AlignConsecutiveBitFields: true +AlignConsecutiveDeclarations: true +AlignConsecutiveMacros: true +AlignEscapedNewlines: Right +AlignOperands: true +AlignTrailingComments: true +AllowAllArgumentsOnNextLine: true +AllowAllConstructorInitializersOnNextLine: true +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortBlocksOnASingleLine: Never +AllowShortCaseLabelsOnASingleLine: true +AllowShortFunctionsOnASingleLine: Empty +AllowShortIfStatementsOnASingleLine: WithoutElse +AllowShortLambdasOnASingleLine: All +AllowShortLoopsOnASingleLine: true +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: No +BinPackArguments: true +BinPackParameters: true +BraceWrapping: + AfterCaseLabel: false + AfterClass: false + AfterControlStatement: false + AfterEnum: false + AfterExternBlock: false + AfterFunction: true + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + BeforeCatch: false + BeforeElse: false + #BeforeLambdaBody: false + #BeforeWhile: false + IndentBraces: false + SplitEmptyFunction: false + SplitEmptyNamespace: true + SplitEmptyRecord: true +BreakAfterJavaFieldAnnotations: false +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Custom +BreakBeforeInheritanceComma: false +BreakBeforeTernaryOperators: true +BreakConstructorInitializers: BeforeComma +BreakConstructorInitializersBeforeComma: false +BreakInheritanceList: BeforeComma +BreakStringLiterals: false +ColumnLimit: 120 +CommentPragmas: '^ IWYU pragma:' +CompactNamespaces: false +ConstructorInitializerAllOnOneLineOrOnePerLine: false +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DeriveLineEnding: true +DerivePointerAlignment: false +DisableFormat: false +ExperimentalAutoDetectBinPacking: false +FixNamespaceComments: true +ForEachMacros: ['foreach', 'Q_FOREACH', 'BOOST_FOREACH'] +IncludeBlocks: Regroup +IncludeCategories: + - Regex: '^"(llvm|llvm-c|clang|clang-c)/' + Priority: 2 + SortPriority: 0 + - Regex: '^(<|"(gtest|gmock|isl|json)/)' + Priority: 3 + SortPriority: 0 + - Regex: '.*' + Priority: 1 + SortPriority: 0 +IncludeIsMainRegex: '(Test)?$' +IncludeIsMainSourceRegex: '' +IndentCaseLabels: true +#IndentExternBlock: Indent +IndentGotoLabels: true +IndentPPDirectives: AfterHash +IndentWidth: 4 +IndentWrappedFunctionNames: true +JavaScriptQuotes: Single +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: false +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: All +ObjCBinPackProtocolList: Auto +ObjCBlockIndentWidth: 2 +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: true +PenaltyBreakAssignment: 2 +PenaltyBreakBeforeFirstCallParameter: 19 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakString: 1000 +PenaltyBreakTemplateDeclaration: 10 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 60 +PointerAlignment: Left +ReflowComments: false +SortIncludes: false +SortUsingDeclarations: true +SpaceAfterCStyleCast: false +SpaceAfterLogicalNot: false +SpaceAfterTemplateKeyword: true +SpaceBeforeAssignmentOperators: true +SpaceBeforeCpp11BracedList: false +SpaceBeforeCtorInitializerColon: false +SpaceBeforeInheritanceColon: false +SpaceBeforeParens: ControlStatements +SpaceBeforeRangeBasedForLoopColon: true +SpaceBeforeSquareBrackets: false +SpaceInEmptyBlock: false +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: false +SpacesInCStyleCastParentheses: false +SpacesInConditionalStatement: false +SpacesInContainerLiterals: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +Standard: Latest +StatementMacros: ['Q_UNUSED', 'QT_REQUIRE_VERSION'] +TabWidth: 4 +TypenameMacros: ['LIST'] +UseCRLF: false +UseTab: ForContinuationAndIndentation diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..3ef0b02 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,8 @@ +root = true + +[*] +charset = utf-8 +end_of_line = lf +indent_size = 4 +indent_style = tab +insert_final_newline = true diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..121eb24 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +.build-* +.tidyall.d +include/version.hpp diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..756fd72 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "3rdparty/p7zip"] + path = 3rdparty/p7zip + url = https://github.com/btolab/p7zip.git diff --git a/.local.vimrc b/.local.vimrc new file mode 100644 index 0000000..e6c455a --- /dev/null +++ b/.local.vimrc @@ -0,0 +1,14 @@ +function! s:find_git_root() + return system('git rev-parse --show-toplevel 2> /dev/null')[:-2] +endfunction + +if !exists("g:ale_configs_updated") + let g:ale_configs_updated = 1 + let root = s:find_git_root() + "let g:ale_cpp_clang_options = g:ale_cpp_options." -std=c++20 -I /usr/include/fuse3 -I ".expand('%:p:h')."/include -I ".expand('%:p:h')."/src/include -I ".expand('%:p:h')."/3rdparty/p7zip -I ".expand('%:p:h')."/3rdparty/p7zip/CPP -I ".expand('%:p:h')."/3rdparty/p7zip/CPP/include_windows -I ".expand('%:p:h')."/src/7zip/include -D_FILE_OFFSET_BITS=64" + let g:ale_cpp_clang_options = g:ale_cpp_options." -std=c++20 -I /usr/include/fuse3 -I ".root."/include -I ".root."/src/include -I ".root."/3rdparty/p7zip -I ".root."/3rdparty/p7zip/CPP -I ".root."/3rdparty/p7zip/CPP/include_windows -I ".root."/src/7zip/include -D_FILE_OFFSET_BITS=64" + let g:ale_cpp_clangcheck_options = g:ale_cpp_clang_options + let g:ale_cpp_clangd_options = g:ale_cpp_clang_options + let g:ale_cpp_gcc_options = g:ale_cpp_clang_options + let g:ale_cpp_clangtidy_options = g:ale_cpp_clang_options +endif diff --git a/.tidyallrc b/.tidyallrc new file mode 100644 index 0000000..9457d1b --- /dev/null +++ b/.tidyallrc @@ -0,0 +1,13 @@ +; vim: filetype=dosini + +[GenericValidator / ClangFromat] +cmd = clang-format +select = {include,src}/**/*.{c,cpp,h,hpp} +;ignore = {.build,3rdparty}/**/* +argv = --style=file + +[GenericTransformer / ClangFromat] +cmd = clang-format +select = {include,src}/**/*.{c,cpp,h,hpp} +;ignore = {.build,3rdparty}/**/* +argv = --style=file diff --git a/3rdparty/p7zip b/3rdparty/p7zip new file mode 160000 index 0000000..f30c859 --- /dev/null +++ b/3rdparty/p7zip @@ -0,0 +1 @@ +Subproject commit f30c859433af90937723dd4e808a24c3bb836711 diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..25da8f4 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,87 @@ +cmake_minimum_required (VERSION 3.12 FATAL_ERROR) + +project (fuse3-p7zip + VERSION 0.9.0 + LANGUAGES CXX +) + +configure_file ( + ${CMAKE_CURRENT_LIST_DIR}/cmake/version.hpp.in + ${CMAKE_CURRENT_LIST_DIR}/include/version.hpp + @ONLY +) + +set (CMAKE_EXPORT_COMPILE_COMMANDS ON) +set (CMAKE_INSTALL_PREFIX /usr) +set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/cmake) + +set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) +set (CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) +set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) + +find_package (FUSE3 REQUIRED) +include_directories (${FUSE3_INCLUDE_DIR}) +include_directories (${CMAKE_CURRENT_LIST_DIR}/3rdparty/p7zip) +include_directories (${CMAKE_CURRENT_LIST_DIR}/3rdparty/p7zip/CPP) +include_directories (${CMAKE_CURRENT_LIST_DIR}/3rdparty/p7zip/CPP/include_windows) +include_directories (${CMAKE_CURRENT_LIST_DIR}/3rdparty/p7zip/CPP/myWindows) + +add_executable (${PROJECT_NAME} + src/main.cpp + src/library.cpp + src/string.cpp + src/fuse3.cpp + src/exception.cpp + + src/7zip/Library.cpp + src/7zip/Format.cpp + src/7zip/Method.cpp + src/7zip/Archive.cpp + src/7zip/ReadStream.cpp + src/7zip/WriteStream.cpp + src/7zip/ArchiveExtractor.cpp + src/7zip/com.cpp + + 3rdparty/p7zip/CPP/Common/MyWindows.cpp + 3rdparty/p7zip/CPP/Windows/PropVariant.cpp +) + +# set_target_properties (${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE CXX) + +target_compile_features (${PROJECT_NAME} PUBLIC + cxx_std_20 +) +target_compile_definitions (${PROJECT_NAME} PUBLIC + _FILE_OFFSET_BITS=64 +) +target_compile_options (${PROJECT_NAME} PUBLIC + -Wall + -fmax-errors=20 + #--pedantic + #-Wextra +) + +target_include_directories (${PROJECT_NAME} PRIVATE + src/include +) +target_include_directories (${PROJECT_NAME} PUBLIC + include +) +target_link_libraries (${PROJECT_NAME} PUBLIC + dl + ${FUSE3_LIBRARIES} +) + +# man: https://cmake.org/cmake/help/v3.12/command/install.html +install(TARGETS ${PROJECT_NAME} + CONFIGURATIONS Debug + ARCHIVE DESTINATION ~/.local/lib/static + LIBRARY DESTINATION ~/.local/lib + RUNTIME DESTINATION ~/.local/bin +) +install(TARGETS ${PROJECT_NAME} + CONFIGURATIONS Release + ARCHIVE DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/static + LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib + RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin +) diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..e75a9c5 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + fuse3-p7zip + Copyright (C) 2020 Andrew Grechkin + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + fuse3-p7zip Copyright (C) 2020 Andrew Grechkin + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/README.md b/README.md new file mode 100644 index 0000000..dff6bca --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# fuse3-p7zip + +fuse3 file system that uses the p7zip library to mount archives diff --git a/build b/build new file mode 100755 index 0000000..7ef481d --- /dev/null +++ b/build @@ -0,0 +1,12 @@ +#!/usr/bin/env bash + +set -Eeuo pipefail + +BUILD_TYPE=${BUILD_TYPE:-Debug} +DIR=".build-$BUILD_TYPE" + +mkdir -p "$DIR" && pushd "$DIR" +cmake -DCMAKE_BUILD_TYPE="$BUILD_TYPE" .. +popd + +make -j -C "$DIR" install diff --git a/cmake/FindFUSE.cmake b/cmake/FindFUSE.cmake new file mode 100644 index 0000000..099573c --- /dev/null +++ b/cmake/FindFUSE.cmake @@ -0,0 +1,37 @@ +# Find the FUSE includes and library +# +# FUSE_INCLUDE_DIR - where to find fuse.h, etc. +# FUSE_LIBRARIES - List of libraries when using FUSE. +# FUSE_FOUND - True if FUSE lib is found. + +# check if already in cache, be silent +if (FUSE_INCLUDE_DIR) + SET (FUSE_FIND_QUIETLY TRUE) +endif (FUSE_INCLUDE_DIR) + +if (APPLE) + set (FUSE_NAMES libosxfuse.dylib fuse) + set (FUSE_SUFFIXES osxfuse fuse) +elseif(WINDOWS) + set (FUSE_NAMES libdokanfuse1) + set (FUSE_SUFFIXES dokanfuse1) +else() + set(FUSE_NAMES fuse) + set(FUSE_SUFFIXES fuse) +endif() + +# find includes +find_path (FUSE_INCLUDE_DIR fuse.h + PATHS /opt /opt/local /usr/pkg + PATH_SUFFIXES ${FUSE_SUFFIXES} +) + +# find lib +find_library (FUSE_LIBRARIES NAMES ${FUSE_NAMES}) + +include ("FindPackageHandleStandardArgs") +find_package_handle_standard_args ( + "FUSE" DEFAULT_MSG FUSE_INCLUDE_DIR FUSE_LIBRARIES +) + +mark_as_advanced (FUSE_INCLUDE_DIR FUSE_LIBRARIES) diff --git a/cmake/FindFUSE3.cmake b/cmake/FindFUSE3.cmake new file mode 100644 index 0000000..23b13fa --- /dev/null +++ b/cmake/FindFUSE3.cmake @@ -0,0 +1,29 @@ +# Find the FUSE3 includes and library +# +# FUSE3_INCLUDE_DIR - where to find fuse.h, etc. +# FUSE3_LIBRARIES - List of libraries when using FUSE3. +# FUSE3_FOUND - True if FUSE3 lib is found. + +# check if already in cache, be silent +if (FUSE3_INCLUDE_DIR) + SET (FUSE3_FIND_QUIETLY TRUE) +endif (FUSE3_INCLUDE_DIR) + +set(FUSE3_NAMES fuse3) +set(FUSE3_SUFFIXES fuse3) + +# find includes +find_path (FUSE3_INCLUDE_DIR fuse.h + PATHS /opt /opt/local /usr/pkg + PATH_SUFFIXES ${FUSE3_SUFFIXES} +) + +# find lib +find_library (FUSE3_LIBRARIES NAMES ${FUSE3_NAMES}) + +include ("FindPackageHandleStandardArgs") +find_package_handle_standard_args ( + "FUSE3" DEFAULT_MSG FUSE3_INCLUDE_DIR FUSE3_LIBRARIES +) + +mark_as_advanced (FUSE3_INCLUDE_DIR FUSE3_LIBRARIES) diff --git a/cmake/version.hpp.in b/cmake/version.hpp.in new file mode 100644 index 0000000..7145dad --- /dev/null +++ b/cmake/version.hpp.in @@ -0,0 +1,9 @@ +#ifndef __FUSE3_7Z__VERSION_HPP_ +#define __FUSE3_7Z__VERSION_HPP_ + +#define PROJECT_VERSION_MAJOR @PROJECT_VERSION_MAJOR@ +#define PROJECT_VERSION_MINOR @PROJECT_VERSION_MINOR@ +#define PROJECT_VERSION_PATCH @PROJECT_VERSION_PATCH@ +#define PROJECT_VERSION "v@PROJECT_VERSION@" + +#endif diff --git a/include/7zip.hpp b/include/7zip.hpp new file mode 100644 index 0000000..5ca2bca --- /dev/null +++ b/include/7zip.hpp @@ -0,0 +1,182 @@ +#ifndef __FUSE3_7Z__7ZIP_HPP_ +#define __FUSE3_7Z__7ZIP_HPP_ + +#include +#include +#include +#include + +#include +#include + +namespace sevenzip { + class ILib; + class IFormat; + class IMethod; + class IArchive; + class IOpenCallback; + class IArchiveExtractor; + class IArchiveUpdator; + class IExtractCallback; + class IUpdateCallback; + class ImplArchive; + class IFile; + + struct Guid; + + using Stat = struct stat; + using Path = std::filesystem::path; + using Lib = std::unique_ptr; + using Format = std::shared_ptr; + using Method = std::unique_ptr; + using Archive = std::unique_ptr; + using Formats = std::vector; + using Methods = std::vector; + using Extensions = std::vector; + using Size = uint64_t; + using flags_type = ssize_t; + using File = std::unique_ptr; + + Lib open(const Path& path); + + class ILib { + public: + virtual ~ILib() noexcept = default; + + virtual const Path& path() const noexcept = 0; + virtual const Formats& formats() const noexcept = 0; + virtual const Methods& methods() const noexcept = 0; + + virtual Archive open(const Path& path, const IOpenCallback& callback, flags_type flags = 0) const = 0; + }; + + class IFormat { + public: + virtual ~IFormat() noexcept = default; + + virtual std::string name() const noexcept = 0; + virtual const Extensions& default_extension() const noexcept = 0; + virtual const Extensions& additional_extension() const noexcept = 0; + virtual const Guid* guid() const noexcept = 0; + virtual bool updatable() const noexcept = 0; + }; + + class IMethod { + public: + virtual ~IMethod() noexcept = default; + + virtual std::string name() const noexcept = 0; + }; + + class IOpenCallback { + public: + virtual ~IOpenCallback() noexcept = default; + + virtual std::string request_password() const = 0; + }; + + class IExtractCallback: public IOpenCallback { + public: + virtual bool notify_progress(uint64_t current, uint64_t of) const = 0; + }; + + class EmptyOpenCallback: public IOpenCallback { + std::string request_password() const override + { + return std::string(); + } + }; + + class EmptyExtractCallback: public IExtractCallback { + std::string request_password() const override + { + return std::string(); + } + bool notify_progress(uint64_t, uint64_t) const override + { + return true; + } + }; + + class IFile { + public: + enum Whence : uint8_t { set = 0, cur = 1, end = 2 }; + + virtual ~IFile() noexcept = default; + + virtual uint64_t read(void* data, uint64_t size) = 0; + virtual uint64_t write(const void* data, uint64_t size) = 0; + virtual uint64_t seek(uint64_t pos, Whence whence) = 0; + }; + + class IArchive { + public: + struct ci_iterator; + + using iterator = ci_iterator; + using const_iterator = ci_iterator; + + virtual ~IArchive() noexcept = default; + + virtual const Path& path() const noexcept = 0; + virtual const Stat& stat() const noexcept = 0; + virtual const Format& format() const noexcept = 0; + virtual std::string proposed_name() const noexcept = 0; + + virtual bool empty() const noexcept = 0; + virtual size_t size() const noexcept = 0; + + virtual const_iterator begin() const noexcept = 0; + virtual const_iterator end() const noexcept = 0; + virtual const_iterator at(size_t index) const = 0; + virtual flags_type flags() const noexcept = 0; + }; + + struct IArchive::ci_iterator { + ~ci_iterator() noexcept; + ci_iterator(const ci_iterator& other); + ci_iterator(ci_iterator&& other) noexcept; + + ci_iterator& operator=(const ci_iterator& other); + ci_iterator& operator=(ci_iterator&& other) noexcept; + void swap(ci_iterator& other) noexcept; + + ci_iterator& operator++(); + ci_iterator operator++(int); + + std::string path() const; + std::string name() const; + std::string extension() const; + std::string comment() const; + Size size() const; + Size size_packed() const; + + bool is_file() const; + bool is_dir() const; + + File extract(const IExtractCallback& callback = EmptyExtractCallback()) const; + + size_t get_props_count() const; + + bool operator==(const ci_iterator& other) const noexcept; + bool operator!=(const ci_iterator& other) const noexcept; + + private: + struct Impl; + using Impl_type = std::unique_ptr; + Impl_type impl; + + ci_iterator(Impl_type&& impl) noexcept; + + friend class ImplArchive; + }; + + class IArchiveExtractor { + public: + virtual ~IArchiveExtractor() noexcept = default; + + virtual void execute(bool test) = 0; + }; +} // namespace sevenzip + +#endif diff --git a/include/exception.hpp b/include/exception.hpp new file mode 100644 index 0000000..8b05b4d --- /dev/null +++ b/include/exception.hpp @@ -0,0 +1,55 @@ +#ifndef __FUSE3_7Z__EXCEPTION_HPP_ +#define __FUSE3_7Z__EXCEPTION_HPP_ + +#include +#include + +#ifdef NDEBUG +# define CheckErrno(arg, str) \ + ({ \ + if (!(arg)) exception::HiddenFunctions::ThrowErrnoFunc((str)); \ + }) +# define CheckPointer(arg, hnd, str) \ + ({ \ + if ((arg) == nullptr) hnd((str)); \ + }) +# define CheckResult(arg, str) \ + ({ \ + if (!(arg)) exception::HiddenFunctions::ThrowResultFunc((str)); \ + }) +# define CheckCom(arg, str) (exception::HiddenFunctions::CheckComFunc((arg), (str))) +#else +# define THROW_PLACE __FILE__, __LINE__, __PRETTY_FUNCTION__ +# define CheckErrno(arg, str) \ + ({ \ + if (!(arg)) exception::HiddenFunctions::ThrowErrnoFunc((str), THROW_PLACE); \ + }) +# define CheckPointer(arg, hnd, str) \ + ({ \ + if ((arg) == nullptr) hnd((str), THROW_PLACE); \ + }) +# define CheckResult(arg, str) \ + ({ \ + if (!(arg)) exception::HiddenFunctions::ThrowResultFunc((str), THROW_PLACE); \ + }) +# define CheckCom(arg, str) (exception::HiddenFunctions::CheckComFunc((arg), (str), THROW_PLACE)) +#endif + +namespace exception { + //using HANDLE = size_t; + using HRESULT = int32_t; + + struct HiddenFunctions { + static void ThrowErrnoFunc(const std::string& str); + static void ThrowErrnoFunc(const std::string& str, const char* file, size_t line, const char* func); + + static void ThrowResultFunc(const std::string& str); + static void ThrowResultFunc(const std::string& str, const char* file, size_t line, const char* func); + + static HRESULT CheckComFunc(HRESULT res, const std::string& str); + static HRESULT CheckComFunc(HRESULT res, const std::string& str, const char* file, size_t line, + const char* func); + }; +} // namespace exception + +#endif diff --git a/include/library.hpp b/include/library.hpp new file mode 100644 index 0000000..71e29bc --- /dev/null +++ b/include/library.hpp @@ -0,0 +1,29 @@ +#ifndef __FUSE3_7Z__LIBRARY_HPP_ +#define __FUSE3_7Z__LIBRARY_HPP_ + +#include +#include +#include + +namespace library { + class IDynamic; + + using Dynamic = std::unique_ptr; + using Path = std::filesystem::path; + using Symbol = void*; + using flags_type = ssize_t; + + Dynamic open(const Path& path, flags_type flags = flags_type()); + + class IDynamic { + public: + virtual ~IDynamic() noexcept = default; + + virtual const Path& path() const noexcept = 0; + + virtual Symbol get_sym(const char* name) const = 0; + virtual Symbol get_sym_nt(const char* name) const noexcept = 0; + }; +} // namespace library + +#endif diff --git a/include/pattern.hpp b/include/pattern.hpp new file mode 100644 index 0000000..0d7ef56 --- /dev/null +++ b/include/pattern.hpp @@ -0,0 +1,44 @@ +#ifndef __FUSE3_7Z__PATTERN_HPP_ +#define __FUSE3_7Z__PATTERN_HPP_ + +#include + +namespace pattern { + struct Command { + virtual ~Command() = default; + + virtual ssize_t execute() = 0; + }; + + struct Destroyable { + virtual ~Destroyable() = default; + + virtual void destroy() const = 0; + }; + + class Uncopyable { + public: + Uncopyable(const Uncopyable&) = delete; + Uncopyable& operator=(const Uncopyable&) = delete; + + protected: + ~Uncopyable() = default; + Uncopyable() = default; + }; + + template struct Singleton: private T { + typedef T implementation_type; + typedef Singleton this_type; + static T& instance() + { + static this_type instance; + return instance; + } + + private: + ~Singleton() {} + Singleton() {} + }; +} // namespace pattern + +#endif diff --git a/include/string.hpp b/include/string.hpp new file mode 100644 index 0000000..dc7005c --- /dev/null +++ b/include/string.hpp @@ -0,0 +1,15 @@ +#ifndef __FUSE3_7Z__STRING_HPP_ +#define __FUSE3_7Z__STRING_HPP_ + +#include +#include + +std::string utf8raw(const std::wstring& wstr, const char* encoding); + +std::string utf8(const wchar_t* str); + +std::string utf8(const char* str, const char* encoding); + +std::vector split(const std::string& d, std::string str); + +#endif diff --git a/packaging/arch/PKGBUILD b/packaging/arch/PKGBUILD new file mode 100644 index 0000000..771c386 --- /dev/null +++ b/packaging/arch/PKGBUILD @@ -0,0 +1,33 @@ +_name=fuse3-p7zip +pkgname="$_name-git" +pkgver=0.9.0 +pkgrel=1 +pkgdesc="FUSE3 file system that uses the p7zip library" +arch=('x86_64') +url="https://github.com/andrew-grechkin/fuse3-p7zip" +license=('GPL') +depends=('fuse3' 'p7zip') +makedepends=('cmake') +_commit=000000000000000000000 +source=("git+https://github.com/andrew-grechkin/fuse3-p7zip#commit=$_commit") +sha256sums=('SKIP') + +# pkgver() { +# cd "$_name" +# git describe --tags | sed 's/-/+/g' +# } + +build() { + cd "$_name" + mkdir -p build + pushd build + cmake .. \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=/usr + popd + make -C build +} + +package() { + make DESTDIR="$pkgdir" install -C build +} diff --git a/src/7zip/Archive.cpp b/src/7zip/Archive.cpp new file mode 100644 index 0000000..0bd8c05 --- /dev/null +++ b/src/7zip/Archive.cpp @@ -0,0 +1,358 @@ +#include "7zip-impl.hpp" +#include "exception.hpp" +#include "string.hpp" + +#include + +namespace sevenzip { + const UInt64 max_check_size = 100 * 1024 * 1024; + + ImplArchive::~ImplArchive() noexcept + { + _arc->Close(); + } + + ImplArchive::ImplArchive(const ImplLib& lib, const Path& path, const IOpenCallback& callback, flags_type flags) + : callback(callback) + , _stream(new FileReadStream(path)) + , _flags(flags) + { + open_archive(lib); + init_props(); + } + + void ImplArchive::open_archive(const ImplLib& lib) + { + for (auto& it : lib.formats()) { + CheckCom(_stream->Seek(0, STREAM_SEEK_SET, nullptr), "Seek"); + + CheckCom(lib.CreateObject(reinterpret_cast(it->guid()), &IID_IInArchive, (void**)&_arc), + "CreateObject"); + + auto res = _arc->Open(_stream, &max_check_size, static_cast(this)); + if (res == S_OK) { + _format = it; + return; + } + } + throw std::runtime_error("ERROR_INVALID_DATA"); + } + + void ImplArchive::init_props() + { + CheckCom(_arc->GetNumberOfItems(&_size), "GetNumberOfItems"); + + auto num_props = UInt32(); + CheckCom(_arc->GetNumberOfArchiveProperties(&num_props), "GetNumberOfArchiveProperties"); + } + + ULONG WINAPI ImplArchive::AddRef() + { + return UnknownImp::AddRef(); + } + + ULONG WINAPI ImplArchive::Release() + { + return UnknownImp::Release(); + } + + HRESULT WINAPI ImplArchive::QueryInterface(REFIID riid, void** object) + { + HRESULT ret = S_OK; + + if (object && (riid == IID_IArchiveOpenCallback)) { + AddRef(); + *object = static_cast(this); + } else if (object && (riid == IID_ICryptoGetTextPassword)) { + AddRef(); + *object = static_cast(this); + } else { + ret = UnknownImp::QueryInterface(riid, object); + } + return ret; + } + + HRESULT WINAPI ImplArchive::SetTotal(const UInt64* files, const UInt64* bytes) + { + UNUSED(files); + UNUSED(bytes); + HRESULT ret = S_OK; + + return ret; + } + + HRESULT WINAPI ImplArchive::SetCompleted(const UInt64* files, const UInt64* bytes) + { + UNUSED(files); + UNUSED(bytes); + HRESULT ret = S_OK; + + return ret; + } + + HRESULT WINAPI ImplArchive::CryptoGetTextPassword(BSTR* password) + { + // std::string ret = callback.request_password(); + // com::BStr(ret).detach(*password); + return S_OK; + } + + const Path& ImplArchive::path() const noexcept + { + return _stream->path(); + } + + const Stat& ImplArchive::stat() const noexcept + { + return _stream->stat(); + } + + const Format& ImplArchive::format() const noexcept + { + return _format; + } + + std::string ImplArchive::proposed_name() const noexcept + { + auto name = path().filename(); + auto ext = path().extension(); + auto ext_def = _format->default_extension(); + auto ext_add = _format->additional_extension(); + + for (auto it = ext_def.begin(); it != ext_def.end(); ++it) { + auto ext_try = (std::string(".") + *it); + if (ext == ext_try) { + auto ext_new = ext_add[std::distance(ext_def.begin(), it)]; + if (ext_new != "*") { + name.replace_extension(ext_new); + break; + } + } + } + return std::string(name); + } + + com::Object ImplArchive::operator->() const + { + return _arc; + } + + ImplArchive::operator com::Object() const + { + return _arc; + } + + bool ImplArchive::empty() const noexcept + { + return _size == 0; + } + + size_t ImplArchive::size() const noexcept + { + return _size; + } + + ImplArchive::const_iterator ImplArchive::begin() const noexcept + { + return const_iterator(ci_iterator::Impl::create(*this)); + } + + ImplArchive::const_iterator ImplArchive::end() const noexcept + { + return const_iterator(ci_iterator::Impl::create()); + } + + ImplArchive::const_iterator ImplArchive::at(size_t index) const + { + if (index >= ImplArchive::size()) CheckCom(1, "out of bounds"); + return const_iterator(ci_iterator::Impl::create(*this, index)); + } + + flags_type ImplArchive::flags() const noexcept + { + return _flags; + } + + ImplArchive::ci_iterator::~ci_iterator() noexcept = default; + + ImplArchive::ci_iterator::ci_iterator(const ci_iterator& other) + : impl(ci_iterator::Impl::create(*other.impl)) + {} + + ImplArchive::ci_iterator::ci_iterator(ci_iterator&& other) noexcept + : impl(std::move(other.impl)) + {} + + ImplArchive::ci_iterator& ImplArchive::ci_iterator::operator=(const ci_iterator& other) + { + if (impl != other.impl) ci_iterator(other).swap(*this); + return *this; + } + + ImplArchive::ci_iterator& ImplArchive::ci_iterator::operator=(ci_iterator&& other) noexcept + { + if (impl != other.impl) ci_iterator(std::move(other)).swap(*this); + return *this; + } + + ImplArchive::ci_iterator& ImplArchive::ci_iterator::operator++() + { + //flags_type flags = impl->_seq->flags(); + while (true) { + if (++impl->_index >= impl->_seq->size()) { + impl->_end = true; + break; + } + + // if ((flags & skipHidden) && ((attr() & FILE_ATTRIBUTE_HIDDEN) == + // FILE_ATTRIBUTE_HIDDEN)) { continue; + //} + + //if ((flags & skipDirs) && is_dir()) { + //continue; + //} + + //if ((flags & skipFiles) && is_file()) { + //continue; + //} + break; + } + return *this; + } + + ImplArchive::ci_iterator ImplArchive::ci_iterator::operator++(int) + { + ci_iterator ret(*this); + operator++(); + return ret; + } + + std::string ImplArchive::ci_iterator::path() const + { + NWindows::NCOM::CPropVariant prop; + auto res = impl->get_prop(kpidPath, prop); + //if (res == S_OK && prop.bstrVal) printf("prop bstr: '%ls'\n", (const wchar_t*)prop.bstrVal); + if (res == S_OK && prop.bstrVal) { + auto override_encoding = std::getenv("FUSE3_P7ZIP_FORCE_ENCODING"); + return override_encoding ? utf8raw((const wchar_t*)prop.bstrVal, override_encoding) + : utf8((const wchar_t*)prop.bstrVal); + }; + + return std::string(); + } + + std::string ImplArchive::ci_iterator::name() const + { + NWindows::NCOM::CPropVariant prop; + auto res = impl->get_prop(kpidName, prop); + if (res == S_OK && prop.vt == 8 && prop.bstrVal) return utf8((const wchar_t*)prop.bstrVal); + return std::string(); + } + + std::string ImplArchive::ci_iterator::extension() const + { + NWindows::NCOM::CPropVariant prop; + auto res = impl->get_prop(kpidExtension, prop); + if (res == S_OK && prop.vt == 8 && prop.bstrVal) return utf8((const wchar_t*)prop.bstrVal); + return std::string(); + } + + std::string ImplArchive::ci_iterator::comment() const + { + NWindows::NCOM::CPropVariant prop; + auto res = impl->get_prop(kpidComment, prop); + if (res == S_OK && prop.vt == 8 && prop.bstrVal) return utf8((const wchar_t*)prop.bstrVal); + return std::string(); + } + + Size ImplArchive::ci_iterator::size() const + { + NWindows::NCOM::CPropVariant prop; + auto res = impl->get_prop(kpidSize, prop); + if (res == S_OK && prop.vt == 21) return prop.uhVal.QuadPart; + return 0; + } + + Size ImplArchive::ci_iterator::size_packed() const + { + NWindows::NCOM::CPropVariant prop; + auto res = impl->get_prop(kpidPackSize, prop); + if (res == S_OK && prop.vt == 21) return prop.uhVal.QuadPart; + return 0; + } + + bool ImplArchive::ci_iterator::is_file() const + { + return !is_dir(); + } + + bool ImplArchive::ci_iterator::is_dir() const + { + NWindows::NCOM::CPropVariant prop; + auto res = impl->get_prop(kpidIsDir, prop); + if (res == S_OK && prop.vt == 11) return prop.boolVal; + return false; + } + + File ImplArchive::ci_iterator::extract(const IExtractCallback& callback) const + { + return impl->extract(callback); + } + + size_t ImplArchive::ci_iterator::get_props_count() const + { + UInt32 props = 0; + static_cast>(*impl->_seq)->GetNumberOfProperties(&props); + return props; + } + + bool ImplArchive::ci_iterator::operator==(const ci_iterator& rhs) const noexcept + { + if (impl->_end && rhs.impl->_end) return true; + return impl->_seq == rhs.impl->_seq && impl->_index == rhs.impl->_index; + } + + bool ImplArchive::ci_iterator::operator!=(const ci_iterator& rhs) const noexcept + { + return !operator==(rhs); + } + + void ImplArchive::ci_iterator::swap(ci_iterator& other) noexcept + { + using std::swap; + swap(impl, other.impl); + } + + ImplArchive::ci_iterator::ci_iterator(Impl_type&& impl) noexcept + : impl(std::move(impl)) + {} + + ImplArchive::ci_iterator::Impl::Impl() + : _seq(nullptr) + , _index(0) + , _end(true) + {} + + ImplArchive::ci_iterator::Impl::Impl(const ImplArchive& seq) + : _seq((ImplArchive*)&seq) + , _index(0) + , _end(!_seq->size()) + {} + + ImplArchive::ci_iterator::Impl::Impl(const ImplArchive& seq, UInt32 index) + : _seq((ImplArchive*)&seq) + , _index(index) + , _end(!_seq->size() || index >= _seq->size()) + {} + + HRESULT ImplArchive::ci_iterator::Impl::get_prop(PROPID id, NWindows::NCOM::CPropVariant& prop) const + { + return static_cast>(*_seq)->GetProperty(_index, id, &prop); + } + + File ImplArchive::ci_iterator::Impl::extract(const IExtractCallback& callback) const + { + auto extractor = com::Object(new ImplArchiveExtractor(*_seq, callback)); + return extractor->execute(_index, false); + } +} // namespace sevenzip diff --git a/src/7zip/ArchiveExtractor.cpp b/src/7zip/ArchiveExtractor.cpp new file mode 100644 index 0000000..79ef3f6 --- /dev/null +++ b/src/7zip/ArchiveExtractor.cpp @@ -0,0 +1,139 @@ +#include "7zip-impl.hpp" +#include "exception.hpp" + +namespace sevenzip { + ULONG WINAPI ImplArchiveExtractor::AddRef() + { + return UnknownImp::AddRef(); + } + + ULONG WINAPI ImplArchiveExtractor::Release() + { + return UnknownImp::Release(); + } + + HRESULT WINAPI ImplArchiveExtractor::QueryInterface(REFIID riid, void** object) + { + HRESULT ret = S_OK; + + if (object && (riid == IID_IArchiveExtractCallback)) { + *object = static_cast(this); + AddRef(); + } else if (object && (riid == IID_ICryptoGetTextPassword)) { + *object = static_cast(this); + AddRef(); + } else { + ret = UnknownImp::QueryInterface(riid, object); + } + return ret; + } + + ImplArchiveExtractor::~ImplArchiveExtractor() noexcept {} + + ImplArchiveExtractor::ImplArchiveExtractor(const ImplArchive& arc, const IExtractCallback& callback) noexcept + : arc(arc) + , callback(callback) + , m_dest() + , total() + {} + + HRESULT WINAPI ImplArchiveExtractor::SetTotal(UInt64 size) + { + total = size; + HRESULT ret = callback.notify_progress(0, total) == true ? S_OK : S_FALSE; + + return ret; + } + + HRESULT WINAPI ImplArchiveExtractor::SetCompleted(const UInt64* completeValue) + { + HRESULT ret = S_OK; + + if (completeValue) ret = callback.notify_progress(*completeValue, total) == true ? S_OK : S_FALSE; + + return ret; + } + + HRESULT WINAPI ImplArchiveExtractor::GetStream(UInt32 index, ISequentialOutStream** outStream, Int32 askExtractMode) + { + *outStream = nullptr; + + //m_curr.reset(new CurrItem(askExtractMode, m_dest, arc.at(index))); + + if (askExtractMode != NArchive::NExtract::NAskMode::kExtract) return S_OK; + if (file.get()) { + *outStream = file.get(); + } + + //try { + //if (m_curr->item.is_dir()) { + //fsysx::dir::create_sh(m_curr->full_path); + //} else { + //// Create folders for file + //size_t pos = m_curr->full_path.find_last_of(WPATH_SEPARATORS); + //if (pos != ustring::npos) { + //fsysx::dir::create_sh(m_curr->full_path.substr(0, pos)); + //} + // + //if (fsysx::is_exist(m_curr->full_path) && fsysx::is_file(m_curr->full_path)) { + //fsysx::file::remove(m_curr->full_path); + //} + + //FileWriteStreamImpl* tmp(new FileWriteStream(m_curr->full_path, true)); + //com::Object stream(tmp); + //m_curr->stream = stream; + //stream.detach(tmp); + //*outStream = tmp; + //} + //} catch (exception::Abstract& e) { + //return E_ABORT; + //} + return S_OK; + } + + HRESULT WINAPI ImplArchiveExtractor::PrepareOperation(Int32 askExtractMode) + { + switch (askExtractMode) { + case NArchive::NExtract::NAskMode::kExtract: break; + case NArchive::NExtract::NAskMode::kTest: break; + case NArchive::NExtract::NAskMode::kSkip: break; + }; + return S_OK; + } + + HRESULT WINAPI ImplArchiveExtractor::SetOperationResult(Int32 operationResult) + { + if (operationResult != NArchive::NExtract::NOperationResult::kOK) { + // failed_files.push_back(FailedFile(m_curr->item.path(), operationResult)); + } else { + //if (m_curr->mode == NArchive::NExtract::NAskMode::kExtract) { + //fsysx::set_attr(m_curr->full_path, m_curr->item.attr()); + //if (m_curr->stream) { + //m_curr->stream->set_mtime(m_curr->item.mtime()); + //} + //} + } + //m_curr.reset(); + return S_OK; + } + + HRESULT WINAPI ImplArchiveExtractor::CryptoGetTextPassword(BSTR* pass) + { + //ustring ret = callback.request_password(); + //com::BStr(ret).detach(*pass); + return S_OK; + } + + void ImplArchiveExtractor::execute(bool test) {} + + File ImplArchiveExtractor::execute(uint32_t index, bool test) + { + const UInt32 indices[] = {index}; + file.reset(new FileWriteStream); + file->AddRef(); + CheckCom(arc->Extract(indices, 1, test, static_cast(this)), "Extract"); + file->seek(0, IFile::Whence::set); + + return std::unique_ptr(file.release()); + } +} // namespace sevenzip diff --git a/src/7zip/Format.cpp b/src/7zip/Format.cpp new file mode 100644 index 0000000..7b1198e --- /dev/null +++ b/src/7zip/Format.cpp @@ -0,0 +1,81 @@ +#include "7zip-impl.hpp" +#include "exception.hpp" +#include "string.hpp" + +#include + +namespace sevenzip { + struct Guid: public GUID { + }; + + class ImplFormat: public IFormat { + public: + ImplFormat(const ImplLib& lib, size_t idx) + : _lib(lib) + , _idx(idx) + { + std::string result; + _lib.get_prop(_idx, NArchive::NHandlerPropID::kExtension, result); + _ext_def = split(" ", result); + + result.clear(); + _lib.get_prop(_idx, NArchive::NHandlerPropID::kAddExtension, result); + _ext_add = split(" ", result); + } + + std::string name() const noexcept override; + const Extensions& default_extension() const noexcept override; + const Extensions& additional_extension() const noexcept override; + const Guid* guid() const noexcept override; + bool updatable() const noexcept override; + + private: + const ImplLib& _lib; + size_t _idx; + mutable Guid _guid; + Extensions _ext_def; + Extensions _ext_add; + }; + + std::string ImplFormat::name() const noexcept + { + std::string result; + CheckCom(_lib.get_prop(_idx, NArchive::NHandlerPropID::kName, result), "get_prop"); + return result; + } + + const Extensions& ImplFormat::default_extension() const noexcept + { + return _ext_def; + } + + const Extensions& ImplFormat::additional_extension() const noexcept + { + return _ext_add; + } + + const Guid* ImplFormat::guid() const noexcept + { + NWindows::NCOM::CPropVariant prop; + if (_lib.get_prop(_idx, NArchive::NHandlerPropID::kClassID, prop) == S_OK) + std::memcpy(&_guid, prop.bstrVal, sizeof(GUID)); + return &_guid; + } + + bool ImplFormat::updatable() const noexcept + { + bool result = false; + CheckCom(_lib.get_prop(_idx, NArchive::NHandlerPropID::kUpdate, result), "get_prop"); + return result; + } + + void ImplLib::fill_formats() + { + auto num_formats = UInt32(); + CheckCom(GetNumberOfFormats(&num_formats), "GetNumberOfFormats"); + + for (size_t idx = 0; idx < num_formats; ++idx) { + m_formats.emplace_back(std::make_shared(*this, idx)); + } + } +} // namespace sevenzip diff --git a/src/7zip/Library.cpp b/src/7zip/Library.cpp new file mode 100644 index 0000000..56448e3 --- /dev/null +++ b/src/7zip/Library.cpp @@ -0,0 +1,79 @@ +#ifndef INITGUID +# define INITGUID +#endif + +#include "CPP/myWindows/StdAfx.h" +#include "CPP/Windows/Defs.h" +#include "CPP/7zip/MyVersion.h" + +#include "7zip-impl.hpp" +#include "string.hpp" + +namespace sevenzip { + Lib open(const Path& path) + { + return std::make_unique(path); + } + + using namespace NWindows::NCOM; + ImplLib::~ImplLib() noexcept {} + + ImplLib::ImplLib(const Path& path) + : library::ImplDynamic(path) + { + GET_LIBRARY_SYM(Func_, CreateObject); + GET_LIBRARY_SYM(Func_, GetMethodProperty); + GET_LIBRARY_SYM(Func_, GetNumberOfFormats); + GET_LIBRARY_SYM(Func_, GetNumberOfMethods); + GET_LIBRARY_SYM_NT(Func_, GetHandlerProperty); + GET_LIBRARY_SYM_NT(Func_, GetHandlerProperty2); + GET_LIBRARY_SYM_NT(Func_, SetLargePageMode); + + // CheckApiThrowError(GetHandlerProperty2 || GetHandlerProperty, + + fill_formats(); + fill_methods(); + } + + const Path& ImplLib::path() const noexcept + { + return library::ImplDynamic::path(); + } + + const Formats& ImplLib::formats() const noexcept + { + return m_formats; + } + + const Methods& ImplLib::methods() const noexcept + { + return m_methods; + } + + Archive ImplLib::open(const Path& path, const IOpenCallback& callback, flags_type flags) const + { + return std::make_unique(*this, path, callback, flags); + } + + HRESULT ImplLib::get_prop(UInt32 index, PROPID prop_id, NWindows::NCOM::CPropVariant& prop) const noexcept + { + return GetHandlerProperty2 ? GetHandlerProperty2(index, prop_id, &prop) : GetHandlerProperty(prop_id, &prop); + } + + HRESULT ImplLib::get_prop(UInt32 index, PROPID prop_id, bool& value) const noexcept + { + CPropVariant prop; + auto res = get_prop(index, prop_id, prop); + if (res == S_OK) value = prop.boolVal; + return res; + } + + HRESULT ImplLib::get_prop(UInt32 index, PROPID prop_id, std::string& value) const noexcept + { + CPropVariant prop; + auto res = get_prop(index, prop_id, prop); + if (res == S_OK && prop.bstrVal) value = utf8((const wchar_t*)prop.bstrVal); + + return res; + } +} // namespace sevenzip diff --git a/src/7zip/Method.cpp b/src/7zip/Method.cpp new file mode 100644 index 0000000..826aa08 --- /dev/null +++ b/src/7zip/Method.cpp @@ -0,0 +1,39 @@ +#include "7zip-impl.hpp" +#include "exception.hpp" +#include "string.hpp" + +namespace sevenzip { + using namespace NWindows::NCOM; + + struct ImplMethod: public IMethod { + ImplMethod(const ImplLib& lib, size_t idx) + : _lib(lib) + , _idx(idx) + {} + + std::string name() const noexcept override; + + private: + const ImplLib& _lib; + size_t _idx; + }; + + std::string ImplMethod::name() const noexcept + { + CPropVariant prop; + CheckCom(_lib.GetMethodProperty(_idx, 1, &prop), "GetMethodProperty"); + if (prop.bstrVal) return utf8((const wchar_t*)prop.bstrVal); + + return std::string(); + } + + void ImplLib::fill_methods() + { + auto num_methods = UInt32(); + CheckCom(GetNumberOfMethods(&num_methods), "GetNumberOfMethods"); + + for (size_t idx = 0; idx < num_methods; ++idx) { + m_methods.emplace_back(std::make_unique(*this, idx)); + } + } +} // namespace sevenzip diff --git a/src/7zip/ReadStream.cpp b/src/7zip/ReadStream.cpp new file mode 100644 index 0000000..1d339c3 --- /dev/null +++ b/src/7zip/ReadStream.cpp @@ -0,0 +1,77 @@ +#include "7zip-impl.hpp" +#include "exception.hpp" + +namespace sevenzip { + class FileReadStream::FileHandle: public std::FILE { + }; + + HRESULT check_error(FileReadStream::FileHandle* file) + { + if (std::ferror(file)) return 1; + return S_OK; + } + + ULONG WINAPI FileReadStream::AddRef() + { + return UnknownImp::AddRef(); + } + + ULONG WINAPI FileReadStream::Release() + { + return UnknownImp::Release(); + } + + HRESULT WINAPI FileReadStream::QueryInterface(REFIID riid, void** object) + { + HRESULT ret = S_OK; + if (object && (riid == IID_IInStream)) { + AddRef(); + *object = static_cast(this); + } else if (object && (riid == IID_ISequentialInStream)) { + AddRef(); + *object = static_cast(this); + } else { + ret = UnknownImp::QueryInterface(riid, object); + } + return ret; + } + + const Path& FileReadStream::path() const noexcept + { + return _path; + } + + const Stat& FileReadStream::stat() const noexcept + { + return _stat; + } + + FileReadStream::~FileReadStream() noexcept + { + std::fclose(_file); + } + + FileReadStream::FileReadStream(const Path& path) + : _path(path) + , _file(static_cast(std::fopen(_path.c_str(), "r"))) + { + CheckErrno(_file, std::string("fopen: ") + path.string()); + lstat(_path.c_str(), &_stat); + } + + HRESULT WINAPI FileReadStream::Read(void* data, UInt32 size, UInt32* processedSize) + { + auto read = std::fread(data, 1, size, _file); + if (processedSize) *processedSize = read; + return check_error(_file); + } + + HRESULT WINAPI FileReadStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64* newPosition) + { + if (std::fseek(_file, offset, seekOrigin) == 0) { + if (newPosition) *newPosition = std::ftell(_file); + return S_OK; + } + return check_error(_file); + } +} // namespace sevenzip diff --git a/src/7zip/WriteStream.cpp b/src/7zip/WriteStream.cpp new file mode 100644 index 0000000..4dfb4f0 --- /dev/null +++ b/src/7zip/WriteStream.cpp @@ -0,0 +1,91 @@ +#include "7zip-impl.hpp" +#include "exception.hpp" + +namespace sevenzip { + class FileWriteStream::FileHandle: public std::FILE { + }; + + HRESULT check_error(FileWriteStream::FileHandle* file) + { + if (std::ferror(file)) return 1; + return S_OK; + } + + FileWriteStream::~FileWriteStream() noexcept + { + std::fclose(_file); + } + + FileWriteStream::FileWriteStream() + : _file(static_cast(std::tmpfile())) + { + CheckErrno(_file, "tmpfile: "); + } + + ULONG WINAPI FileWriteStream::AddRef() + { + return UnknownImp::AddRef(); + } + + ULONG WINAPI FileWriteStream::Release() + { + return UnknownImp::Release(); + } + + HRESULT WINAPI FileWriteStream::QueryInterface(REFIID riid, void** object) + { + HRESULT ret = S_OK; + + if (object && (riid == IID_IOutStream)) { + *object = static_cast(this); + AddRef(); + } else if (object && (riid == IID_ISequentialOutStream)) { + *object = static_cast(this); + AddRef(); + } else { + ret = UnknownImp::QueryInterface(riid, object); + } + return ret; + } + + HRESULT WINAPI FileWriteStream::Write(const void* data, UInt32 size, UInt32* processedSize) + { + DWORD written = std::fwrite(data, 1, size, _file); + if (processedSize) *processedSize = written; + return check_error(_file); + } + + HRESULT WINAPI FileWriteStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64* newPosition) + { + std::fseek(_file, offset, seekOrigin); + auto pos = std::ftell(_file); + if (newPosition) *newPosition = pos; + return check_error(_file); + } + + HRESULT WINAPI FileWriteStream::SetSize(UInt64 newSize) + { + auto pos = std::ftell(_file); + ftruncate(_file->_fileno, newSize); + std::fseek(_file, pos, SEEK_SET); + return check_error(_file); + } + + uint64_t FileWriteStream::read(void* data, uint64_t size) + { + auto read = std::fread(data, 1, size, _file); + return read; + } + + uint64_t FileWriteStream::write(const void* data, uint64_t size) + { + auto written = std::fwrite(data, 1, size, _file); + return written; + } + + uint64_t FileWriteStream::seek(uint64_t pos, Whence whence) + { + std::fseek(_file, pos, whence); + return std::ftell(_file); + } +} // namespace sevenzip diff --git a/src/7zip/com.cpp b/src/7zip/com.cpp new file mode 100644 index 0000000..29c514a --- /dev/null +++ b/src/7zip/com.cpp @@ -0,0 +1,47 @@ +#include "com.hpp" + +namespace com { + HRESULT ConvertErrorToHRESULT(LONG error) + { + return (error == 0) ? S_OK : HRESULT_FROM_WIN32(error); + } + + HRESULT ConvertBoolToHRESULT(bool result) + { + return result ? S_OK : ConvertErrorToHRESULT(::GetLastError()); + } + + UnknownImp::UnknownImp() + : _ref_counter(1) + {} + + uint32_t WINAPI UnknownImp::AddRef() + { + return ++_ref_counter; + } + + ULONG WINAPI UnknownImp::Release() + { + if (--_ref_counter) { + return use_count(); + } + delete this; + return 0; + } + + HRESULT WINAPI UnknownImp::QueryInterface(REFIID riid, void** object) + { + if (object && (riid == IID_IUnknown)) { + *object = static_cast(this); + AddRef(); + return S_OK; + } + if (object) *object = nullptr; + return E_NOINTERFACE; + } + + ULONG UnknownImp::use_count() const + { + return _ref_counter.load(); + } +} // namespace com diff --git a/src/exception.cpp b/src/exception.cpp new file mode 100644 index 0000000..dbe78e6 --- /dev/null +++ b/src/exception.cpp @@ -0,0 +1,40 @@ +#include "exception.hpp" +#include + +#include "CPP/Common/MyWindows.h" + +namespace exception { + void HiddenFunctions::ThrowErrnoFunc(const std::string& str) + { + throw std::runtime_error(str + " [" + std::to_string(errno) + "]: " + strerror(errno)); + } + + void HiddenFunctions::ThrowErrnoFunc(const std::string& str, const char* file, size_t line, const char* func) + { + throw std::runtime_error(str + " [" + std::to_string(errno) + "]: " + strerror(errno) + "\n " + func + ":" + + std::to_string(line) + "\n " + file); + } + + void HiddenFunctions::ThrowResultFunc(const std::string& str) + { + throw std::runtime_error(str); + } + + void HiddenFunctions::ThrowResultFunc(const std::string& str, const char* file, size_t line, const char* func) + { + throw std::runtime_error(str + "\n " + func + ":" + std::to_string(line) + "\n " + file); + } + + HRESULT HiddenFunctions::CheckComFunc(HRESULT res, const std::string& str) + { + if (FAILED(res)) throw std::runtime_error(str); + return res; + } + + HRESULT HiddenFunctions::CheckComFunc(HRESULT res, const std::string& str, const char* file, size_t line, + const char* func) + { + if (FAILED(res)) throw std::runtime_error(str + "\n " + func + ":" + std::to_string(line) + "\n " + file); + return res; + } +} // namespace exception diff --git a/src/fuse3.cpp b/src/fuse3.cpp new file mode 100644 index 0000000..5f52bb1 --- /dev/null +++ b/src/fuse3.cpp @@ -0,0 +1,251 @@ +#include "fuse3.hpp" +#include "exception.hpp" +#include "pattern.hpp" +#include "string.hpp" +#include "version.hpp" + +#include +#include +#include +#include +#include + +static const fuse_opt opts_spec[] = {FUSE_OPT_END}; + +enum arg_status : int { + ARG_DISCARD = 0, + ARG_KEEP = 1, + ARG_ERROR = -1, +}; + +struct Cache { + using FileTree = std::map>; + sevenzip::IArchive* arc; + FileTree tree; +}; + +class Fuse::Params: public fuse_cmdline_opts { +public: + ~Params(); + Params(int argc, char** argv); + + void print_usage(); + static int process_arg(Params* fuse, const char* arg, int key, struct fuse_args* outargs); + + fuse_args args; + std::vector cli_args; +}; + +Fuse::Params::~Params() +{ + free(mountpoint); +} + +Fuse::Params::Params(int argc, char** argv) +{ + mountpoint = nullptr; + args = FUSE_ARGS_INIT(argc, argv); + + CheckResult(fuse_opt_parse(&args, this, opts_spec, (fuse_opt_proc_t)&process_arg) != -1, "fuse_opt_parse"); + + CheckResult(fuse_parse_cmdline(&args, this) == 0, "fuse_parse_cmdline"); + + if (show_version) { + printf("%s\n", PROJECT_VERSION); + // printf("FUSE library version %s\n", fuse_pkgversion()); + // fuse_lowlevel_version(); + exit(0); + } else if (show_help) { + print_usage(); + } else if (!mountpoint) { + fprintf(stderr, "error: no mountpoint specified\n"); + exit(0); + } +} + +void Fuse::Params::print_usage() +{ + printf("usage: fuse3-7z [options] \n\n"); + fuse_cmdline_help(); + fuse_lib_help(&args); + exit(0); +} + +int Fuse::Params::process_arg(Fuse::Params* fuse, const char* arg, int key, struct fuse_args* outargs) +{ + switch (key) { + case FUSE_OPT_KEY_NONOPT: + fuse->cli_args.emplace_back(arg); + if (fuse->cli_args.back().empty()) fuse->print_usage(); + if (fuse->cli_args.size() == 1) return ARG_DISCARD; + + default: return ARG_KEEP; + } +} + +class Fuse::Operations + : public fuse_operations + , public pattern::Uncopyable { +public: + Operations(); + + static void* cb_init(fuse_conn_info* conn, fuse_config* cfg); + static void cb_destroy(void*); + static int cb_getattr(const char* path, struct stat* stbuf, fuse_file_info* fi); + static int cb_open(const char* path, struct fuse_file_info* fi); + static int cb_release(const char* path, struct fuse_file_info* fi); + static int cb_read(const char* path, char* buf, size_t size, off_t offset, struct fuse_file_info* fi); + static int cb_readdir(const char*, void*, fuse_fill_dir_t, off_t, fuse_file_info*, fuse_readdir_flags); +}; + +Fuse::Operations::Operations() +{ + std::memset(this, 0, sizeof(*this)); + init = cb_init; + getattr = cb_getattr; + open = cb_open; + read = cb_read; + readdir = cb_readdir; + release = cb_release; +} + +void* Fuse::Operations::cb_init(fuse_conn_info*, fuse_config* cfg) +{ + // cfg->entry_timeout = NO_TIMEOUT; + // cfg->attr_timeout = NO_TIMEOUT; + // cfg->negative_timeout = 0; + + auto ctx = fuse_get_context(); + + return ctx->private_data; +} +void Fuse::Operations::cb_destroy(void*) {} + +int Fuse::Operations::cb_getattr(const char* path, struct stat* stbuf, fuse_file_info*) +{ + std::memset(stbuf, 0, sizeof(struct stat)); + + Cache* cache = static_cast(fuse_get_context()->private_data); + auto el = cache->tree.find(path); + if (el == cache->tree.end()) return -ENOENT; + + *stbuf = el->second.second; + return 0; +} + +int Fuse::Operations::cb_open(const char* path, fuse_file_info* fi) +{ + Cache* cache = static_cast(fuse_get_context()->private_data); + auto el = cache->tree.find(path); + if (el == cache->tree.end()) return -ENOENT; + + auto override_max_size = std::getenv("FUSE3_P7ZIP_MAX_OPEN_SIZE"); + if (override_max_size) { + auto size = std::strtoll(override_max_size, nullptr, 10); + if (el->second.second.st_size > size) return -E2BIG; + } + + auto tmpfile = el->second.first.extract().release(); + fi->fh = reinterpret_cast(tmpfile); + + return 0; +} + +int Fuse::Operations::cb_release(const char*, struct fuse_file_info* fi) +{ + auto file = reinterpret_cast(fi->fh); + delete file; + return 0; +} + +int Fuse::Operations::cb_read(const char* path, char* buf, size_t size, off_t offset, struct fuse_file_info* fi) +{ + auto file = reinterpret_cast(fi->fh); + file->seek(offset, sevenzip::IFile::Whence::set); + return file->read(buf, size); +} + +int Fuse::Operations::cb_readdir(const char* p, void* buf, fuse_fill_dir_t filler, off_t, fuse_file_info*, + fuse_readdir_flags) +{ + Cache* cache = static_cast(fuse_get_context()->private_data); + if (strcmp("/", p) != 0 && !cache->tree.contains(p)) return -ENOTDIR; + + auto path = sevenzip::Path(p); + + filler(buf, ".", NULL, 0, FUSE_FILL_DIR_PLUS); + filler(buf, "..", NULL, 0, FUSE_FILL_DIR_PLUS); + for (auto& it : cache->tree) { + auto parent = it.first.parent_path(); + auto name = it.first.filename(); + if (path == parent && !name.empty()) { + filler(buf, name.c_str(), &it.second.second, 0, FUSE_FILL_DIR_PLUS); + } + } + return 0; +} + +Fuse::~Fuse() +{ + if (fuse) fuse_destroy(fuse); +} + +Fuse::Fuse(int argc, char** argv) + : fuse() + , _params(std::make_unique(argc, argv)) + , _operations(std::make_unique()) +{} + +const std::string& Fuse::path() const +{ + return _params->cli_args[0]; +} + +ssize_t Fuse::execute(sevenzip::IArchive* arc) +{ + static auto cache = Cache{arc, Cache::FileTree()}; + auto root = sevenzip::Path("/"); + auto root_stat = arc->stat(); + root_stat.st_mode = (root_stat.st_mode & ~S_IFMT) | S_IFDIR; + cache.tree.emplace(root, std::make_pair(arc->end(), root_stat)); + for (auto it = arc->begin(); it != arc->end(); ++it) { + auto path = root / it.path(); + auto name = sevenzip::Path(root == path && it.name().empty() ? arc->proposed_name() : it.name()); + if (!it.extension().empty()) name += "." + it.extension(); + + if (!name.empty()) path /= name; + + auto file_stat = arc->stat(); + file_stat.st_mode &= ~S_IFMT; + file_stat.st_size = it.size(); + if (it.is_dir()) { + file_stat.st_mode |= S_IFDIR; + } else { + file_stat.st_mode |= S_IFREG; + } + cache.tree.emplace(path, std::make_pair(it, file_stat)); + } + + fuse = fuse_new(&_params->args, _operations.get(), sizeof(fuse_operations), &cache); + + if (fuse_mount(fuse, _params->mountpoint) != 0) { + exit(1); + } + + if (fuse_daemonize(_params->foreground) != 0) { + exit(1); + } + + auto se = fuse_get_session(fuse); + if (fuse_set_signal_handlers(se) != 0) { + exit(1); + } + + auto ret = fuse_loop(fuse); + + fuse_remove_signal_handlers(se); + + fuse_unmount(fuse); + + return ret; +} diff --git a/src/include/7zip-impl.hpp b/src/include/7zip-impl.hpp new file mode 100644 index 0000000..ad2c552 --- /dev/null +++ b/src/include/7zip-impl.hpp @@ -0,0 +1,221 @@ +#ifndef __FUSE3_7Z__7ZIP_PRIVATE_HPP_ +#define __FUSE3_7Z__7ZIP_PRIVATE_HPP_ + +#include "7zip.hpp" +#include "com.hpp" +#include "exception.hpp" +#include "library-impl.hpp" + +#define ENV_HAVE_WCTYPE_H +#include "CPP/myWindows/StdAfx.h" +#include "CPP/Windows/Defs.h" +#include "CPP/7zip/MyVersion.h" +#include "CPP/7zip/Archive/IArchive.h" +#include "CPP/7zip/ICoder.h" +#include "CPP/7zip/IPassword.h" +#include "CPP/Windows/PropVariant.h" + +#define UNUSED(val) ((void)val) + +namespace sevenzip { + class FileReadStream + : public IInStream + , private com::UnknownImp { + public: + class FileHandle; + + ~FileReadStream() noexcept; + explicit FileReadStream(const Path& path); + + const Path& path() const noexcept; + const Stat& stat() const noexcept; + + // Unknown + ULONG WINAPI AddRef() override; + ULONG WINAPI Release() override; + HRESULT WINAPI QueryInterface(REFIID riid, void** object) override; + + // ISequentialInStream + HRESULT WINAPI Read(void* data, UInt32 size, UInt32* processedSize) override; + + // IInStream + HRESULT WINAPI Seek(Int64 offset, UInt32 seekOrigin, UInt64* newPosition) override; + + private: + Path _path; + Stat _stat; + FileHandle* _file; + }; + + class FileWriteStream + : public IOutStream + , public IFile + , private com::UnknownImp { + public: + class FileHandle; + + ~FileWriteStream() noexcept; + FileWriteStream(); + + // Unknown + ULONG WINAPI AddRef() override; + ULONG WINAPI Release() override; + HRESULT WINAPI QueryInterface(REFIID riid, void** object) override; + + // ISequentialOutStream + HRESULT WINAPI Write(const void* data, UInt32 size, UInt32* processedSize) override; + + // IOutStream + HRESULT WINAPI Seek(Int64 offset, UInt32 seekOrigin, UInt64* newPosition) override; + HRESULT WINAPI SetSize(UInt64 newSize) override; + + // IFile + uint64_t read(void* data, uint64_t size) override; + uint64_t write(const void* data, uint64_t size) override; + uint64_t seek(uint64_t pos, Whence whence) override; + + private: + FileHandle* _file; + }; + + class ImplLib + : public ILib + , private library::ImplDynamic { + public: + DEFINE_SYM(Func_, CreateObject); + DEFINE_SYM(Func_, GetHandlerProperty); + DEFINE_SYM(Func_, GetHandlerProperty2); + DEFINE_SYM(Func_, GetMethodProperty); + DEFINE_SYM(Func_, GetNumberOfFormats); + DEFINE_SYM(Func_, GetNumberOfMethods); + DEFINE_SYM(Func_, SetLargePageMode); + + ~ImplLib() noexcept; + ImplLib(const Path& path); + + const Path& path() const noexcept override; + const Formats& formats() const noexcept override; + const Methods& methods() const noexcept override; + + Archive open(const Path& path, const IOpenCallback& callback, flags_type flags) const override; + + HRESULT get_prop(UInt32 index, PROPID prop_id, NWindows::NCOM::CPropVariant& prop) const noexcept; + HRESULT get_prop(UInt32 index, PROPID prop_id, bool& value) const noexcept; + HRESULT get_prop(UInt32 index, PROPID prop_id, std::string& value) const noexcept; + + private: + void fill_formats(); + void fill_methods(); + + Formats m_formats; + Methods m_methods; + }; + + class ImplArchive + : public IArchive + , public IArchiveOpenCallback + , public ICryptoGetTextPassword + , private com::UnknownImp { + public: + ~ImplArchive() noexcept; + ImplArchive(const ImplLib& lib, const Path& path, const IOpenCallback& callback, + flags_type flasgs = flags_type()); + + // IUnknown + ULONG WINAPI AddRef() override; + ULONG WINAPI Release() override; + HRESULT WINAPI QueryInterface(REFIID riid, void** object) override; + + // IArchiveOpenCallback + HRESULT WINAPI SetTotal(const UInt64* files, const UInt64* bytes) override; + HRESULT WINAPI SetCompleted(const UInt64* files, const UInt64* bytes) override; + + // ICryptoGetTextPassword + HRESULT WINAPI CryptoGetTextPassword(BSTR* password) override; + + const Path& path() const noexcept override; + const Stat& stat() const noexcept override; + const Format& format() const noexcept override; + std::string proposed_name() const noexcept override; + + flags_type flags() const noexcept override; + bool empty() const noexcept override; + size_t size() const noexcept override; + + const_iterator begin() const noexcept override; + const_iterator end() const noexcept override; + const_iterator at(size_t index) const override; + + com::Object operator->() const; + operator com::Object() const; + + protected: + void open_archive(const ImplLib& lib); + void init_props(); + + const IOpenCallback& callback; + com::Object _stream; + com::Object _arc; + Format _format; + UInt32 _size; + flags_type _flags; + }; + + struct IArchive::ci_iterator::Impl { + template static std::unique_ptr create(Args&&... args) + { + return std::make_unique(std::forward(args)...); + } + + Impl(); + explicit Impl(const ImplArchive& seq); + Impl(const ImplArchive& seq, UInt32 index); + + HRESULT get_prop(PROPID id, NWindows::NCOM::CPropVariant& prop) const; + File extract(const IExtractCallback& callback) const; + + const ImplArchive* _seq; + UInt32 _index; + bool _end; + }; + + class ImplArchiveExtractor + : public IArchiveExtractor + , public IArchiveExtractCallback + , public ICryptoGetTextPassword + , private com::UnknownImp { + public: + ~ImplArchiveExtractor() noexcept; + ImplArchiveExtractor(const ImplArchive& arc, const IExtractCallback& callback) noexcept; + + // IUnknown + ULONG WINAPI AddRef() override; + ULONG WINAPI Release() override; + HRESULT WINAPI QueryInterface(REFIID riid, void** object) override; + + // IProgress + HRESULT WINAPI SetTotal(UInt64 size) override; + HRESULT WINAPI SetCompleted(const UInt64* completeValue) override; + + // IArchiveExtractCallback + HRESULT WINAPI GetStream(UInt32 index, ISequentialOutStream** outStream, Int32 askExtractMode) override; + HRESULT WINAPI PrepareOperation(Int32 askExtractMode) override; + HRESULT WINAPI SetOperationResult(Int32 resultEOperationResult) override; + + // ICryptoGetTextPassword + HRESULT WINAPI CryptoGetTextPassword(BSTR* pass) override; + + // IArchiveExtractor + void execute(bool test) override; + File execute(uint32_t index, bool test); + + private: + const ImplArchive& arc; + const IExtractCallback& callback; + Path m_dest; + UInt64 total; + std::unique_ptr file; + }; +} // namespace sevenzip + +#endif diff --git a/src/include/com.hpp b/src/include/com.hpp new file mode 100644 index 0000000..110bf48 --- /dev/null +++ b/src/include/com.hpp @@ -0,0 +1,183 @@ +#ifndef __FUSE3_7Z__COM_HPP_ +#define __FUSE3_7Z__COM_HPP_ + +#include + +#include "CPP/myWindows/StdAfx.h" + +namespace com { + HRESULT ConvertErrorToHRESULT(LONG error); + HRESULT ConvertBoolToHRESULT(bool result); + + struct UnknownImp: public IUnknown { + virtual ~UnknownImp() = default; + UnknownImp(); + + ULONG use_count() const; + ULONG WINAPI AddRef() override; + ULONG WINAPI Release() override; + HRESULT WINAPI QueryInterface(REFIID riid, void** ppvObject) override; + + private: + std::atomic _ref_counter; + }; + + template class Object { + using this_type = Object; + using pointer = Interface*; + using const_pointer = const Interface*; + + public: + ~Object(); + + Object() noexcept; + explicit Object(const_pointer param); + Object(const this_type& other) noexcept; + Object(this_type&& other) noexcept; + template Object(const Object& other); + + this_type& operator=(const this_type& other) noexcept; + this_type& operator=(this_type&& other) noexcept; + template this_type& operator=(const Object& other); + + void release(); + + explicit operator bool() const noexcept + { + return ptr; + } + operator pointer() const noexcept + { + return ptr; + } + + pointer* operator&(); + pointer operator->() const noexcept; + pointer get_ptr() const noexcept + { + return ptr; + } + + bool operator==(const pointer other) const noexcept + { + return ptr == other; + } + bool operator==(const this_type& other) const noexcept + { + return ptr == other.ptr; + } + + bool operator!=(const pointer other) const noexcept + { + return ptr != other; + } + bool operator!=(const this_type& other) const noexcept + { + return ptr != other.ptr; + } + + void attach(pointer& other); + void detach(pointer& other) noexcept; + + void swap(this_type& other) noexcept; + + private: + pointer ptr; + }; + + template Object::~Object() + { + release(); + } + + template Object::Object() noexcept + : ptr() + {} + + template Object::Object(const_pointer other) + : ptr(const_cast(other)) + {} + + template Object::Object(const this_type& other) noexcept + : ptr(other.ptr) + { + if (ptr) ptr->AddRef(); + } + + template Object::Object(this_type&& other) noexcept + : ptr(other.ptr) + { + other.ptr = nullptr; + } + + template template + Object::Object(const Object& other) + : ptr(static_cast(other.ptr)) + { + if (ptr) ptr->AddRef(); + } + + template + typename Object::this_type& Object::operator=(const this_type& other) noexcept + { + if (ptr != other.ptr) this_type(other).swap(*this); + return *this; + } + + template + typename Object::this_type& Object::operator=(this_type&& other) noexcept + { + if (ptr != other.ptr) this_type(std::move(other)).swap(*this); + return *this; + } + + template template + typename Object::this_type& Object::operator=(const Object& other) + { + if (ptr != static_cast(other)) { // FIXME + this_type tmp(other); + swap(tmp); + } + return *this; + } + + template void Object::release() + { + if (ptr) { + ptr->Release(); + ptr = nullptr; + } + } + + template typename Object::pointer* Object::operator&() + { + release(); + return &ptr; + } + + template typename Object::pointer Object::operator->() const noexcept + { + return ptr; + } + + template void Object::attach(pointer& other) + { + release(); + ptr = other; + other = nullptr; + } + + template void Object::detach(pointer& other) noexcept + { + other = ptr; + ptr = nullptr; + } + + template void Object::swap(this_type& other) noexcept + { + using std::swap; + swap(ptr, other.ptr); + } +} // namespace com + +#endif diff --git a/src/include/fuse3.hpp b/src/include/fuse3.hpp new file mode 100644 index 0000000..9c91c8f --- /dev/null +++ b/src/include/fuse3.hpp @@ -0,0 +1,32 @@ +#ifndef __FUSE3_7Z__FUSE3_HPP__ +#define __FUSE3_7Z__FUSE3_HPP__ + +#define FUSE_USE_VERSION 35 + +#include // +#include + +#include "7zip.hpp" + +#include +#include +#include + +class Fuse { +public: + ~Fuse(); + Fuse(int argc, char** argv); + + ssize_t execute(sevenzip::IArchive* archive); + const std::string& path() const; + +private: + class Params; + class Operations; + + struct fuse* fuse; + std::unique_ptr _params; + std::unique_ptr _operations; +}; + +#endif diff --git a/src/include/library-impl.hpp b/src/include/library-impl.hpp new file mode 100644 index 0000000..4ae9de2 --- /dev/null +++ b/src/include/library-impl.hpp @@ -0,0 +1,35 @@ +#ifndef __FUSE3_7Z__LIBRARY_IMPL_HPP_ +#define __FUSE3_7Z__LIBRARY_IMPL_HPP_ + +#include "library.hpp" +#include "pattern.hpp" + +#define DEFINE_SYM(prefix, name) prefix##name name; +#define GET_LIBRARY_SYM(prefix, name) name = (prefix##name)get_sym(#name); +#define GET_LIBRARY_SYM_NT(prefix, name) name = (prefix##name)get_sym_nt(#name); + +namespace library { + using Handle = void*; + + class ImplDynamic + : public IDynamic + , public pattern::Uncopyable { + using this_type = ImplDynamic; + + public: + ~ImplDynamic() noexcept; + ImplDynamic(const Path& path, flags_type flags = flags_type()); + + const Path& path() const noexcept override; + + Symbol get_sym(const char* name) const override; + Symbol get_sym_nt(const char* name) const noexcept override; + + private: + Path _path; + flags_type _flags; + Handle _hnd; + }; +} // namespace library + +#endif diff --git a/src/library.cpp b/src/library.cpp new file mode 100644 index 0000000..fbc081d --- /dev/null +++ b/src/library.cpp @@ -0,0 +1,57 @@ +#include "exception.hpp" +#include "library-impl.hpp" + +#include + +#ifdef NDEBUG +void ThrowLibraryError(const char* str) +{ + throw std::runtime_error(std::string(str) + " " + dlerror()); +} +#else +void ThrowLibraryError(const char* str, const char* file, size_t line, const char* func) +{ + throw std::runtime_error(std::string(str) + " " + dlerror()); +} +#endif + +namespace library { + Dynamic open(const Path& path, flags_type flags) + { + return std::make_unique(path, flags); + } + + ImplDynamic::~ImplDynamic() noexcept + { + dlclose(_hnd); + } + + ImplDynamic::ImplDynamic(const Path& path, flags_type flags) + : _path(path) + , _flags(flags | RTLD_NOW) + , _hnd(dlopen(path.c_str(), _flags)) + { + CheckPointer(_hnd, ThrowLibraryError, "dlopen"); + } + + const Path& ImplDynamic::path() const noexcept + { + //Dl_info info{}; + //if (dladdr(m_hnd, &info) && info.dli_fname) { + //return info.dli_fname; + //} + return _path; + } + + Symbol ImplDynamic::get_sym(const char* name) const + { + auto ptr = get_sym_nt(name); + CheckPointer(ptr, ThrowLibraryError, "dlsym"); + return ptr; + } + + Symbol ImplDynamic::get_sym_nt(const char* name) const noexcept + { + return dlsym(_hnd, name); + } +} // namespace library diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..0983a4b --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,22 @@ +#include "7zip.hpp" +#include "fuse3.hpp" + +// TODO +// priority format +// rar not working +// verbose version + +int main(int argc, char** argv, char** env) +try { + auto override_library = std::getenv("FUSE3_P7ZIP_LIBRARY"); + auto lib_path = override_library ? override_library : "/usr/lib/p7zip/7z.so"; + auto lib = sevenzip::open(lib_path); + + Fuse loop(argc, argv); + auto arc = lib->open(loop.path(), sevenzip::EmptyOpenCallback()); + + return loop.execute(arc.get()); +} catch (std::exception& e) { + fprintf(stderr, "Critical error:\n %s\n", e.what()); + return 1; +} diff --git a/src/string.cpp b/src/string.cpp new file mode 100644 index 0000000..cd1ba4d --- /dev/null +++ b/src/string.cpp @@ -0,0 +1,59 @@ +#include "string.hpp" +#include "exception.hpp" +#include +#include +#include + +std::string utf8raw(const std::wstring& wstr, const char* encoding) +{ + return utf8(std::string(wstr.begin(), wstr.end()).c_str(), encoding); +} + +std::string utf8(const wchar_t* wstr) +{ + auto conv = std::unique_ptr(iconv_open("UTF-8", "UTF-32"), &iconv_close); + CheckErrno(conv.get() != reinterpret_cast(-1), "iconv_open: "); + + size_t in_size = std::wcslen(wstr) * sizeof(wchar_t); + size_t res_size = in_size * 6; + auto result = std::unique_ptr(new char[res_size + 1]()); + + auto in_ptr = (char*)wstr; + auto res_ptr = result.get(); + + iconv(conv.get(), NULL, NULL, &res_ptr, &res_size); + CheckErrno(iconv(conv.get(), &in_ptr, &in_size, &res_ptr, &res_size) != static_cast(-1), "iconv: "); + + return std::string(result.get()); +} + +std::string utf8(const char* str, const char* encoding) +{ + // https://gist.github.com/hakre/4188459 + auto conv = std::unique_ptr(iconv_open("UTF-8", encoding), &iconv_close); + CheckErrno(conv.get() != reinterpret_cast(-1), "iconv_open: "); + + size_t in_size = std::strlen(str); + size_t res_size = in_size * 6; + auto result = std::unique_ptr(new char[res_size + 1]()); + + auto in_ptr = const_cast(str); + auto res_ptr = result.get(); + + iconv(conv.get(), NULL, NULL, &res_ptr, &res_size); + CheckErrno(iconv(conv.get(), &in_ptr, &in_size, &res_ptr, &res_size) != static_cast(-1), "iconv: "); + + return std::string(result.get()); +} + +std::vector split(const std::string& d, std::string str) +{ + auto result = std::vector(); + auto pos = std::string::size_type(); + while ((pos = str.find(d)) != std::string::npos) { + result.emplace_back(str.substr(0, pos)); + str.erase(0, pos + d.length()); + } + result.emplace_back(str); + return result; +} diff --git a/t/tidy b/t/tidy new file mode 100755 index 0000000..bd01275 --- /dev/null +++ b/t/tidy @@ -0,0 +1,7 @@ +#!/usr/bin/env bash + +set -Eeuo pipefail + +cp -f "$(git rev-parse --show-toplevel)/.clang-format" /tmp + +tidyall -a -j 4 diff --git a/tools/git-hooks/pre-commit b/tools/git-hooks/pre-commit new file mode 100755 index 0000000..e665a7d --- /dev/null +++ b/tools/git-hooks/pre-commit @@ -0,0 +1,9 @@ +#!/usr/bin/env perl + +use v5.22; +use strict; +use warnings; + +use Code::TidyAll::Git::Precommit; + +Code::TidyAll::Git::Precommit->check(); diff --git a/tools/setup-hooks b/tools/setup-hooks new file mode 100755 index 0000000..0b0044f --- /dev/null +++ b/tools/setup-hooks @@ -0,0 +1,7 @@ +#!/usr/bin/env bash + +set -Eeuo pipefail + +chmod +x "$(git rev-parse --show-toplevel)/tools/git-hooks/pre-commit" + +ln -s "../../tools/git-hooks/pre-commit" "$(git rev-parse --show-toplevel)/.git/hooks/"