From bf8de05b8ca8d8e4d379845151abc1c3338a862d Mon Sep 17 00:00:00 2001 From: SimonShin <1847401037@qq.com> Date: Tue, 12 Dec 2023 16:56:18 +0800 Subject: [PATCH] =?UTF-8?q?=E5=88=9D=E5=A7=8B=E5=8C=96rpm=E5=8C=85?= =?UTF-8?q?=E7=BC=96=E8=AF=91=E9=85=8D=E7=BD=AE=E4=BB=A5=E5=8F=8A=E6=BA=90?= =?UTF-8?q?=E7=A0=81=E5=8C=85?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- add-lzma-sdk-and-uadk-include-file.patch | 7276 ++++++++++++++++++++++ lzma2200_so.7z | Bin 0 -> 653953 bytes unizip-v0.0.3.zip | Bin 0 -> 207742 bytes unizip.spec | 75 + unizip.yaml | 5 + 5 files changed, 7356 insertions(+) create mode 100644 add-lzma-sdk-and-uadk-include-file.patch create mode 100644 lzma2200_so.7z create mode 100644 unizip-v0.0.3.zip create mode 100644 unizip.spec create mode 100644 unizip.yaml diff --git a/add-lzma-sdk-and-uadk-include-file.patch b/add-lzma-sdk-and-uadk-include-file.patch new file mode 100644 index 0000000..b1de863 --- /dev/null +++ b/add-lzma-sdk-and-uadk-include-file.patch @@ -0,0 +1,7276 @@ +From 4f1cab99673dc0410bbbb6fc233018ed884b1a54 Mon Sep 17 00:00:00 2001 +From: huangduirong +Date: Mon, 11 Dec 2023 23:26:43 +0800 +Subject: [PATCH] add lzma-sdk and uadk include file + +--- + src/lzma-sdk/C/7z.h | 204 ++++++++++ + src/lzma-sdk/C/7zAlloc.h | 19 + + src/lzma-sdk/C/7zBuf.h | 35 ++ + src/lzma-sdk/C/7zCrc.h | 25 ++ + src/lzma-sdk/C/7zFile.h | 91 +++++ + src/lzma-sdk/C/7zTypes.h | 529 +++++++++++++++++++++++++ + src/lzma-sdk/C/7zVersion.h | 27 ++ + src/lzma-sdk/C/Aes.h | 60 +++ + src/lzma-sdk/C/Alloc.h | 58 +++ + src/lzma-sdk/C/Bcj2.h | 146 +++++++ + src/lzma-sdk/C/Bra.h | 64 +++ + src/lzma-sdk/C/Compiler.h | 43 ++ + src/lzma-sdk/C/CpuArch.h | 442 +++++++++++++++++++++ + src/lzma-sdk/C/Delta.h | 19 + + src/lzma-sdk/C/DllSecur.h | 20 + + src/lzma-sdk/C/LzFind.h | 136 +++++++ + src/lzma-sdk/C/LzFindMt.h | 109 +++++ + src/lzma-sdk/C/LzHash.h | 34 ++ + src/lzma-sdk/C/Lzma2Dec.h | 120 ++++++ + src/lzma-sdk/C/Lzma2DecMt.h | 79 ++++ + src/lzma-sdk/C/Lzma2Enc.h | 55 +++ + src/lzma-sdk/C/Lzma86.h | 111 ++++++ + src/lzma-sdk/C/LzmaDec.h | 236 +++++++++++ + src/lzma-sdk/C/LzmaEnc.h | 78 ++++ + src/lzma-sdk/C/LzmaLib.h | 138 +++++++ + src/lzma-sdk/C/MtCoder.h | 141 +++++++ + src/lzma-sdk/C/MtDec.h | 202 ++++++++++ + src/lzma-sdk/C/Ppmd.h | 167 ++++++++ + src/lzma-sdk/C/Ppmd7.h | 181 +++++++++ + src/lzma-sdk/C/Precomp.h | 10 + + src/lzma-sdk/C/RotateDefs.h | 30 ++ + src/lzma-sdk/C/Sha256.h | 76 ++++ + src/lzma-sdk/C/Sort.h | 18 + + src/lzma-sdk/C/Threads.h | 232 +++++++++++ + src/lzma-sdk/C/Util/7z/Precomp.h | 10 + + src/lzma-sdk/C/Util/SfxSetup/Precomp.h | 10 + + src/lzma-sdk/C/Xz.h | 517 ++++++++++++++++++++++++ + src/lzma-sdk/C/XzCrc64.h | 26 ++ + src/lzma-sdk/C/XzEnc.h | 60 +++ + src/uadk/v1/uacce.h | 86 ++++ + src/uadk/v1/wd.h | 214 ++++++++++ + src/uadk/v1/wd_adapter.h | 75 ++++ + src/uadk/v1/wd_aead.h | 213 ++++++++++ + src/uadk/v1/wd_bmm.h | 50 +++ + src/uadk/v1/wd_cipher.h | 166 ++++++++ + src/uadk/v1/wd_comp.h | 256 ++++++++++++ + src/uadk/v1/wd_dh.h | 91 +++++ + src/uadk/v1/wd_digest.h | 168 ++++++++ + src/uadk/v1/wd_ecc.h | 273 +++++++++++++ + src/uadk/v1/wd_rng.h | 76 ++++ + src/uadk/v1/wd_rsa.h | 148 +++++++ + src/uadk/v1/wd_sgl.h | 74 ++++ + src/uadk/v1/wd_util.h | 393 ++++++++++++++++++ + 53 files changed, 6841 insertions(+) + create mode 100644 src/lzma-sdk/C/7z.h + create mode 100644 src/lzma-sdk/C/7zAlloc.h + create mode 100644 src/lzma-sdk/C/7zBuf.h + create mode 100644 src/lzma-sdk/C/7zCrc.h + create mode 100644 src/lzma-sdk/C/7zFile.h + create mode 100644 src/lzma-sdk/C/7zTypes.h + create mode 100644 src/lzma-sdk/C/7zVersion.h + create mode 100644 src/lzma-sdk/C/Aes.h + create mode 100644 src/lzma-sdk/C/Alloc.h + create mode 100644 src/lzma-sdk/C/Bcj2.h + create mode 100644 src/lzma-sdk/C/Bra.h + create mode 100644 src/lzma-sdk/C/Compiler.h + create mode 100644 src/lzma-sdk/C/CpuArch.h + create mode 100644 src/lzma-sdk/C/Delta.h + create mode 100644 src/lzma-sdk/C/DllSecur.h + create mode 100644 src/lzma-sdk/C/LzFind.h + create mode 100644 src/lzma-sdk/C/LzFindMt.h + create mode 100644 src/lzma-sdk/C/LzHash.h + create mode 100644 src/lzma-sdk/C/Lzma2Dec.h + create mode 100644 src/lzma-sdk/C/Lzma2DecMt.h + create mode 100644 src/lzma-sdk/C/Lzma2Enc.h + create mode 100644 src/lzma-sdk/C/Lzma86.h + create mode 100644 src/lzma-sdk/C/LzmaDec.h + create mode 100644 src/lzma-sdk/C/LzmaEnc.h + create mode 100644 src/lzma-sdk/C/LzmaLib.h + create mode 100644 src/lzma-sdk/C/MtCoder.h + create mode 100644 src/lzma-sdk/C/MtDec.h + create mode 100644 src/lzma-sdk/C/Ppmd.h + create mode 100644 src/lzma-sdk/C/Ppmd7.h + create mode 100644 src/lzma-sdk/C/Precomp.h + create mode 100644 src/lzma-sdk/C/RotateDefs.h + create mode 100644 src/lzma-sdk/C/Sha256.h + create mode 100644 src/lzma-sdk/C/Sort.h + create mode 100644 src/lzma-sdk/C/Threads.h + create mode 100644 src/lzma-sdk/C/Util/7z/Precomp.h + create mode 100644 src/lzma-sdk/C/Util/SfxSetup/Precomp.h + create mode 100644 src/lzma-sdk/C/Xz.h + create mode 100644 src/lzma-sdk/C/XzCrc64.h + create mode 100644 src/lzma-sdk/C/XzEnc.h + create mode 100644 src/uadk/v1/uacce.h + create mode 100644 src/uadk/v1/wd.h + create mode 100644 src/uadk/v1/wd_adapter.h + create mode 100644 src/uadk/v1/wd_aead.h + create mode 100644 src/uadk/v1/wd_bmm.h + create mode 100644 src/uadk/v1/wd_cipher.h + create mode 100644 src/uadk/v1/wd_comp.h + create mode 100644 src/uadk/v1/wd_dh.h + create mode 100644 src/uadk/v1/wd_digest.h + create mode 100644 src/uadk/v1/wd_ecc.h + create mode 100644 src/uadk/v1/wd_rng.h + create mode 100644 src/uadk/v1/wd_rsa.h + create mode 100644 src/uadk/v1/wd_sgl.h + create mode 100644 src/uadk/v1/wd_util.h + +diff --git a/src/lzma-sdk/C/7z.h b/src/lzma-sdk/C/7z.h +new file mode 100644 +index 0000000..969523c +--- /dev/null ++++ b/src/lzma-sdk/C/7z.h +@@ -0,0 +1,204 @@ ++/* 7z.h -- 7z interface ++2018-07-02 : Igor Pavlov : Public domain */ ++ ++#ifndef __7Z_H ++#define __7Z_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++#define k7zStartHeaderSize 0x20 ++#define k7zSignatureSize 6 ++ ++extern const Byte k7zSignature[k7zSignatureSize]; ++ ++typedef struct ++{ ++ const Byte *Data; ++ size_t Size; ++} CSzData; ++ ++/* CSzCoderInfo & CSzFolder support only default methods */ ++ ++typedef struct ++{ ++ size_t PropsOffset; ++ UInt32 MethodID; ++ Byte NumStreams; ++ Byte PropsSize; ++} CSzCoderInfo; ++ ++typedef struct ++{ ++ UInt32 InIndex; ++ UInt32 OutIndex; ++} CSzBond; ++ ++#define SZ_NUM_CODERS_IN_FOLDER_MAX 4 ++#define SZ_NUM_BONDS_IN_FOLDER_MAX 3 ++#define SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX 4 ++ ++typedef struct ++{ ++ UInt32 NumCoders; ++ UInt32 NumBonds; ++ UInt32 NumPackStreams; ++ UInt32 UnpackStream; ++ UInt32 PackStreams[SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX]; ++ CSzBond Bonds[SZ_NUM_BONDS_IN_FOLDER_MAX]; ++ CSzCoderInfo Coders[SZ_NUM_CODERS_IN_FOLDER_MAX]; ++} CSzFolder; ++ ++ ++SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd); ++ ++typedef struct ++{ ++ UInt32 Low; ++ UInt32 High; ++} CNtfsFileTime; ++ ++typedef struct ++{ ++ Byte *Defs; /* MSB 0 bit numbering */ ++ UInt32 *Vals; ++} CSzBitUi32s; ++ ++typedef struct ++{ ++ Byte *Defs; /* MSB 0 bit numbering */ ++ // UInt64 *Vals; ++ CNtfsFileTime *Vals; ++} CSzBitUi64s; ++ ++#define SzBitArray_Check(p, i) (((p)[(i) >> 3] & (0x80 >> ((i) & 7))) != 0) ++ ++#define SzBitWithVals_Check(p, i) ((p)->Defs && ((p)->Defs[(i) >> 3] & (0x80 >> ((i) & 7))) != 0) ++ ++typedef struct ++{ ++ UInt32 NumPackStreams; ++ UInt32 NumFolders; ++ ++ UInt64 *PackPositions; // NumPackStreams + 1 ++ CSzBitUi32s FolderCRCs; // NumFolders ++ ++ size_t *FoCodersOffsets; // NumFolders + 1 ++ UInt32 *FoStartPackStreamIndex; // NumFolders + 1 ++ UInt32 *FoToCoderUnpackSizes; // NumFolders + 1 ++ Byte *FoToMainUnpackSizeIndex; // NumFolders ++ UInt64 *CoderUnpackSizes; // for all coders in all folders ++ ++ Byte *CodersData; ++ ++ UInt64 RangeLimit; ++} CSzAr; ++ ++UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex); ++ ++SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex, ++ ILookInStream *stream, UInt64 startPos, ++ Byte *outBuffer, size_t outSize, ++ ISzAllocPtr allocMain); ++ ++typedef struct ++{ ++ CSzAr db; ++ ++ UInt64 startPosAfterHeader; ++ UInt64 dataPos; ++ ++ UInt32 NumFiles; ++ ++ UInt64 *UnpackPositions; // NumFiles + 1 ++ // Byte *IsEmptyFiles; ++ Byte *IsDirs; ++ CSzBitUi32s CRCs; ++ ++ CSzBitUi32s Attribs; ++ // CSzBitUi32s Parents; ++ CSzBitUi64s MTime; ++ CSzBitUi64s CTime; ++ ++ UInt32 *FolderToFile; // NumFolders + 1 ++ UInt32 *FileToFolder; // NumFiles ++ ++ size_t *FileNameOffsets; /* in 2-byte steps */ ++ Byte *FileNames; /* UTF-16-LE */ ++} CSzArEx; ++ ++#define SzArEx_IsDir(p, i) (SzBitArray_Check((p)->IsDirs, i)) ++ ++#define SzArEx_GetFileSize(p, i) ((p)->UnpackPositions[(i) + 1] - (p)->UnpackPositions[i]) ++ ++void SzArEx_Init(CSzArEx *p); ++void SzArEx_Free(CSzArEx *p, ISzAllocPtr alloc); ++UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder); ++int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize); ++ ++/* ++if dest == NULL, the return value specifies the required size of the buffer, ++ in 16-bit characters, including the null-terminating character. ++if dest != NULL, the return value specifies the number of 16-bit characters that ++ are written to the dest, including the null-terminating character. */ ++ ++size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest); ++ ++/* ++size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex); ++UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest); ++*/ ++ ++ ++ ++/* ++ SzArEx_Extract extracts file from archive ++ ++ *outBuffer must be 0 before first call for each new archive. ++ ++ Extracting cache: ++ If you need to decompress more than one file, you can send ++ these values from previous call: ++ *blockIndex, ++ *outBuffer, ++ *outBufferSize ++ You can consider "*outBuffer" as cache of solid block. If your archive is solid, ++ it will increase decompression speed. ++ ++ If you use external function, you can declare these 3 cache variables ++ (blockIndex, outBuffer, outBufferSize) as static in that external function. ++ ++ Free *outBuffer and set *outBuffer to 0, if you want to flush cache. ++*/ ++ ++SRes SzArEx_Extract( ++ const CSzArEx *db, ++ ILookInStream *inStream, ++ UInt32 fileIndex, /* index of file */ ++ UInt32 *blockIndex, /* index of solid block */ ++ Byte **outBuffer, /* pointer to pointer to output buffer (allocated with allocMain) */ ++ size_t *outBufferSize, /* buffer size for output buffer */ ++ size_t *offset, /* offset of stream for required file in *outBuffer */ ++ size_t *outSizeProcessed, /* size of file in *outBuffer */ ++ ISzAllocPtr allocMain, ++ ISzAllocPtr allocTemp); ++ ++ ++/* ++SzArEx_Open Errors: ++SZ_ERROR_NO_ARCHIVE ++SZ_ERROR_ARCHIVE ++SZ_ERROR_UNSUPPORTED ++SZ_ERROR_MEM ++SZ_ERROR_CRC ++SZ_ERROR_INPUT_EOF ++SZ_ERROR_FAIL ++*/ ++ ++SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream, ++ ISzAllocPtr allocMain, ISzAllocPtr allocTemp); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/7zAlloc.h b/src/lzma-sdk/C/7zAlloc.h +new file mode 100644 +index 0000000..c0f89d7 +--- /dev/null ++++ b/src/lzma-sdk/C/7zAlloc.h +@@ -0,0 +1,19 @@ ++/* 7zAlloc.h -- Allocation functions ++2017-04-03 : Igor Pavlov : Public domain */ ++ ++#ifndef __7Z_ALLOC_H ++#define __7Z_ALLOC_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++void *SzAlloc(ISzAllocPtr p, size_t size); ++void SzFree(ISzAllocPtr p, void *address); ++ ++void *SzAllocTemp(ISzAllocPtr p, size_t size); ++void SzFreeTemp(ISzAllocPtr p, void *address); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/7zBuf.h b/src/lzma-sdk/C/7zBuf.h +new file mode 100644 +index 0000000..5942d6e +--- /dev/null ++++ b/src/lzma-sdk/C/7zBuf.h +@@ -0,0 +1,35 @@ ++/* 7zBuf.h -- Byte Buffer ++2017-04-03 : Igor Pavlov : Public domain */ ++ ++#ifndef __7Z_BUF_H ++#define __7Z_BUF_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++typedef struct ++{ ++ Byte *data; ++ size_t size; ++} CBuf; ++ ++void Buf_Init(CBuf *p); ++int Buf_Create(CBuf *p, size_t size, ISzAllocPtr alloc); ++void Buf_Free(CBuf *p, ISzAllocPtr alloc); ++ ++typedef struct ++{ ++ Byte *data; ++ size_t size; ++ size_t pos; ++} CDynBuf; ++ ++void DynBuf_Construct(CDynBuf *p); ++void DynBuf_SeekToBeg(CDynBuf *p); ++int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAllocPtr alloc); ++void DynBuf_Free(CDynBuf *p, ISzAllocPtr alloc); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/7zCrc.h b/src/lzma-sdk/C/7zCrc.h +new file mode 100644 +index 0000000..3b04594 +--- /dev/null ++++ b/src/lzma-sdk/C/7zCrc.h +@@ -0,0 +1,25 @@ ++/* 7zCrc.h -- CRC32 calculation ++2013-01-18 : Igor Pavlov : Public domain */ ++ ++#ifndef __7Z_CRC_H ++#define __7Z_CRC_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++extern UInt32 g_CrcTable[]; ++ ++/* Call CrcGenerateTable one time before other CRC functions */ ++void MY_FAST_CALL CrcGenerateTable(void); ++ ++#define CRC_INIT_VAL 0xFFFFFFFF ++#define CRC_GET_DIGEST(crc) ((crc) ^ CRC_INIT_VAL) ++#define CRC_UPDATE_BYTE(crc, b) (g_CrcTable[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8)) ++ ++UInt32 MY_FAST_CALL CrcUpdate(UInt32 crc, const void *data, size_t size); ++UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/7zFile.h b/src/lzma-sdk/C/7zFile.h +new file mode 100644 +index 0000000..c7a30fc +--- /dev/null ++++ b/src/lzma-sdk/C/7zFile.h +@@ -0,0 +1,91 @@ ++/* 7zFile.h -- File IO ++2021-02-15 : Igor Pavlov : Public domain */ ++ ++#ifndef __7Z_FILE_H ++#define __7Z_FILE_H ++ ++#ifdef _WIN32 ++#define USE_WINDOWS_FILE ++// #include ++#endif ++ ++#ifdef USE_WINDOWS_FILE ++#include ++#else ++// note: USE_FOPEN mode is limited to 32-bit file size ++// #define USE_FOPEN ++// #include ++#endif ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++/* ---------- File ---------- */ ++ ++typedef struct ++{ ++ #ifdef USE_WINDOWS_FILE ++ HANDLE handle; ++ #elif defined(USE_FOPEN) ++ FILE *file; ++ #else ++ int fd; ++ #endif ++} CSzFile; ++ ++void File_Construct(CSzFile *p); ++#if !defined(UNDER_CE) || !defined(USE_WINDOWS_FILE) ++WRes InFile_Open(CSzFile *p, const char *name); ++WRes OutFile_Open(CSzFile *p, const char *name); ++#endif ++#ifdef USE_WINDOWS_FILE ++WRes InFile_OpenW(CSzFile *p, const WCHAR *name); ++WRes OutFile_OpenW(CSzFile *p, const WCHAR *name); ++#endif ++WRes File_Close(CSzFile *p); ++ ++/* reads max(*size, remain file's size) bytes */ ++WRes File_Read(CSzFile *p, void *data, size_t *size); ++ ++/* writes *size bytes */ ++WRes File_Write(CSzFile *p, const void *data, size_t *size); ++ ++WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin); ++WRes File_GetLength(CSzFile *p, UInt64 *length); ++ ++ ++/* ---------- FileInStream ---------- */ ++ ++typedef struct ++{ ++ ISeqInStream vt; ++ CSzFile file; ++ WRes wres; ++} CFileSeqInStream; ++ ++void FileSeqInStream_CreateVTable(CFileSeqInStream *p); ++ ++ ++typedef struct ++{ ++ ISeekInStream vt; ++ CSzFile file; ++ WRes wres; ++} CFileInStream; ++ ++void FileInStream_CreateVTable(CFileInStream *p); ++ ++ ++typedef struct ++{ ++ ISeqOutStream vt; ++ CSzFile file; ++ WRes wres; ++} CFileOutStream; ++ ++void FileOutStream_CreateVTable(CFileOutStream *p); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/7zTypes.h b/src/lzma-sdk/C/7zTypes.h +new file mode 100644 +index 0000000..763d3a9 +--- /dev/null ++++ b/src/lzma-sdk/C/7zTypes.h +@@ -0,0 +1,529 @@ ++/* 7zTypes.h -- Basic types ++2022-04-01 : Igor Pavlov : Public domain */ ++ ++#ifndef __7Z_TYPES_H ++#define __7Z_TYPES_H ++ ++#ifdef _WIN32 ++/* #include */ ++#else ++#include ++#endif ++ ++#include ++ ++#ifndef EXTERN_C_BEGIN ++#ifdef __cplusplus ++#define EXTERN_C_BEGIN extern "C" { ++#define EXTERN_C_END } ++#else ++#define EXTERN_C_BEGIN ++#define EXTERN_C_END ++#endif ++#endif ++ ++EXTERN_C_BEGIN ++ ++#define SZ_OK 0 ++ ++#define SZ_ERROR_DATA 1 ++#define SZ_ERROR_MEM 2 ++#define SZ_ERROR_CRC 3 ++#define SZ_ERROR_UNSUPPORTED 4 ++#define SZ_ERROR_PARAM 5 ++#define SZ_ERROR_INPUT_EOF 6 ++#define SZ_ERROR_OUTPUT_EOF 7 ++#define SZ_ERROR_READ 8 ++#define SZ_ERROR_WRITE 9 ++#define SZ_ERROR_PROGRESS 10 ++#define SZ_ERROR_FAIL 11 ++#define SZ_ERROR_THREAD 12 ++ ++#define SZ_ERROR_ARCHIVE 16 ++#define SZ_ERROR_NO_ARCHIVE 17 ++ ++typedef int SRes; ++ ++ ++#ifdef _MSC_VER ++ #if _MSC_VER > 1200 ++ #define MY_ALIGN(n) __declspec(align(n)) ++ #else ++ #define MY_ALIGN(n) ++ #endif ++#else ++ #define MY_ALIGN(n) __attribute__ ((aligned(n))) ++#endif ++ ++ ++#ifdef _WIN32 ++ ++/* typedef DWORD WRes; */ ++typedef unsigned WRes; ++#define MY_SRes_HRESULT_FROM_WRes(x) HRESULT_FROM_WIN32(x) ++ ++// #define MY_HRES_ERROR__INTERNAL_ERROR MY_SRes_HRESULT_FROM_WRes(ERROR_INTERNAL_ERROR) ++ ++#else // _WIN32 ++ ++// #define ENV_HAVE_LSTAT ++typedef int WRes; ++ ++// (FACILITY_ERRNO = 0x800) is 7zip's FACILITY constant to represent (errno) errors in HRESULT ++#define MY__FACILITY_ERRNO 0x800 ++#define MY__FACILITY_WIN32 7 ++#define MY__FACILITY__WRes MY__FACILITY_ERRNO ++ ++#define MY_HRESULT_FROM_errno_CONST_ERROR(x) ((HRESULT)( \ ++ ( (HRESULT)(x) & 0x0000FFFF) \ ++ | (MY__FACILITY__WRes << 16) \ ++ | (HRESULT)0x80000000 )) ++ ++#define MY_SRes_HRESULT_FROM_WRes(x) \ ++ ((HRESULT)(x) <= 0 ? ((HRESULT)(x)) : MY_HRESULT_FROM_errno_CONST_ERROR(x)) ++ ++// we call macro HRESULT_FROM_WIN32 for system errors (WRes) that are (errno) ++#define HRESULT_FROM_WIN32(x) MY_SRes_HRESULT_FROM_WRes(x) ++ ++/* ++#define ERROR_FILE_NOT_FOUND 2L ++#define ERROR_ACCESS_DENIED 5L ++#define ERROR_NO_MORE_FILES 18L ++#define ERROR_LOCK_VIOLATION 33L ++#define ERROR_FILE_EXISTS 80L ++#define ERROR_DISK_FULL 112L ++#define ERROR_NEGATIVE_SEEK 131L ++#define ERROR_ALREADY_EXISTS 183L ++#define ERROR_DIRECTORY 267L ++#define ERROR_TOO_MANY_POSTS 298L ++ ++#define ERROR_INTERNAL_ERROR 1359L ++#define ERROR_INVALID_REPARSE_DATA 4392L ++#define ERROR_REPARSE_TAG_INVALID 4393L ++#define ERROR_REPARSE_TAG_MISMATCH 4394L ++*/ ++ ++// we use errno equivalents for some WIN32 errors: ++ ++#define ERROR_INVALID_PARAMETER EINVAL ++#define ERROR_INVALID_FUNCTION EINVAL ++#define ERROR_ALREADY_EXISTS EEXIST ++#define ERROR_FILE_EXISTS EEXIST ++#define ERROR_PATH_NOT_FOUND ENOENT ++#define ERROR_FILE_NOT_FOUND ENOENT ++#define ERROR_DISK_FULL ENOSPC ++// #define ERROR_INVALID_HANDLE EBADF ++ ++// we use FACILITY_WIN32 for errors that has no errno equivalent ++// Too many posts were made to a semaphore. ++#define ERROR_TOO_MANY_POSTS ((HRESULT)0x8007012AL) ++#define ERROR_INVALID_REPARSE_DATA ((HRESULT)0x80071128L) ++#define ERROR_REPARSE_TAG_INVALID ((HRESULT)0x80071129L) ++ ++// if (MY__FACILITY__WRes != FACILITY_WIN32), ++// we use FACILITY_WIN32 for COM errors: ++#define E_OUTOFMEMORY ((HRESULT)0x8007000EL) ++#define E_INVALIDARG ((HRESULT)0x80070057L) ++#define MY__E_ERROR_NEGATIVE_SEEK ((HRESULT)0x80070083L) ++ ++/* ++// we can use FACILITY_ERRNO for some COM errors, that have errno equivalents: ++#define E_OUTOFMEMORY MY_HRESULT_FROM_errno_CONST_ERROR(ENOMEM) ++#define E_INVALIDARG MY_HRESULT_FROM_errno_CONST_ERROR(EINVAL) ++#define MY__E_ERROR_NEGATIVE_SEEK MY_HRESULT_FROM_errno_CONST_ERROR(EINVAL) ++*/ ++ ++#define TEXT(quote) quote ++ ++#define FILE_ATTRIBUTE_READONLY 0x0001 ++#define FILE_ATTRIBUTE_HIDDEN 0x0002 ++#define FILE_ATTRIBUTE_SYSTEM 0x0004 ++#define FILE_ATTRIBUTE_DIRECTORY 0x0010 ++#define FILE_ATTRIBUTE_ARCHIVE 0x0020 ++#define FILE_ATTRIBUTE_DEVICE 0x0040 ++#define FILE_ATTRIBUTE_NORMAL 0x0080 ++#define FILE_ATTRIBUTE_TEMPORARY 0x0100 ++#define FILE_ATTRIBUTE_SPARSE_FILE 0x0200 ++#define FILE_ATTRIBUTE_REPARSE_POINT 0x0400 ++#define FILE_ATTRIBUTE_COMPRESSED 0x0800 ++#define FILE_ATTRIBUTE_OFFLINE 0x1000 ++#define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED 0x2000 ++#define FILE_ATTRIBUTE_ENCRYPTED 0x4000 ++ ++#define FILE_ATTRIBUTE_UNIX_EXTENSION 0x8000 /* trick for Unix */ ++ ++#endif ++ ++ ++#ifndef RINOK ++#define RINOK(x) { int __result__ = (x); if (__result__ != 0) return __result__; } ++#endif ++ ++#ifndef RINOK_WRes ++#define RINOK_WRes(x) { WRes __result__ = (x); if (__result__ != 0) return __result__; } ++#endif ++ ++typedef unsigned char Byte; ++typedef short Int16; ++typedef unsigned short UInt16; ++ ++#ifdef _LZMA_UINT32_IS_ULONG ++typedef long Int32; ++typedef unsigned long UInt32; ++#else ++typedef int Int32; ++typedef unsigned int UInt32; ++#endif ++ ++ ++#ifndef _WIN32 ++ ++typedef int INT; ++typedef Int32 INT32; ++typedef unsigned int UINT; ++typedef UInt32 UINT32; ++typedef INT32 LONG; // LONG, ULONG and DWORD must be 32-bit for _WIN32 compatibility ++typedef UINT32 ULONG; ++ ++#undef DWORD ++typedef UINT32 DWORD; ++ ++#define VOID void ++ ++#define HRESULT LONG ++ ++typedef void *LPVOID; ++// typedef void VOID; ++// typedef ULONG_PTR DWORD_PTR, *PDWORD_PTR; ++// gcc / clang on Unix : sizeof(long==sizeof(void*) in 32 or 64 bits) ++typedef long INT_PTR; ++typedef unsigned long UINT_PTR; ++typedef long LONG_PTR; ++typedef unsigned long DWORD_PTR; ++ ++typedef size_t SIZE_T; ++ ++#endif // _WIN32 ++ ++ ++#define MY_HRES_ERROR__INTERNAL_ERROR ((HRESULT)0x8007054FL) ++ ++ ++#ifdef _SZ_NO_INT_64 ++ ++/* define _SZ_NO_INT_64, if your compiler doesn't support 64-bit integers. ++ NOTES: Some code will work incorrectly in that case! */ ++ ++typedef long Int64; ++typedef unsigned long UInt64; ++ ++#else ++ ++#if defined(_MSC_VER) || defined(__BORLANDC__) ++typedef __int64 Int64; ++typedef unsigned __int64 UInt64; ++#define UINT64_CONST(n) n ++#else ++typedef long long int Int64; ++typedef unsigned long long int UInt64; ++#define UINT64_CONST(n) n ## ULL ++#endif ++ ++#endif ++ ++#ifdef _LZMA_NO_SYSTEM_SIZE_T ++typedef UInt32 SizeT; ++#else ++typedef size_t SizeT; ++#endif ++ ++typedef int BoolInt; ++/* typedef BoolInt Bool; */ ++#define True 1 ++#define False 0 ++ ++ ++#ifdef _WIN32 ++#define MY_STD_CALL __stdcall ++#else ++#define MY_STD_CALL ++#endif ++ ++#ifdef _MSC_VER ++ ++#if _MSC_VER >= 1300 ++#define MY_NO_INLINE __declspec(noinline) ++#else ++#define MY_NO_INLINE ++#endif ++ ++#define MY_FORCE_INLINE __forceinline ++ ++#define MY_CDECL __cdecl ++#define MY_FAST_CALL __fastcall ++ ++#else // _MSC_VER ++ ++#if (defined(__GNUC__) && (__GNUC__ >= 4)) \ ++ || (defined(__clang__) && (__clang_major__ >= 4)) \ ++ || defined(__INTEL_COMPILER) \ ++ || defined(__xlC__) ++#define MY_NO_INLINE __attribute__((noinline)) ++// #define MY_FORCE_INLINE __attribute__((always_inline)) inline ++#else ++#define MY_NO_INLINE ++#endif ++ ++#define MY_FORCE_INLINE ++ ++ ++#define MY_CDECL ++ ++#if defined(_M_IX86) \ ++ || defined(__i386__) ++// #define MY_FAST_CALL __attribute__((fastcall)) ++// #define MY_FAST_CALL __attribute__((cdecl)) ++#define MY_FAST_CALL ++#elif defined(MY_CPU_AMD64) ++// #define MY_FAST_CALL __attribute__((ms_abi)) ++#define MY_FAST_CALL ++#else ++#define MY_FAST_CALL ++#endif ++ ++#endif // _MSC_VER ++ ++ ++/* The following interfaces use first parameter as pointer to structure */ ++ ++typedef struct IByteIn IByteIn; ++struct IByteIn ++{ ++ Byte (*Read)(const IByteIn *p); /* reads one byte, returns 0 in case of EOF or error */ ++}; ++#define IByteIn_Read(p) (p)->Read(p) ++ ++ ++typedef struct IByteOut IByteOut; ++struct IByteOut ++{ ++ void (*Write)(const IByteOut *p, Byte b); ++}; ++#define IByteOut_Write(p, b) (p)->Write(p, b) ++ ++ ++typedef struct ISeqInStream ISeqInStream; ++struct ISeqInStream ++{ ++ SRes (*Read)(const ISeqInStream *p, void *buf, size_t *size); ++ /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream. ++ (output(*size) < input(*size)) is allowed */ ++}; ++#define ISeqInStream_Read(p, buf, size) (p)->Read(p, buf, size) ++ ++/* it can return SZ_ERROR_INPUT_EOF */ ++SRes SeqInStream_Read(const ISeqInStream *stream, void *buf, size_t size); ++SRes SeqInStream_Read2(const ISeqInStream *stream, void *buf, size_t size, SRes errorType); ++SRes SeqInStream_ReadByte(const ISeqInStream *stream, Byte *buf); ++ ++ ++typedef struct ISeqOutStream ISeqOutStream; ++struct ISeqOutStream ++{ ++ size_t (*Write)(const ISeqOutStream *p, const void *buf, size_t size); ++ /* Returns: result - the number of actually written bytes. ++ (result < size) means error */ ++}; ++#define ISeqOutStream_Write(p, buf, size) (p)->Write(p, buf, size) ++ ++typedef enum ++{ ++ SZ_SEEK_SET = 0, ++ SZ_SEEK_CUR = 1, ++ SZ_SEEK_END = 2 ++} ESzSeek; ++ ++ ++typedef struct ISeekInStream ISeekInStream; ++struct ISeekInStream ++{ ++ SRes (*Read)(const ISeekInStream *p, void *buf, size_t *size); /* same as ISeqInStream::Read */ ++ SRes (*Seek)(const ISeekInStream *p, Int64 *pos, ESzSeek origin); ++}; ++#define ISeekInStream_Read(p, buf, size) (p)->Read(p, buf, size) ++#define ISeekInStream_Seek(p, pos, origin) (p)->Seek(p, pos, origin) ++ ++ ++typedef struct ILookInStream ILookInStream; ++struct ILookInStream ++{ ++ SRes (*Look)(const ILookInStream *p, const void **buf, size_t *size); ++ /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream. ++ (output(*size) > input(*size)) is not allowed ++ (output(*size) < input(*size)) is allowed */ ++ SRes (*Skip)(const ILookInStream *p, size_t offset); ++ /* offset must be <= output(*size) of Look */ ++ ++ SRes (*Read)(const ILookInStream *p, void *buf, size_t *size); ++ /* reads directly (without buffer). It's same as ISeqInStream::Read */ ++ SRes (*Seek)(const ILookInStream *p, Int64 *pos, ESzSeek origin); ++}; ++ ++#define ILookInStream_Look(p, buf, size) (p)->Look(p, buf, size) ++#define ILookInStream_Skip(p, offset) (p)->Skip(p, offset) ++#define ILookInStream_Read(p, buf, size) (p)->Read(p, buf, size) ++#define ILookInStream_Seek(p, pos, origin) (p)->Seek(p, pos, origin) ++ ++ ++SRes LookInStream_LookRead(const ILookInStream *stream, void *buf, size_t *size); ++SRes LookInStream_SeekTo(const ILookInStream *stream, UInt64 offset); ++ ++/* reads via ILookInStream::Read */ ++SRes LookInStream_Read2(const ILookInStream *stream, void *buf, size_t size, SRes errorType); ++SRes LookInStream_Read(const ILookInStream *stream, void *buf, size_t size); ++ ++ ++ ++typedef struct ++{ ++ ILookInStream vt; ++ const ISeekInStream *realStream; ++ ++ size_t pos; ++ size_t size; /* it's data size */ ++ ++ /* the following variables must be set outside */ ++ Byte *buf; ++ size_t bufSize; ++} CLookToRead2; ++ ++void LookToRead2_CreateVTable(CLookToRead2 *p, int lookahead); ++ ++#define LookToRead2_Init(p) { (p)->pos = (p)->size = 0; } ++ ++ ++typedef struct ++{ ++ ISeqInStream vt; ++ const ILookInStream *realStream; ++} CSecToLook; ++ ++void SecToLook_CreateVTable(CSecToLook *p); ++ ++ ++ ++typedef struct ++{ ++ ISeqInStream vt; ++ const ILookInStream *realStream; ++} CSecToRead; ++ ++void SecToRead_CreateVTable(CSecToRead *p); ++ ++ ++typedef struct ICompressProgress ICompressProgress; ++ ++struct ICompressProgress ++{ ++ SRes (*Progress)(const ICompressProgress *p, UInt64 inSize, UInt64 outSize); ++ /* Returns: result. (result != SZ_OK) means break. ++ Value (UInt64)(Int64)-1 for size means unknown value. */ ++}; ++#define ICompressProgress_Progress(p, inSize, outSize) (p)->Progress(p, inSize, outSize) ++ ++ ++ ++typedef struct ISzAlloc ISzAlloc; ++typedef const ISzAlloc * ISzAllocPtr; ++ ++struct ISzAlloc ++{ ++ void *(*Alloc)(ISzAllocPtr p, size_t size); ++ void (*Free)(ISzAllocPtr p, void *address); /* address can be 0 */ ++}; ++ ++#define ISzAlloc_Alloc(p, size) (p)->Alloc(p, size) ++#define ISzAlloc_Free(p, a) (p)->Free(p, a) ++ ++/* deprecated */ ++#define IAlloc_Alloc(p, size) ISzAlloc_Alloc(p, size) ++#define IAlloc_Free(p, a) ISzAlloc_Free(p, a) ++ ++ ++ ++ ++ ++#ifndef MY_offsetof ++ #ifdef offsetof ++ #define MY_offsetof(type, m) offsetof(type, m) ++ /* ++ #define MY_offsetof(type, m) FIELD_OFFSET(type, m) ++ */ ++ #else ++ #define MY_offsetof(type, m) ((size_t)&(((type *)0)->m)) ++ #endif ++#endif ++ ++ ++ ++#ifndef MY_container_of ++ ++/* ++#define MY_container_of(ptr, type, m) container_of(ptr, type, m) ++#define MY_container_of(ptr, type, m) CONTAINING_RECORD(ptr, type, m) ++#define MY_container_of(ptr, type, m) ((type *)((char *)(ptr) - offsetof(type, m))) ++#define MY_container_of(ptr, type, m) (&((type *)0)->m == (ptr), ((type *)(((char *)(ptr)) - MY_offsetof(type, m)))) ++*/ ++ ++/* ++ GCC shows warning: "perhaps the 'offsetof' macro was used incorrectly" ++ GCC 3.4.4 : classes with constructor ++ GCC 4.8.1 : classes with non-public variable members" ++*/ ++ ++#define MY_container_of(ptr, type, m) ((type *)(void *)((char *)(void *)(1 ? (ptr) : &((type *)0)->m) - MY_offsetof(type, m))) ++ ++#endif ++ ++#define CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m) ((type *)(void *)(ptr)) ++ ++/* ++#define CONTAINER_FROM_VTBL(ptr, type, m) CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m) ++*/ ++#define CONTAINER_FROM_VTBL(ptr, type, m) MY_container_of(ptr, type, m) ++ ++#define CONTAINER_FROM_VTBL_CLS(ptr, type, m) CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m) ++/* ++#define CONTAINER_FROM_VTBL_CLS(ptr, type, m) CONTAINER_FROM_VTBL(ptr, type, m) ++*/ ++ ++ ++#define MY_memset_0_ARRAY(a) memset((a), 0, sizeof(a)) ++ ++#ifdef _WIN32 ++ ++#define CHAR_PATH_SEPARATOR '\\' ++#define WCHAR_PATH_SEPARATOR L'\\' ++#define STRING_PATH_SEPARATOR "\\" ++#define WSTRING_PATH_SEPARATOR L"\\" ++ ++#else ++ ++#define CHAR_PATH_SEPARATOR '/' ++#define WCHAR_PATH_SEPARATOR L'/' ++#define STRING_PATH_SEPARATOR "/" ++#define WSTRING_PATH_SEPARATOR L"/" ++ ++#endif ++ ++#define k_PropVar_TimePrec_0 0 ++#define k_PropVar_TimePrec_Unix 1 ++#define k_PropVar_TimePrec_DOS 2 ++#define k_PropVar_TimePrec_HighPrec 3 ++#define k_PropVar_TimePrec_Base 16 ++#define k_PropVar_TimePrec_100ns (k_PropVar_TimePrec_Base + 7) ++#define k_PropVar_TimePrec_1ns (k_PropVar_TimePrec_Base + 9) ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/7zVersion.h b/src/lzma-sdk/C/7zVersion.h +new file mode 100644 +index 0000000..345b5b5 +--- /dev/null ++++ b/src/lzma-sdk/C/7zVersion.h +@@ -0,0 +1,27 @@ ++#define MY_VER_MAJOR 22 ++#define MY_VER_MINOR 00 ++#define MY_VER_BUILD 0 ++#define MY_VERSION_NUMBERS "22.00" ++#define MY_VERSION MY_VERSION_NUMBERS ++ ++#ifdef MY_CPU_NAME ++ #define MY_VERSION_CPU MY_VERSION " (" MY_CPU_NAME ")" ++#else ++ #define MY_VERSION_CPU MY_VERSION ++#endif ++ ++#define MY_DATE "2022-06-15" ++#undef MY_COPYRIGHT ++#undef MY_VERSION_COPYRIGHT_DATE ++#define MY_AUTHOR_NAME "Igor Pavlov" ++#define MY_COPYRIGHT_PD "Igor Pavlov : Public domain" ++#define MY_COPYRIGHT_CR "Copyright (c) 1999-2022 Igor Pavlov" ++ ++#ifdef USE_COPYRIGHT_CR ++ #define MY_COPYRIGHT MY_COPYRIGHT_CR ++#else ++ #define MY_COPYRIGHT MY_COPYRIGHT_PD ++#endif ++ ++#define MY_COPYRIGHT_DATE MY_COPYRIGHT " : " MY_DATE ++#define MY_VERSION_COPYRIGHT_DATE MY_VERSION_CPU " : " MY_COPYRIGHT " : " MY_DATE +diff --git a/src/lzma-sdk/C/Aes.h b/src/lzma-sdk/C/Aes.h +new file mode 100644 +index 0000000..602e25e +--- /dev/null ++++ b/src/lzma-sdk/C/Aes.h +@@ -0,0 +1,60 @@ ++/* Aes.h -- AES encryption / decryption ++2018-04-28 : Igor Pavlov : Public domain */ ++ ++#ifndef __AES_H ++#define __AES_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++#define AES_BLOCK_SIZE 16 ++ ++/* Call AesGenTables one time before other AES functions */ ++void AesGenTables(void); ++ ++/* UInt32 pointers must be 16-byte aligned */ ++ ++/* 16-byte (4 * 32-bit words) blocks: 1 (IV) + 1 (keyMode) + 15 (AES-256 roundKeys) */ ++#define AES_NUM_IVMRK_WORDS ((1 + 1 + 15) * 4) ++ ++/* aes - 16-byte aligned pointer to keyMode+roundKeys sequence */ ++/* keySize = 16 or 24 or 32 (bytes) */ ++typedef void (MY_FAST_CALL *AES_SET_KEY_FUNC)(UInt32 *aes, const Byte *key, unsigned keySize); ++void MY_FAST_CALL Aes_SetKey_Enc(UInt32 *aes, const Byte *key, unsigned keySize); ++void MY_FAST_CALL Aes_SetKey_Dec(UInt32 *aes, const Byte *key, unsigned keySize); ++ ++/* ivAes - 16-byte aligned pointer to iv+keyMode+roundKeys sequence: UInt32[AES_NUM_IVMRK_WORDS] */ ++void AesCbc_Init(UInt32 *ivAes, const Byte *iv); /* iv size is AES_BLOCK_SIZE */ ++ ++/* data - 16-byte aligned pointer to data */ ++/* numBlocks - the number of 16-byte blocks in data array */ ++typedef void (MY_FAST_CALL *AES_CODE_FUNC)(UInt32 *ivAes, Byte *data, size_t numBlocks); ++ ++extern AES_CODE_FUNC g_AesCbc_Decode; ++#ifndef _SFX ++extern AES_CODE_FUNC g_AesCbc_Encode; ++extern AES_CODE_FUNC g_AesCtr_Code; ++#define k_Aes_SupportedFunctions_HW (1 << 2) ++#define k_Aes_SupportedFunctions_HW_256 (1 << 3) ++extern UInt32 g_Aes_SupportedFunctions_Flags; ++#endif ++ ++ ++#define DECLARE__AES_CODE_FUNC(funcName) \ ++ void MY_FAST_CALL funcName(UInt32 *ivAes, Byte *data, size_t numBlocks); ++ ++DECLARE__AES_CODE_FUNC (AesCbc_Encode) ++DECLARE__AES_CODE_FUNC (AesCbc_Decode) ++DECLARE__AES_CODE_FUNC (AesCtr_Code) ++ ++DECLARE__AES_CODE_FUNC (AesCbc_Encode_HW) ++DECLARE__AES_CODE_FUNC (AesCbc_Decode_HW) ++DECLARE__AES_CODE_FUNC (AesCtr_Code_HW) ++ ++DECLARE__AES_CODE_FUNC (AesCbc_Decode_HW_256) ++DECLARE__AES_CODE_FUNC (AesCtr_Code_HW_256) ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/Alloc.h b/src/lzma-sdk/C/Alloc.h +new file mode 100644 +index 0000000..59de107 +--- /dev/null ++++ b/src/lzma-sdk/C/Alloc.h +@@ -0,0 +1,58 @@ ++/* Alloc.h -- Memory allocation functions ++2021-07-13 : Igor Pavlov : Public domain */ ++ ++#ifndef __COMMON_ALLOC_H ++#define __COMMON_ALLOC_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++void *MyAlloc(size_t size); ++void MyFree(void *address); ++ ++#ifdef _WIN32 ++ ++void SetLargePageSize(void); ++ ++void *MidAlloc(size_t size); ++void MidFree(void *address); ++void *BigAlloc(size_t size); ++void BigFree(void *address); ++ ++#else ++ ++#define MidAlloc(size) MyAlloc(size) ++#define MidFree(address) MyFree(address) ++#define BigAlloc(size) MyAlloc(size) ++#define BigFree(address) MyFree(address) ++ ++#endif ++ ++extern const ISzAlloc g_Alloc; ++ ++#ifdef _WIN32 ++extern const ISzAlloc g_BigAlloc; ++extern const ISzAlloc g_MidAlloc; ++#else ++#define g_BigAlloc g_AlignedAlloc ++#define g_MidAlloc g_AlignedAlloc ++#endif ++ ++extern const ISzAlloc g_AlignedAlloc; ++ ++ ++typedef struct ++{ ++ ISzAlloc vt; ++ ISzAllocPtr baseAlloc; ++ unsigned numAlignBits; /* ((1 << numAlignBits) >= sizeof(void *)) */ ++ size_t offset; /* (offset == (k * sizeof(void *)) && offset < (1 << numAlignBits) */ ++} CAlignOffsetAlloc; ++ ++void AlignOffsetAlloc_CreateVTable(CAlignOffsetAlloc *p); ++ ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/Bcj2.h b/src/lzma-sdk/C/Bcj2.h +new file mode 100644 +index 0000000..68893d2 +--- /dev/null ++++ b/src/lzma-sdk/C/Bcj2.h +@@ -0,0 +1,146 @@ ++/* Bcj2.h -- BCJ2 Converter for x86 code ++2014-11-10 : Igor Pavlov : Public domain */ ++ ++#ifndef __BCJ2_H ++#define __BCJ2_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++#define BCJ2_NUM_STREAMS 4 ++ ++enum ++{ ++ BCJ2_STREAM_MAIN, ++ BCJ2_STREAM_CALL, ++ BCJ2_STREAM_JUMP, ++ BCJ2_STREAM_RC ++}; ++ ++enum ++{ ++ BCJ2_DEC_STATE_ORIG_0 = BCJ2_NUM_STREAMS, ++ BCJ2_DEC_STATE_ORIG_1, ++ BCJ2_DEC_STATE_ORIG_2, ++ BCJ2_DEC_STATE_ORIG_3, ++ ++ BCJ2_DEC_STATE_ORIG, ++ BCJ2_DEC_STATE_OK ++}; ++ ++enum ++{ ++ BCJ2_ENC_STATE_ORIG = BCJ2_NUM_STREAMS, ++ BCJ2_ENC_STATE_OK ++}; ++ ++ ++#define BCJ2_IS_32BIT_STREAM(s) ((s) == BCJ2_STREAM_CALL || (s) == BCJ2_STREAM_JUMP) ++ ++/* ++CBcj2Dec / CBcj2Enc ++bufs sizes: ++ BUF_SIZE(n) = lims[n] - bufs[n] ++bufs sizes for BCJ2_STREAM_CALL and BCJ2_STREAM_JUMP must be mutliply of 4: ++ (BUF_SIZE(BCJ2_STREAM_CALL) & 3) == 0 ++ (BUF_SIZE(BCJ2_STREAM_JUMP) & 3) == 0 ++*/ ++ ++/* ++CBcj2Dec: ++dest is allowed to overlap with bufs[BCJ2_STREAM_MAIN], with the following conditions: ++ bufs[BCJ2_STREAM_MAIN] >= dest && ++ bufs[BCJ2_STREAM_MAIN] - dest >= tempReserv + ++ BUF_SIZE(BCJ2_STREAM_CALL) + ++ BUF_SIZE(BCJ2_STREAM_JUMP) ++ tempReserv = 0 : for first call of Bcj2Dec_Decode ++ tempReserv = 4 : for any other calls of Bcj2Dec_Decode ++ overlap with offset = 1 is not allowed ++*/ ++ ++typedef struct ++{ ++ const Byte *bufs[BCJ2_NUM_STREAMS]; ++ const Byte *lims[BCJ2_NUM_STREAMS]; ++ Byte *dest; ++ const Byte *destLim; ++ ++ unsigned state; /* BCJ2_STREAM_MAIN has more priority than BCJ2_STATE_ORIG */ ++ ++ UInt32 ip; ++ Byte temp[4]; ++ UInt32 range; ++ UInt32 code; ++ UInt16 probs[2 + 256]; ++} CBcj2Dec; ++ ++void Bcj2Dec_Init(CBcj2Dec *p); ++ ++/* Returns: SZ_OK or SZ_ERROR_DATA */ ++SRes Bcj2Dec_Decode(CBcj2Dec *p); ++ ++#define Bcj2Dec_IsFinished(_p_) ((_p_)->code == 0) ++ ++ ++ ++typedef enum ++{ ++ BCJ2_ENC_FINISH_MODE_CONTINUE, ++ BCJ2_ENC_FINISH_MODE_END_BLOCK, ++ BCJ2_ENC_FINISH_MODE_END_STREAM ++} EBcj2Enc_FinishMode; ++ ++typedef struct ++{ ++ Byte *bufs[BCJ2_NUM_STREAMS]; ++ const Byte *lims[BCJ2_NUM_STREAMS]; ++ const Byte *src; ++ const Byte *srcLim; ++ ++ unsigned state; ++ EBcj2Enc_FinishMode finishMode; ++ ++ Byte prevByte; ++ ++ Byte cache; ++ UInt32 range; ++ UInt64 low; ++ UInt64 cacheSize; ++ ++ UInt32 ip; ++ ++ /* 32-bit ralative offset in JUMP/CALL commands is ++ - (mod 4 GB) in 32-bit mode ++ - signed Int32 in 64-bit mode ++ We use (mod 4 GB) check for fileSize. ++ Use fileSize up to 2 GB, if you want to support 32-bit and 64-bit code conversion. */ ++ UInt32 fileIp; ++ UInt32 fileSize; /* (fileSize <= ((UInt32)1 << 31)), 0 means no_limit */ ++ UInt32 relatLimit; /* (relatLimit <= ((UInt32)1 << 31)), 0 means desable_conversion */ ++ ++ UInt32 tempTarget; ++ unsigned tempPos; ++ Byte temp[4 * 2]; ++ ++ unsigned flushPos; ++ ++ UInt16 probs[2 + 256]; ++} CBcj2Enc; ++ ++void Bcj2Enc_Init(CBcj2Enc *p); ++void Bcj2Enc_Encode(CBcj2Enc *p); ++ ++#define Bcj2Enc_Get_InputData_Size(p) ((SizeT)((p)->srcLim - (p)->src) + (p)->tempPos) ++#define Bcj2Enc_IsFinished(p) ((p)->flushPos == 5) ++ ++ ++#define BCJ2_RELAT_LIMIT_NUM_BITS 26 ++#define BCJ2_RELAT_LIMIT ((UInt32)1 << BCJ2_RELAT_LIMIT_NUM_BITS) ++ ++/* limit for CBcj2Enc::fileSize variable */ ++#define BCJ2_FileSize_MAX ((UInt32)1 << 31) ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/Bra.h b/src/lzma-sdk/C/Bra.h +new file mode 100644 +index 0000000..aba8dce +--- /dev/null ++++ b/src/lzma-sdk/C/Bra.h +@@ -0,0 +1,64 @@ ++/* Bra.h -- Branch converters for executables ++2013-01-18 : Igor Pavlov : Public domain */ ++ ++#ifndef __BRA_H ++#define __BRA_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++/* ++These functions convert relative addresses to absolute addresses ++in CALL instructions to increase the compression ratio. ++ ++ In: ++ data - data buffer ++ size - size of data ++ ip - current virtual Instruction Pinter (IP) value ++ state - state variable for x86 converter ++ encoding - 0 (for decoding), 1 (for encoding) ++ ++ Out: ++ state - state variable for x86 converter ++ ++ Returns: ++ The number of processed bytes. If you call these functions with multiple calls, ++ you must start next call with first byte after block of processed bytes. ++ ++ Type Endian Alignment LookAhead ++ ++ x86 little 1 4 ++ ARMT little 2 2 ++ ARM little 4 0 ++ PPC big 4 0 ++ SPARC big 4 0 ++ IA64 little 16 0 ++ ++ size must be >= Alignment + LookAhead, if it's not last block. ++ If (size < Alignment + LookAhead), converter returns 0. ++ ++ Example: ++ ++ UInt32 ip = 0; ++ for () ++ { ++ ; size must be >= Alignment + LookAhead, if it's not last block ++ SizeT processed = Convert(data, size, ip, 1); ++ data += processed; ++ size -= processed; ++ ip += processed; ++ } ++*/ ++ ++#define x86_Convert_Init(state) { state = 0; } ++SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding); ++SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); ++SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); ++SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); ++SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); ++SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/Compiler.h b/src/lzma-sdk/C/Compiler.h +new file mode 100644 +index 0000000..eba3742 +--- /dev/null ++++ b/src/lzma-sdk/C/Compiler.h +@@ -0,0 +1,43 @@ ++/* Compiler.h ++2021-01-05 : Igor Pavlov : Public domain */ ++ ++#ifndef __7Z_COMPILER_H ++#define __7Z_COMPILER_H ++ ++ #ifdef __clang__ ++ #pragma clang diagnostic ignored "-Wunused-private-field" ++ #endif ++ ++#ifdef _MSC_VER ++ ++ #ifdef UNDER_CE ++ #define RPC_NO_WINDOWS_H ++ /* #pragma warning(disable : 4115) // '_RPC_ASYNC_STATE' : named type definition in parentheses */ ++ #pragma warning(disable : 4201) // nonstandard extension used : nameless struct/union ++ #pragma warning(disable : 4214) // nonstandard extension used : bit field types other than int ++ #endif ++ ++ #if _MSC_VER >= 1300 ++ #pragma warning(disable : 4996) // This function or variable may be unsafe ++ #else ++ #pragma warning(disable : 4511) // copy constructor could not be generated ++ #pragma warning(disable : 4512) // assignment operator could not be generated ++ #pragma warning(disable : 4514) // unreferenced inline function has been removed ++ #pragma warning(disable : 4702) // unreachable code ++ #pragma warning(disable : 4710) // not inlined ++ #pragma warning(disable : 4714) // function marked as __forceinline not inlined ++ #pragma warning(disable : 4786) // identifier was truncated to '255' characters in the debug information ++ #endif ++ ++ #ifdef __clang__ ++ #pragma clang diagnostic ignored "-Wdeprecated-declarations" ++ #pragma clang diagnostic ignored "-Wmicrosoft-exception-spec" ++ // #pragma clang diagnostic ignored "-Wreserved-id-macro" ++ #endif ++ ++#endif ++ ++#define UNUSED_VAR(x) (void)x; ++/* #define UNUSED_VAR(x) x=x; */ ++ ++#endif +diff --git a/src/lzma-sdk/C/CpuArch.h b/src/lzma-sdk/C/CpuArch.h +new file mode 100644 +index 0000000..b300a5a +--- /dev/null ++++ b/src/lzma-sdk/C/CpuArch.h +@@ -0,0 +1,442 @@ ++/* CpuArch.h -- CPU specific code ++2021-07-13 : Igor Pavlov : Public domain */ ++ ++#ifndef __CPU_ARCH_H ++#define __CPU_ARCH_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++/* ++MY_CPU_LE means that CPU is LITTLE ENDIAN. ++MY_CPU_BE means that CPU is BIG ENDIAN. ++If MY_CPU_LE and MY_CPU_BE are not defined, we don't know about ENDIANNESS of platform. ++ ++MY_CPU_LE_UNALIGN means that CPU is LITTLE ENDIAN and CPU supports unaligned memory accesses. ++ ++MY_CPU_64BIT means that processor can work with 64-bit registers. ++ MY_CPU_64BIT can be used to select fast code branch ++ MY_CPU_64BIT doesn't mean that (sizeof(void *) == 8) ++*/ ++ ++#if defined(_M_X64) \ ++ || defined(_M_AMD64) \ ++ || defined(__x86_64__) \ ++ || defined(__AMD64__) \ ++ || defined(__amd64__) ++ #define MY_CPU_AMD64 ++ #ifdef __ILP32__ ++ #define MY_CPU_NAME "x32" ++ #define MY_CPU_SIZEOF_POINTER 4 ++ #else ++ #define MY_CPU_NAME "x64" ++ #define MY_CPU_SIZEOF_POINTER 8 ++ #endif ++ #define MY_CPU_64BIT ++#endif ++ ++ ++#if defined(_M_IX86) \ ++ || defined(__i386__) ++ #define MY_CPU_X86 ++ #define MY_CPU_NAME "x86" ++ /* #define MY_CPU_32BIT */ ++ #define MY_CPU_SIZEOF_POINTER 4 ++#endif ++ ++ ++#if defined(_M_ARM64) \ ++ || defined(__AARCH64EL__) \ ++ || defined(__AARCH64EB__) \ ++ || defined(__aarch64__) ++ #define MY_CPU_ARM64 ++ #define MY_CPU_NAME "arm64" ++ #define MY_CPU_64BIT ++#endif ++ ++ ++#if defined(_M_ARM) \ ++ || defined(_M_ARM_NT) \ ++ || defined(_M_ARMT) \ ++ || defined(__arm__) \ ++ || defined(__thumb__) \ ++ || defined(__ARMEL__) \ ++ || defined(__ARMEB__) \ ++ || defined(__THUMBEL__) \ ++ || defined(__THUMBEB__) ++ #define MY_CPU_ARM ++ ++ #if defined(__thumb__) || defined(__THUMBEL__) || defined(_M_ARMT) ++ #define MY_CPU_NAME "armt" ++ #else ++ #define MY_CPU_NAME "arm" ++ #endif ++ /* #define MY_CPU_32BIT */ ++ #define MY_CPU_SIZEOF_POINTER 4 ++#endif ++ ++ ++#if defined(_M_IA64) \ ++ || defined(__ia64__) ++ #define MY_CPU_IA64 ++ #define MY_CPU_NAME "ia64" ++ #define MY_CPU_64BIT ++#endif ++ ++ ++#if defined(__mips64) \ ++ || defined(__mips64__) \ ++ || (defined(__mips) && (__mips == 64 || __mips == 4 || __mips == 3)) ++ #define MY_CPU_NAME "mips64" ++ #define MY_CPU_64BIT ++#elif defined(__mips__) ++ #define MY_CPU_NAME "mips" ++ /* #define MY_CPU_32BIT */ ++#endif ++ ++ ++#if defined(__ppc64__) \ ++ || defined(__powerpc64__) \ ++ || defined(__ppc__) \ ++ || defined(__powerpc__) \ ++ || defined(__PPC__) \ ++ || defined(_POWER) ++ ++#if defined(__ppc64__) \ ++ || defined(__powerpc64__) \ ++ || defined(_LP64) \ ++ || defined(__64BIT__) ++ #ifdef __ILP32__ ++ #define MY_CPU_NAME "ppc64-32" ++ #define MY_CPU_SIZEOF_POINTER 4 ++ #else ++ #define MY_CPU_NAME "ppc64" ++ #define MY_CPU_SIZEOF_POINTER 8 ++ #endif ++ #define MY_CPU_64BIT ++#else ++ #define MY_CPU_NAME "ppc" ++ #define MY_CPU_SIZEOF_POINTER 4 ++ /* #define MY_CPU_32BIT */ ++#endif ++#endif ++ ++ ++#if defined(__sparc64__) ++ #define MY_CPU_NAME "sparc64" ++ #define MY_CPU_64BIT ++#elif defined(__sparc__) ++ #define MY_CPU_NAME "sparc" ++ /* #define MY_CPU_32BIT */ ++#endif ++ ++ ++#if defined(MY_CPU_X86) || defined(MY_CPU_AMD64) ++#define MY_CPU_X86_OR_AMD64 ++#endif ++ ++#if defined(MY_CPU_ARM) || defined(MY_CPU_ARM64) ++#define MY_CPU_ARM_OR_ARM64 ++#endif ++ ++ ++#ifdef _WIN32 ++ ++ #ifdef MY_CPU_ARM ++ #define MY_CPU_ARM_LE ++ #endif ++ ++ #ifdef MY_CPU_ARM64 ++ #define MY_CPU_ARM64_LE ++ #endif ++ ++ #ifdef _M_IA64 ++ #define MY_CPU_IA64_LE ++ #endif ++ ++#endif ++ ++ ++#if defined(MY_CPU_X86_OR_AMD64) \ ++ || defined(MY_CPU_ARM_LE) \ ++ || defined(MY_CPU_ARM64_LE) \ ++ || defined(MY_CPU_IA64_LE) \ ++ || defined(__LITTLE_ENDIAN__) \ ++ || defined(__ARMEL__) \ ++ || defined(__THUMBEL__) \ ++ || defined(__AARCH64EL__) \ ++ || defined(__MIPSEL__) \ ++ || defined(__MIPSEL) \ ++ || defined(_MIPSEL) \ ++ || defined(__BFIN__) \ ++ || (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) ++ #define MY_CPU_LE ++#endif ++ ++#if defined(__BIG_ENDIAN__) \ ++ || defined(__ARMEB__) \ ++ || defined(__THUMBEB__) \ ++ || defined(__AARCH64EB__) \ ++ || defined(__MIPSEB__) \ ++ || defined(__MIPSEB) \ ++ || defined(_MIPSEB) \ ++ || defined(__m68k__) \ ++ || defined(__s390__) \ ++ || defined(__s390x__) \ ++ || defined(__zarch__) \ ++ || (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)) ++ #define MY_CPU_BE ++#endif ++ ++ ++#if defined(MY_CPU_LE) && defined(MY_CPU_BE) ++ #error Stop_Compiling_Bad_Endian ++#endif ++ ++ ++#if defined(MY_CPU_32BIT) && defined(MY_CPU_64BIT) ++ #error Stop_Compiling_Bad_32_64_BIT ++#endif ++ ++#ifdef __SIZEOF_POINTER__ ++ #ifdef MY_CPU_SIZEOF_POINTER ++ #if MY_CPU_SIZEOF_POINTER != __SIZEOF_POINTER__ ++ #error Stop_Compiling_Bad_MY_CPU_PTR_SIZE ++ #endif ++ #else ++ #define MY_CPU_SIZEOF_POINTER __SIZEOF_POINTER__ ++ #endif ++#endif ++ ++#if defined(MY_CPU_SIZEOF_POINTER) && (MY_CPU_SIZEOF_POINTER == 4) ++#if defined (_LP64) ++ #error Stop_Compiling_Bad_MY_CPU_PTR_SIZE ++#endif ++#endif ++ ++#ifdef _MSC_VER ++ #if _MSC_VER >= 1300 ++ #define MY_CPU_pragma_pack_push_1 __pragma(pack(push, 1)) ++ #define MY_CPU_pragma_pop __pragma(pack(pop)) ++ #else ++ #define MY_CPU_pragma_pack_push_1 ++ #define MY_CPU_pragma_pop ++ #endif ++#else ++ #ifdef __xlC__ ++ #define MY_CPU_pragma_pack_push_1 _Pragma("pack(1)") ++ #define MY_CPU_pragma_pop _Pragma("pack()") ++ #else ++ #define MY_CPU_pragma_pack_push_1 _Pragma("pack(push, 1)") ++ #define MY_CPU_pragma_pop _Pragma("pack(pop)") ++ #endif ++#endif ++ ++ ++#ifndef MY_CPU_NAME ++ #ifdef MY_CPU_LE ++ #define MY_CPU_NAME "LE" ++ #elif defined(MY_CPU_BE) ++ #define MY_CPU_NAME "BE" ++ #else ++ /* ++ #define MY_CPU_NAME "" ++ */ ++ #endif ++#endif ++ ++ ++ ++ ++ ++#ifdef MY_CPU_LE ++ #if defined(MY_CPU_X86_OR_AMD64) \ ++ || defined(MY_CPU_ARM64) ++ #define MY_CPU_LE_UNALIGN ++ #define MY_CPU_LE_UNALIGN_64 ++ #elif defined(__ARM_FEATURE_UNALIGNED) ++ /* gcc9 for 32-bit arm can use LDRD instruction that requires 32-bit alignment. ++ So we can't use unaligned 64-bit operations. */ ++ #define MY_CPU_LE_UNALIGN ++ #endif ++#endif ++ ++ ++#ifdef MY_CPU_LE_UNALIGN ++ ++#define GetUi16(p) (*(const UInt16 *)(const void *)(p)) ++#define GetUi32(p) (*(const UInt32 *)(const void *)(p)) ++#ifdef MY_CPU_LE_UNALIGN_64 ++#define GetUi64(p) (*(const UInt64 *)(const void *)(p)) ++#endif ++ ++#define SetUi16(p, v) { *(UInt16 *)(void *)(p) = (v); } ++#define SetUi32(p, v) { *(UInt32 *)(void *)(p) = (v); } ++#ifdef MY_CPU_LE_UNALIGN_64 ++#define SetUi64(p, v) { *(UInt64 *)(void *)(p) = (v); } ++#endif ++ ++#else ++ ++#define GetUi16(p) ( (UInt16) ( \ ++ ((const Byte *)(p))[0] | \ ++ ((UInt16)((const Byte *)(p))[1] << 8) )) ++ ++#define GetUi32(p) ( \ ++ ((const Byte *)(p))[0] | \ ++ ((UInt32)((const Byte *)(p))[1] << 8) | \ ++ ((UInt32)((const Byte *)(p))[2] << 16) | \ ++ ((UInt32)((const Byte *)(p))[3] << 24)) ++ ++#define SetUi16(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \ ++ _ppp_[0] = (Byte)_vvv_; \ ++ _ppp_[1] = (Byte)(_vvv_ >> 8); } ++ ++#define SetUi32(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \ ++ _ppp_[0] = (Byte)_vvv_; \ ++ _ppp_[1] = (Byte)(_vvv_ >> 8); \ ++ _ppp_[2] = (Byte)(_vvv_ >> 16); \ ++ _ppp_[3] = (Byte)(_vvv_ >> 24); } ++ ++#endif ++ ++ ++#ifndef MY_CPU_LE_UNALIGN_64 ++ ++#define GetUi64(p) (GetUi32(p) | ((UInt64)GetUi32(((const Byte *)(p)) + 4) << 32)) ++ ++#define SetUi64(p, v) { Byte *_ppp2_ = (Byte *)(p); UInt64 _vvv2_ = (v); \ ++ SetUi32(_ppp2_ , (UInt32)_vvv2_); \ ++ SetUi32(_ppp2_ + 4, (UInt32)(_vvv2_ >> 32)); } ++ ++#endif ++ ++ ++ ++ ++#ifdef __has_builtin ++ #define MY__has_builtin(x) __has_builtin(x) ++#else ++ #define MY__has_builtin(x) 0 ++#endif ++ ++#if defined(MY_CPU_LE_UNALIGN) && /* defined(_WIN64) && */ defined(_MSC_VER) && (_MSC_VER >= 1300) ++ ++/* Note: we use bswap instruction, that is unsupported in 386 cpu */ ++ ++#include ++ ++#pragma intrinsic(_byteswap_ushort) ++#pragma intrinsic(_byteswap_ulong) ++#pragma intrinsic(_byteswap_uint64) ++ ++/* #define GetBe16(p) _byteswap_ushort(*(const UInt16 *)(const Byte *)(p)) */ ++#define GetBe32(p) _byteswap_ulong (*(const UInt32 *)(const void *)(p)) ++#define GetBe64(p) _byteswap_uint64(*(const UInt64 *)(const void *)(p)) ++ ++#define SetBe32(p, v) (*(UInt32 *)(void *)(p)) = _byteswap_ulong(v) ++ ++#elif defined(MY_CPU_LE_UNALIGN) && ( \ ++ (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))) \ ++ || (defined(__clang__) && MY__has_builtin(__builtin_bswap16)) ) ++ ++/* #define GetBe16(p) __builtin_bswap16(*(const UInt16 *)(const void *)(p)) */ ++#define GetBe32(p) __builtin_bswap32(*(const UInt32 *)(const void *)(p)) ++#define GetBe64(p) __builtin_bswap64(*(const UInt64 *)(const void *)(p)) ++ ++#define SetBe32(p, v) (*(UInt32 *)(void *)(p)) = __builtin_bswap32(v) ++ ++#else ++ ++#define GetBe32(p) ( \ ++ ((UInt32)((const Byte *)(p))[0] << 24) | \ ++ ((UInt32)((const Byte *)(p))[1] << 16) | \ ++ ((UInt32)((const Byte *)(p))[2] << 8) | \ ++ ((const Byte *)(p))[3] ) ++ ++#define GetBe64(p) (((UInt64)GetBe32(p) << 32) | GetBe32(((const Byte *)(p)) + 4)) ++ ++#define SetBe32(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \ ++ _ppp_[0] = (Byte)(_vvv_ >> 24); \ ++ _ppp_[1] = (Byte)(_vvv_ >> 16); \ ++ _ppp_[2] = (Byte)(_vvv_ >> 8); \ ++ _ppp_[3] = (Byte)_vvv_; } ++ ++#endif ++ ++ ++#ifndef GetBe16 ++ ++#define GetBe16(p) ( (UInt16) ( \ ++ ((UInt16)((const Byte *)(p))[0] << 8) | \ ++ ((const Byte *)(p))[1] )) ++ ++#endif ++ ++ ++ ++#ifdef MY_CPU_X86_OR_AMD64 ++ ++typedef struct ++{ ++ UInt32 maxFunc; ++ UInt32 vendor[3]; ++ UInt32 ver; ++ UInt32 b; ++ UInt32 c; ++ UInt32 d; ++} Cx86cpuid; ++ ++enum ++{ ++ CPU_FIRM_INTEL, ++ CPU_FIRM_AMD, ++ CPU_FIRM_VIA ++}; ++ ++void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d); ++ ++BoolInt x86cpuid_CheckAndRead(Cx86cpuid *p); ++int x86cpuid_GetFirm(const Cx86cpuid *p); ++ ++#define x86cpuid_GetFamily(ver) (((ver >> 16) & 0xFF0) | ((ver >> 8) & 0xF)) ++#define x86cpuid_GetModel(ver) (((ver >> 12) & 0xF0) | ((ver >> 4) & 0xF)) ++#define x86cpuid_GetStepping(ver) (ver & 0xF) ++ ++BoolInt CPU_Is_InOrder(void); ++ ++BoolInt CPU_IsSupported_AES(void); ++BoolInt CPU_IsSupported_AVX2(void); ++BoolInt CPU_IsSupported_VAES_AVX2(void); ++BoolInt CPU_IsSupported_SSSE3(void); ++BoolInt CPU_IsSupported_SSE41(void); ++BoolInt CPU_IsSupported_SHA(void); ++BoolInt CPU_IsSupported_PageGB(void); ++ ++#elif defined(MY_CPU_ARM_OR_ARM64) ++ ++BoolInt CPU_IsSupported_CRC32(void); ++BoolInt CPU_IsSupported_NEON(void); ++ ++#if defined(_WIN32) ++BoolInt CPU_IsSupported_CRYPTO(void); ++#define CPU_IsSupported_SHA1 CPU_IsSupported_CRYPTO ++#define CPU_IsSupported_SHA2 CPU_IsSupported_CRYPTO ++#define CPU_IsSupported_AES CPU_IsSupported_CRYPTO ++#else ++BoolInt CPU_IsSupported_SHA1(void); ++BoolInt CPU_IsSupported_SHA2(void); ++BoolInt CPU_IsSupported_AES(void); ++#endif ++ ++#endif ++ ++#if defined(__APPLE__) ++int My_sysctlbyname_Get(const char *name, void *buf, size_t *bufSize); ++int My_sysctlbyname_Get_UInt32(const char *name, UInt32 *val); ++#endif ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/Delta.h b/src/lzma-sdk/C/Delta.h +new file mode 100644 +index 0000000..e59d5a2 +--- /dev/null ++++ b/src/lzma-sdk/C/Delta.h +@@ -0,0 +1,19 @@ ++/* Delta.h -- Delta converter ++2013-01-18 : Igor Pavlov : Public domain */ ++ ++#ifndef __DELTA_H ++#define __DELTA_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++#define DELTA_STATE_SIZE 256 ++ ++void Delta_Init(Byte *state); ++void Delta_Encode(Byte *state, unsigned delta, Byte *data, SizeT size); ++void Delta_Decode(Byte *state, unsigned delta, Byte *data, SizeT size); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/DllSecur.h b/src/lzma-sdk/C/DllSecur.h +new file mode 100644 +index 0000000..0fd8070 +--- /dev/null ++++ b/src/lzma-sdk/C/DllSecur.h +@@ -0,0 +1,20 @@ ++/* DllSecur.h -- DLL loading for security ++2018-02-19 : Igor Pavlov : Public domain */ ++ ++#ifndef __DLL_SECUR_H ++#define __DLL_SECUR_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++#ifdef _WIN32 ++ ++void My_SetDefaultDllDirectories(void); ++void LoadSecurityDlls(void); ++ ++#endif ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/LzFind.h b/src/lzma-sdk/C/LzFind.h +new file mode 100644 +index 0000000..8f9fade +--- /dev/null ++++ b/src/lzma-sdk/C/LzFind.h +@@ -0,0 +1,136 @@ ++/* LzFind.h -- Match finder for LZ algorithms ++2021-07-13 : Igor Pavlov : Public domain */ ++ ++#ifndef __LZ_FIND_H ++#define __LZ_FIND_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++typedef UInt32 CLzRef; ++ ++typedef struct _CMatchFinder ++{ ++ Byte *buffer; ++ UInt32 pos; ++ UInt32 posLimit; ++ UInt32 streamPos; /* wrap over Zero is allowed (streamPos < pos). Use (UInt32)(streamPos - pos) */ ++ UInt32 lenLimit; ++ ++ UInt32 cyclicBufferPos; ++ UInt32 cyclicBufferSize; /* it must be = (historySize + 1) */ ++ ++ Byte streamEndWasReached; ++ Byte btMode; ++ Byte bigHash; ++ Byte directInput; ++ ++ UInt32 matchMaxLen; ++ CLzRef *hash; ++ CLzRef *son; ++ UInt32 hashMask; ++ UInt32 cutValue; ++ ++ Byte *bufferBase; ++ ISeqInStream *stream; ++ ++ UInt32 blockSize; ++ UInt32 keepSizeBefore; ++ UInt32 keepSizeAfter; ++ ++ UInt32 numHashBytes; ++ size_t directInputRem; ++ UInt32 historySize; ++ UInt32 fixedHashSize; ++ UInt32 hashSizeSum; ++ SRes result; ++ UInt32 crc[256]; ++ size_t numRefs; ++ ++ UInt64 expectedDataSize; ++} CMatchFinder; ++ ++#define Inline_MatchFinder_GetPointerToCurrentPos(p) ((const Byte *)(p)->buffer) ++ ++#define Inline_MatchFinder_GetNumAvailableBytes(p) ((UInt32)((p)->streamPos - (p)->pos)) ++ ++/* ++#define Inline_MatchFinder_IsFinishedOK(p) \ ++ ((p)->streamEndWasReached \ ++ && (p)->streamPos == (p)->pos \ ++ && (!(p)->directInput || (p)->directInputRem == 0)) ++*/ ++ ++int MatchFinder_NeedMove(CMatchFinder *p); ++/* Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p); */ ++void MatchFinder_MoveBlock(CMatchFinder *p); ++void MatchFinder_ReadIfRequired(CMatchFinder *p); ++ ++void MatchFinder_Construct(CMatchFinder *p); ++ ++/* Conditions: ++ historySize <= 3 GB ++ keepAddBufferBefore + matchMaxLen + keepAddBufferAfter < 511MB ++*/ ++int MatchFinder_Create(CMatchFinder *p, UInt32 historySize, ++ UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter, ++ ISzAllocPtr alloc); ++void MatchFinder_Free(CMatchFinder *p, ISzAllocPtr alloc); ++void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, size_t numItems); ++// void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue); ++ ++/* ++#define Inline_MatchFinder_InitPos(p, val) \ ++ (p)->pos = (val); \ ++ (p)->streamPos = (val); ++*/ ++ ++#define Inline_MatchFinder_ReduceOffsets(p, subValue) \ ++ (p)->pos -= (subValue); \ ++ (p)->streamPos -= (subValue); ++ ++ ++UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *buffer, CLzRef *son, ++ size_t _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 _cutValue, ++ UInt32 *distances, UInt32 maxLen); ++ ++/* ++Conditions: ++ Mf_GetNumAvailableBytes_Func must be called before each Mf_GetMatchLen_Func. ++ Mf_GetPointerToCurrentPos_Func's result must be used only before any other function ++*/ ++ ++typedef void (*Mf_Init_Func)(void *object); ++typedef UInt32 (*Mf_GetNumAvailableBytes_Func)(void *object); ++typedef const Byte * (*Mf_GetPointerToCurrentPos_Func)(void *object); ++typedef UInt32 * (*Mf_GetMatches_Func)(void *object, UInt32 *distances); ++typedef void (*Mf_Skip_Func)(void *object, UInt32); ++ ++typedef struct _IMatchFinder ++{ ++ Mf_Init_Func Init; ++ Mf_GetNumAvailableBytes_Func GetNumAvailableBytes; ++ Mf_GetPointerToCurrentPos_Func GetPointerToCurrentPos; ++ Mf_GetMatches_Func GetMatches; ++ Mf_Skip_Func Skip; ++} IMatchFinder2; ++ ++void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder2 *vTable); ++ ++void MatchFinder_Init_LowHash(CMatchFinder *p); ++void MatchFinder_Init_HighHash(CMatchFinder *p); ++void MatchFinder_Init_4(CMatchFinder *p); ++void MatchFinder_Init(CMatchFinder *p); ++ ++UInt32* Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances); ++UInt32* Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances); ++ ++void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num); ++void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num); ++ ++void LzFindPrepare(void); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/LzFindMt.h b/src/lzma-sdk/C/LzFindMt.h +new file mode 100644 +index 0000000..ee9a1b6 +--- /dev/null ++++ b/src/lzma-sdk/C/LzFindMt.h +@@ -0,0 +1,109 @@ ++/* LzFindMt.h -- multithreaded Match finder for LZ algorithms ++2021-07-12 : Igor Pavlov : Public domain */ ++ ++#ifndef __LZ_FIND_MT_H ++#define __LZ_FIND_MT_H ++ ++#include "LzFind.h" ++#include "Threads.h" ++ ++EXTERN_C_BEGIN ++ ++typedef struct _CMtSync ++{ ++ UInt32 numProcessedBlocks; ++ CThread thread; ++ UInt64 affinity; ++ ++ BoolInt wasCreated; ++ BoolInt needStart; ++ BoolInt csWasInitialized; ++ BoolInt csWasEntered; ++ ++ BoolInt exit; ++ BoolInt stopWriting; ++ ++ CAutoResetEvent canStart; ++ CAutoResetEvent wasStopped; ++ CSemaphore freeSemaphore; ++ CSemaphore filledSemaphore; ++ CCriticalSection cs; ++ // UInt32 numBlocks_Sent; ++} CMtSync; ++ ++typedef UInt32 * (*Mf_Mix_Matches)(void *p, UInt32 matchMinPos, UInt32 *distances); ++ ++/* kMtCacheLineDummy must be >= size_of_CPU_cache_line */ ++#define kMtCacheLineDummy 128 ++ ++typedef void (*Mf_GetHeads)(const Byte *buffer, UInt32 pos, ++ UInt32 *hash, UInt32 hashMask, UInt32 *heads, UInt32 numHeads, const UInt32 *crc); ++ ++typedef struct _CMatchFinderMt ++{ ++ /* LZ */ ++ const Byte *pointerToCurPos; ++ UInt32 *btBuf; ++ const UInt32 *btBufPos; ++ const UInt32 *btBufPosLimit; ++ UInt32 lzPos; ++ UInt32 btNumAvailBytes; ++ ++ UInt32 *hash; ++ UInt32 fixedHashSize; ++ // UInt32 hash4Mask; ++ UInt32 historySize; ++ const UInt32 *crc; ++ ++ Mf_Mix_Matches MixMatchesFunc; ++ UInt32 failure_LZ_BT; // failure in BT transfered to LZ ++ // UInt32 failure_LZ_LZ; // failure in LZ tables ++ UInt32 failureBuf[1]; ++ // UInt32 crc[256]; ++ ++ /* LZ + BT */ ++ CMtSync btSync; ++ Byte btDummy[kMtCacheLineDummy]; ++ ++ /* BT */ ++ UInt32 *hashBuf; ++ UInt32 hashBufPos; ++ UInt32 hashBufPosLimit; ++ UInt32 hashNumAvail; ++ UInt32 failure_BT; ++ ++ ++ CLzRef *son; ++ UInt32 matchMaxLen; ++ UInt32 numHashBytes; ++ UInt32 pos; ++ const Byte *buffer; ++ UInt32 cyclicBufferPos; ++ UInt32 cyclicBufferSize; /* it must be = (historySize + 1) */ ++ UInt32 cutValue; ++ ++ /* BT + Hash */ ++ CMtSync hashSync; ++ /* Byte hashDummy[kMtCacheLineDummy]; */ ++ ++ /* Hash */ ++ Mf_GetHeads GetHeadsFunc; ++ CMatchFinder *MatchFinder; ++ // CMatchFinder MatchFinder; ++} CMatchFinderMt; ++ ++// only for Mt part ++void MatchFinderMt_Construct(CMatchFinderMt *p); ++void MatchFinderMt_Destruct(CMatchFinderMt *p, ISzAllocPtr alloc); ++ ++SRes MatchFinderMt_Create(CMatchFinderMt *p, UInt32 historySize, UInt32 keepAddBufferBefore, ++ UInt32 matchMaxLen, UInt32 keepAddBufferAfter, ISzAllocPtr alloc); ++void MatchFinderMt_CreateVTable(CMatchFinderMt *p, IMatchFinder2 *vTable); ++ ++/* call MatchFinderMt_InitMt() before IMatchFinder::Init() */ ++SRes MatchFinderMt_InitMt(CMatchFinderMt *p); ++void MatchFinderMt_ReleaseStream(CMatchFinderMt *p); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/LzHash.h b/src/lzma-sdk/C/LzHash.h +new file mode 100644 +index 0000000..a682f83 +--- /dev/null ++++ b/src/lzma-sdk/C/LzHash.h +@@ -0,0 +1,34 @@ ++/* LzHash.h -- HASH functions for LZ algorithms ++2019-10-30 : Igor Pavlov : Public domain */ ++ ++#ifndef __LZ_HASH_H ++#define __LZ_HASH_H ++ ++/* ++ (kHash2Size >= (1 << 8)) : Required ++ (kHash3Size >= (1 << 16)) : Required ++*/ ++ ++#define kHash2Size (1 << 10) ++#define kHash3Size (1 << 16) ++// #define kHash4Size (1 << 20) ++ ++#define kFix3HashSize (kHash2Size) ++#define kFix4HashSize (kHash2Size + kHash3Size) ++// #define kFix5HashSize (kHash2Size + kHash3Size + kHash4Size) ++ ++/* ++ We use up to 3 crc values for hash: ++ crc0 ++ crc1 << Shift_1 ++ crc2 << Shift_2 ++ (Shift_1 = 5) and (Shift_2 = 10) is good tradeoff. ++ Small values for Shift are not good for collision rate. ++ Big value for Shift_2 increases the minimum size ++ of hash table, that will be slow for small files. ++*/ ++ ++#define kLzHash_CrcShift_1 5 ++#define kLzHash_CrcShift_2 10 ++ ++#endif +diff --git a/src/lzma-sdk/C/Lzma2Dec.h b/src/lzma-sdk/C/Lzma2Dec.h +new file mode 100644 +index 0000000..da50387 +--- /dev/null ++++ b/src/lzma-sdk/C/Lzma2Dec.h +@@ -0,0 +1,120 @@ ++/* Lzma2Dec.h -- LZMA2 Decoder ++2018-02-19 : Igor Pavlov : Public domain */ ++ ++#ifndef __LZMA2_DEC_H ++#define __LZMA2_DEC_H ++ ++#include "LzmaDec.h" ++ ++EXTERN_C_BEGIN ++ ++/* ---------- State Interface ---------- */ ++ ++typedef struct ++{ ++ unsigned state; ++ Byte control; ++ Byte needInitLevel; ++ Byte isExtraMode; ++ Byte _pad_; ++ UInt32 packSize; ++ UInt32 unpackSize; ++ CLzmaDec decoder; ++} CLzma2Dec; ++ ++#define Lzma2Dec_Construct(p) LzmaDec_Construct(&(p)->decoder) ++#define Lzma2Dec_FreeProbs(p, alloc) LzmaDec_FreeProbs(&(p)->decoder, alloc) ++#define Lzma2Dec_Free(p, alloc) LzmaDec_Free(&(p)->decoder, alloc) ++ ++SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc); ++SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc); ++void Lzma2Dec_Init(CLzma2Dec *p); ++ ++/* ++finishMode: ++ It has meaning only if the decoding reaches output limit (*destLen or dicLimit). ++ LZMA_FINISH_ANY - use smallest number of input bytes ++ LZMA_FINISH_END - read EndOfStream marker after decoding ++ ++Returns: ++ SZ_OK ++ status: ++ LZMA_STATUS_FINISHED_WITH_MARK ++ LZMA_STATUS_NOT_FINISHED ++ LZMA_STATUS_NEEDS_MORE_INPUT ++ SZ_ERROR_DATA - Data error ++*/ ++ ++SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit, ++ const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status); ++ ++SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, ++ const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status); ++ ++ ++/* ---------- LZMA2 block and chunk parsing ---------- */ ++ ++/* ++Lzma2Dec_Parse() parses compressed data stream up to next independent block or next chunk data. ++It can return LZMA_STATUS_* code or LZMA2_PARSE_STATUS_* code: ++ - LZMA2_PARSE_STATUS_NEW_BLOCK - there is new block, and 1 additional byte (control byte of next block header) was read from input. ++ - LZMA2_PARSE_STATUS_NEW_CHUNK - there is new chunk, and only lzma2 header of new chunk was read. ++ CLzma2Dec::unpackSize contains unpack size of that chunk ++*/ ++ ++typedef enum ++{ ++/* ++ LZMA_STATUS_NOT_SPECIFIED // data error ++ LZMA_STATUS_FINISHED_WITH_MARK ++ LZMA_STATUS_NOT_FINISHED // ++ LZMA_STATUS_NEEDS_MORE_INPUT ++ LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK // unused ++*/ ++ LZMA2_PARSE_STATUS_NEW_BLOCK = LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK + 1, ++ LZMA2_PARSE_STATUS_NEW_CHUNK ++} ELzma2ParseStatus; ++ ++ELzma2ParseStatus Lzma2Dec_Parse(CLzma2Dec *p, ++ SizeT outSize, // output size ++ const Byte *src, SizeT *srcLen, ++ int checkFinishBlock // set (checkFinishBlock = 1), if it must read full input data, if decoder.dicPos reaches blockMax position. ++ ); ++ ++/* ++LZMA2 parser doesn't decode LZMA chunks, so we must read ++ full input LZMA chunk to decode some part of LZMA chunk. ++ ++Lzma2Dec_GetUnpackExtra() returns the value that shows ++ max possible number of output bytes that can be output by decoder ++ at current input positon. ++*/ ++ ++#define Lzma2Dec_GetUnpackExtra(p) ((p)->isExtraMode ? (p)->unpackSize : 0); ++ ++ ++/* ---------- One Call Interface ---------- */ ++ ++/* ++finishMode: ++ It has meaning only if the decoding reaches output limit (*destLen). ++ LZMA_FINISH_ANY - use smallest number of input bytes ++ LZMA_FINISH_END - read EndOfStream marker after decoding ++ ++Returns: ++ SZ_OK ++ status: ++ LZMA_STATUS_FINISHED_WITH_MARK ++ LZMA_STATUS_NOT_FINISHED ++ SZ_ERROR_DATA - Data error ++ SZ_ERROR_MEM - Memory allocation error ++ SZ_ERROR_UNSUPPORTED - Unsupported properties ++ SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src). ++*/ ++ ++SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ++ Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAllocPtr alloc); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/Lzma2DecMt.h b/src/lzma-sdk/C/Lzma2DecMt.h +new file mode 100644 +index 0000000..96f89a3 +--- /dev/null ++++ b/src/lzma-sdk/C/Lzma2DecMt.h +@@ -0,0 +1,79 @@ ++/* Lzma2DecMt.h -- LZMA2 Decoder Multi-thread ++2018-02-17 : Igor Pavlov : Public domain */ ++ ++#ifndef __LZMA2_DEC_MT_H ++#define __LZMA2_DEC_MT_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++typedef struct ++{ ++ size_t inBufSize_ST; ++ size_t outStep_ST; ++ ++ #ifndef _7ZIP_ST ++ unsigned numThreads; ++ size_t inBufSize_MT; ++ size_t outBlockMax; ++ size_t inBlockMax; ++ #endif ++} CLzma2DecMtProps; ++ ++/* init to single-thread mode */ ++void Lzma2DecMtProps_Init(CLzma2DecMtProps *p); ++ ++ ++/* ---------- CLzma2DecMtHandle Interface ---------- */ ++ ++/* Lzma2DecMt_ * functions can return the following exit codes: ++SRes: ++ SZ_OK - OK ++ SZ_ERROR_MEM - Memory allocation error ++ SZ_ERROR_PARAM - Incorrect paramater in props ++ SZ_ERROR_WRITE - ISeqOutStream write callback error ++ // SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output ++ SZ_ERROR_PROGRESS - some break from progress callback ++ SZ_ERROR_THREAD - error in multithreading functions (only for Mt version) ++*/ ++ ++typedef void * CLzma2DecMtHandle; ++ ++CLzma2DecMtHandle Lzma2DecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid); ++void Lzma2DecMt_Destroy(CLzma2DecMtHandle p); ++ ++SRes Lzma2DecMt_Decode(CLzma2DecMtHandle p, ++ Byte prop, ++ const CLzma2DecMtProps *props, ++ ISeqOutStream *outStream, ++ const UInt64 *outDataSize, // NULL means undefined ++ int finishMode, // 0 - partial unpacking is allowed, 1 - if lzma2 stream must be finished ++ // Byte *outBuf, size_t *outBufSize, ++ ISeqInStream *inStream, ++ // const Byte *inData, size_t inDataSize, ++ ++ // out variables: ++ UInt64 *inProcessed, ++ int *isMT, /* out: (*isMT == 0), if single thread decoding was used */ ++ ++ // UInt64 *outProcessed, ++ ICompressProgress *progress); ++ ++ ++/* ---------- Read from CLzma2DecMtHandle Interface ---------- */ ++ ++SRes Lzma2DecMt_Init(CLzma2DecMtHandle pp, ++ Byte prop, ++ const CLzma2DecMtProps *props, ++ const UInt64 *outDataSize, int finishMode, ++ ISeqInStream *inStream); ++ ++SRes Lzma2DecMt_Read(CLzma2DecMtHandle pp, ++ Byte *data, size_t *outSize, ++ UInt64 *inStreamProcessed); ++ ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/Lzma2Enc.h b/src/lzma-sdk/C/Lzma2Enc.h +new file mode 100644 +index 0000000..65f2dd1 +--- /dev/null ++++ b/src/lzma-sdk/C/Lzma2Enc.h +@@ -0,0 +1,55 @@ ++/* Lzma2Enc.h -- LZMA2 Encoder ++2017-07-27 : Igor Pavlov : Public domain */ ++ ++#ifndef __LZMA2_ENC_H ++#define __LZMA2_ENC_H ++ ++#include "LzmaEnc.h" ++ ++EXTERN_C_BEGIN ++ ++#define LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO 0 ++#define LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID ((UInt64)(Int64)-1) ++ ++typedef struct ++{ ++ CLzmaEncProps lzmaProps; ++ UInt64 blockSize; ++ int numBlockThreads_Reduced; ++ int numBlockThreads_Max; ++ int numTotalThreads; ++} CLzma2EncProps; ++ ++void Lzma2EncProps_Init(CLzma2EncProps *p); ++void Lzma2EncProps_Normalize(CLzma2EncProps *p); ++ ++/* ---------- CLzmaEnc2Handle Interface ---------- */ ++ ++/* Lzma2Enc_* functions can return the following exit codes: ++SRes: ++ SZ_OK - OK ++ SZ_ERROR_MEM - Memory allocation error ++ SZ_ERROR_PARAM - Incorrect paramater in props ++ SZ_ERROR_WRITE - ISeqOutStream write callback error ++ SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output ++ SZ_ERROR_PROGRESS - some break from progress callback ++ SZ_ERROR_THREAD - error in multithreading functions (only for Mt version) ++*/ ++ ++typedef void * CLzma2EncHandle; ++ ++CLzma2EncHandle Lzma2Enc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig); ++void Lzma2Enc_Destroy(CLzma2EncHandle p); ++SRes Lzma2Enc_SetProps(CLzma2EncHandle p, const CLzma2EncProps *props); ++void Lzma2Enc_SetDataSize(CLzma2EncHandle p, UInt64 expectedDataSiize); ++Byte Lzma2Enc_WriteProperties(CLzma2EncHandle p); ++SRes Lzma2Enc_Encode2(CLzma2EncHandle p, ++ ISeqOutStream *outStream, ++ Byte *outBuf, size_t *outBufSize, ++ ISeqInStream *inStream, ++ const Byte *inData, size_t inDataSize, ++ ICompressProgress *progress); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/Lzma86.h b/src/lzma-sdk/C/Lzma86.h +new file mode 100644 +index 0000000..83057e5 +--- /dev/null ++++ b/src/lzma-sdk/C/Lzma86.h +@@ -0,0 +1,111 @@ ++/* Lzma86.h -- LZMA + x86 (BCJ) Filter ++2013-01-18 : Igor Pavlov : Public domain */ ++ ++#ifndef __LZMA86_H ++#define __LZMA86_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++#define LZMA86_SIZE_OFFSET (1 + 5) ++#define LZMA86_HEADER_SIZE (LZMA86_SIZE_OFFSET + 8) ++ ++/* ++It's an example for LZMA + x86 Filter use. ++You can use .lzma86 extension, if you write that stream to file. ++.lzma86 header adds one additional byte to standard .lzma header. ++.lzma86 header (14 bytes): ++ Offset Size Description ++ 0 1 = 0 - no filter, pure LZMA ++ = 1 - x86 filter + LZMA ++ 1 1 lc, lp and pb in encoded form ++ 2 4 dictSize (little endian) ++ 6 8 uncompressed size (little endian) ++ ++ ++Lzma86_Encode ++------------- ++level - compression level: 0 <= level <= 9, the default value for "level" is 5. ++ ++dictSize - The dictionary size in bytes. The maximum value is ++ 128 MB = (1 << 27) bytes for 32-bit version ++ 1 GB = (1 << 30) bytes for 64-bit version ++ The default value is 16 MB = (1 << 24) bytes, for level = 5. ++ It's recommended to use the dictionary that is larger than 4 KB and ++ that can be calculated as (1 << N) or (3 << N) sizes. ++ For better compression ratio dictSize must be >= inSize. ++ ++filterMode: ++ SZ_FILTER_NO - no Filter ++ SZ_FILTER_YES - x86 Filter ++ SZ_FILTER_AUTO - it tries both alternatives to select best. ++ Encoder will use 2 or 3 passes: ++ 2 passes when FILTER_NO provides better compression. ++ 3 passes when FILTER_YES provides better compression. ++ ++Lzma86Encode allocates Data with MyAlloc functions. ++RAM Requirements for compressing: ++ RamSize = dictionarySize * 11.5 + 6MB + FilterBlockSize ++ filterMode FilterBlockSize ++ SZ_FILTER_NO 0 ++ SZ_FILTER_YES inSize ++ SZ_FILTER_AUTO inSize ++ ++ ++Return code: ++ SZ_OK - OK ++ SZ_ERROR_MEM - Memory allocation error ++ SZ_ERROR_PARAM - Incorrect paramater ++ SZ_ERROR_OUTPUT_EOF - output buffer overflow ++ SZ_ERROR_THREAD - errors in multithreading functions (only for Mt version) ++*/ ++ ++enum ESzFilterMode ++{ ++ SZ_FILTER_NO, ++ SZ_FILTER_YES, ++ SZ_FILTER_AUTO ++}; ++ ++SRes Lzma86_Encode(Byte *dest, size_t *destLen, const Byte *src, size_t srcLen, ++ int level, UInt32 dictSize, int filterMode); ++ ++ ++/* ++Lzma86_GetUnpackSize: ++ In: ++ src - input data ++ srcLen - input data size ++ Out: ++ unpackSize - size of uncompressed stream ++ Return code: ++ SZ_OK - OK ++ SZ_ERROR_INPUT_EOF - Error in headers ++*/ ++ ++SRes Lzma86_GetUnpackSize(const Byte *src, SizeT srcLen, UInt64 *unpackSize); ++ ++/* ++Lzma86_Decode: ++ In: ++ dest - output data ++ destLen - output data size ++ src - input data ++ srcLen - input data size ++ Out: ++ destLen - processed output size ++ srcLen - processed input size ++ Return code: ++ SZ_OK - OK ++ SZ_ERROR_DATA - Data error ++ SZ_ERROR_MEM - Memory allocation error ++ SZ_ERROR_UNSUPPORTED - unsupported file ++ SZ_ERROR_INPUT_EOF - it needs more bytes in input buffer ++*/ ++ ++SRes Lzma86_Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/LzmaDec.h b/src/lzma-sdk/C/LzmaDec.h +new file mode 100644 +index 0000000..6194b7d +--- /dev/null ++++ b/src/lzma-sdk/C/LzmaDec.h +@@ -0,0 +1,236 @@ ++/* LzmaDec.h -- LZMA Decoder ++2020-03-19 : Igor Pavlov : Public domain */ ++ ++#ifndef __LZMA_DEC_H ++#define __LZMA_DEC_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++/* #define _LZMA_PROB32 */ ++/* _LZMA_PROB32 can increase the speed on some CPUs, ++ but memory usage for CLzmaDec::probs will be doubled in that case */ ++ ++typedef ++#ifdef _LZMA_PROB32 ++ UInt32 ++#else ++ UInt16 ++#endif ++ CLzmaProb; ++ ++ ++/* ---------- LZMA Properties ---------- */ ++ ++#define LZMA_PROPS_SIZE 5 ++ ++typedef struct _CLzmaProps ++{ ++ Byte lc; ++ Byte lp; ++ Byte pb; ++ Byte _pad_; ++ UInt32 dicSize; ++} CLzmaProps; ++ ++/* LzmaProps_Decode - decodes properties ++Returns: ++ SZ_OK ++ SZ_ERROR_UNSUPPORTED - Unsupported properties ++*/ ++ ++SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size); ++ ++ ++/* ---------- LZMA Decoder state ---------- */ ++ ++/* LZMA_REQUIRED_INPUT_MAX = number of required input bytes for worst case. ++ Num bits = log2((2^11 / 31) ^ 22) + 26 < 134 + 26 = 160; */ ++ ++#define LZMA_REQUIRED_INPUT_MAX 20 ++ ++typedef struct ++{ ++ /* Don't change this structure. ASM code can use it. */ ++ CLzmaProps prop; ++ CLzmaProb *probs; ++ CLzmaProb *probs_1664; ++ Byte *dic; ++ SizeT dicBufSize; ++ SizeT dicPos; ++ const Byte *buf; ++ UInt32 range; ++ UInt32 code; ++ UInt32 processedPos; ++ UInt32 checkDicSize; ++ UInt32 reps[4]; ++ UInt32 state; ++ UInt32 remainLen; ++ ++ UInt32 numProbs; ++ unsigned tempBufSize; ++ Byte tempBuf[LZMA_REQUIRED_INPUT_MAX]; ++} CLzmaDec; ++ ++#define LzmaDec_Construct(p) { (p)->dic = NULL; (p)->probs = NULL; } ++ ++void LzmaDec_Init(CLzmaDec *p); ++ ++/* There are two types of LZMA streams: ++ - Stream with end mark. That end mark adds about 6 bytes to compressed size. ++ - Stream without end mark. You must know exact uncompressed size to decompress such stream. */ ++ ++typedef enum ++{ ++ LZMA_FINISH_ANY, /* finish at any point */ ++ LZMA_FINISH_END /* block must be finished at the end */ ++} ELzmaFinishMode; ++ ++/* ELzmaFinishMode has meaning only if the decoding reaches output limit !!! ++ ++ You must use LZMA_FINISH_END, when you know that current output buffer ++ covers last bytes of block. In other cases you must use LZMA_FINISH_ANY. ++ ++ If LZMA decoder sees end marker before reaching output limit, it returns SZ_OK, ++ and output value of destLen will be less than output buffer size limit. ++ You can check status result also. ++ ++ You can use multiple checks to test data integrity after full decompression: ++ 1) Check Result and "status" variable. ++ 2) Check that output(destLen) = uncompressedSize, if you know real uncompressedSize. ++ 3) Check that output(srcLen) = compressedSize, if you know real compressedSize. ++ You must use correct finish mode in that case. */ ++ ++typedef enum ++{ ++ LZMA_STATUS_NOT_SPECIFIED, /* use main error code instead */ ++ LZMA_STATUS_FINISHED_WITH_MARK, /* stream was finished with end mark. */ ++ LZMA_STATUS_NOT_FINISHED, /* stream was not finished */ ++ LZMA_STATUS_NEEDS_MORE_INPUT, /* you must provide more input bytes */ ++ LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK /* there is probability that stream was finished without end mark */ ++} ELzmaStatus; ++ ++/* ELzmaStatus is used only as output value for function call */ ++ ++ ++/* ---------- Interfaces ---------- */ ++ ++/* There are 3 levels of interfaces: ++ 1) Dictionary Interface ++ 2) Buffer Interface ++ 3) One Call Interface ++ You can select any of these interfaces, but don't mix functions from different ++ groups for same object. */ ++ ++ ++/* There are two variants to allocate state for Dictionary Interface: ++ 1) LzmaDec_Allocate / LzmaDec_Free ++ 2) LzmaDec_AllocateProbs / LzmaDec_FreeProbs ++ You can use variant 2, if you set dictionary buffer manually. ++ For Buffer Interface you must always use variant 1. ++ ++LzmaDec_Allocate* can return: ++ SZ_OK ++ SZ_ERROR_MEM - Memory allocation error ++ SZ_ERROR_UNSUPPORTED - Unsupported properties ++*/ ++ ++SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc); ++void LzmaDec_FreeProbs(CLzmaDec *p, ISzAllocPtr alloc); ++ ++SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc); ++void LzmaDec_Free(CLzmaDec *p, ISzAllocPtr alloc); ++ ++/* ---------- Dictionary Interface ---------- */ ++ ++/* You can use it, if you want to eliminate the overhead for data copying from ++ dictionary to some other external buffer. ++ You must work with CLzmaDec variables directly in this interface. ++ ++ STEPS: ++ LzmaDec_Construct() ++ LzmaDec_Allocate() ++ for (each new stream) ++ { ++ LzmaDec_Init() ++ while (it needs more decompression) ++ { ++ LzmaDec_DecodeToDic() ++ use data from CLzmaDec::dic and update CLzmaDec::dicPos ++ } ++ } ++ LzmaDec_Free() ++*/ ++ ++/* LzmaDec_DecodeToDic ++ ++ The decoding to internal dictionary buffer (CLzmaDec::dic). ++ You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!! ++ ++finishMode: ++ It has meaning only if the decoding reaches output limit (dicLimit). ++ LZMA_FINISH_ANY - Decode just dicLimit bytes. ++ LZMA_FINISH_END - Stream must be finished after dicLimit. ++ ++Returns: ++ SZ_OK ++ status: ++ LZMA_STATUS_FINISHED_WITH_MARK ++ LZMA_STATUS_NOT_FINISHED ++ LZMA_STATUS_NEEDS_MORE_INPUT ++ LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK ++ SZ_ERROR_DATA - Data error ++ SZ_ERROR_FAIL - Some unexpected error: internal error of code, memory corruption or hardware failure ++*/ ++ ++SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, ++ const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status); ++ ++ ++/* ---------- Buffer Interface ---------- */ ++ ++/* It's zlib-like interface. ++ See LzmaDec_DecodeToDic description for information about STEPS and return results, ++ but you must use LzmaDec_DecodeToBuf instead of LzmaDec_DecodeToDic and you don't need ++ to work with CLzmaDec variables manually. ++ ++finishMode: ++ It has meaning only if the decoding reaches output limit (*destLen). ++ LZMA_FINISH_ANY - Decode just destLen bytes. ++ LZMA_FINISH_END - Stream must be finished after (*destLen). ++*/ ++ ++SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, ++ const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status); ++ ++ ++/* ---------- One Call Interface ---------- */ ++ ++/* LzmaDecode ++ ++finishMode: ++ It has meaning only if the decoding reaches output limit (*destLen). ++ LZMA_FINISH_ANY - Decode just destLen bytes. ++ LZMA_FINISH_END - Stream must be finished after (*destLen). ++ ++Returns: ++ SZ_OK ++ status: ++ LZMA_STATUS_FINISHED_WITH_MARK ++ LZMA_STATUS_NOT_FINISHED ++ LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK ++ SZ_ERROR_DATA - Data error ++ SZ_ERROR_MEM - Memory allocation error ++ SZ_ERROR_UNSUPPORTED - Unsupported properties ++ SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src). ++ SZ_ERROR_FAIL - Some unexpected error: internal error of code, memory corruption or hardware failure ++*/ ++ ++SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ++ const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode, ++ ELzmaStatus *status, ISzAllocPtr alloc); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/LzmaEnc.h b/src/lzma-sdk/C/LzmaEnc.h +new file mode 100644 +index 0000000..26757ba +--- /dev/null ++++ b/src/lzma-sdk/C/LzmaEnc.h +@@ -0,0 +1,78 @@ ++/* LzmaEnc.h -- LZMA Encoder ++2019-10-30 : Igor Pavlov : Public domain */ ++ ++#ifndef __LZMA_ENC_H ++#define __LZMA_ENC_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++#define LZMA_PROPS_SIZE 5 ++ ++typedef struct _CLzmaEncProps ++{ ++ int level; /* 0 <= level <= 9 */ ++ UInt32 dictSize; /* (1 << 12) <= dictSize <= (1 << 27) for 32-bit version ++ (1 << 12) <= dictSize <= (3 << 29) for 64-bit version ++ default = (1 << 24) */ ++ int lc; /* 0 <= lc <= 8, default = 3 */ ++ int lp; /* 0 <= lp <= 4, default = 0 */ ++ int pb; /* 0 <= pb <= 4, default = 2 */ ++ int algo; /* 0 - fast, 1 - normal, default = 1 */ ++ int fb; /* 5 <= fb <= 273, default = 32 */ ++ int btMode; /* 0 - hashChain Mode, 1 - binTree mode - normal, default = 1 */ ++ int numHashBytes; /* 2, 3 or 4, default = 4 */ ++ UInt32 mc; /* 1 <= mc <= (1 << 30), default = 32 */ ++ unsigned writeEndMark; /* 0 - do not write EOPM, 1 - write EOPM, default = 0 */ ++ int numThreads; /* 1 or 2, default = 2 */ ++ ++ UInt64 reduceSize; /* estimated size of data that will be compressed. default = (UInt64)(Int64)-1. ++ Encoder uses this value to reduce dictionary size */ ++ ++ UInt64 affinity; ++} CLzmaEncProps; ++ ++void LzmaEncProps_Init(CLzmaEncProps *p); ++void LzmaEncProps_Normalize(CLzmaEncProps *p); ++UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2); ++ ++ ++/* ---------- CLzmaEncHandle Interface ---------- */ ++ ++/* LzmaEnc* functions can return the following exit codes: ++SRes: ++ SZ_OK - OK ++ SZ_ERROR_MEM - Memory allocation error ++ SZ_ERROR_PARAM - Incorrect paramater in props ++ SZ_ERROR_WRITE - ISeqOutStream write callback error ++ SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output ++ SZ_ERROR_PROGRESS - some break from progress callback ++ SZ_ERROR_THREAD - error in multithreading functions (only for Mt version) ++*/ ++ ++typedef void * CLzmaEncHandle; ++ ++CLzmaEncHandle LzmaEnc_Create(ISzAllocPtr alloc); ++void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAllocPtr alloc, ISzAllocPtr allocBig); ++ ++SRes LzmaEnc_SetProps(CLzmaEncHandle p, const CLzmaEncProps *props); ++void LzmaEnc_SetDataSize(CLzmaEncHandle p, UInt64 expectedDataSiize); ++SRes LzmaEnc_WriteProperties(CLzmaEncHandle p, Byte *properties, SizeT *size); ++unsigned LzmaEnc_IsWriteEndMark(CLzmaEncHandle p); ++ ++SRes LzmaEnc_Encode(CLzmaEncHandle p, ISeqOutStream *outStream, ISeqInStream *inStream, ++ ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig); ++SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen, ++ int writeEndMark, ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig); ++ ++ ++/* ---------- One Call Interface ---------- */ ++ ++SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen, ++ const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark, ++ ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/LzmaLib.h b/src/lzma-sdk/C/LzmaLib.h +new file mode 100644 +index 0000000..4103e22 +--- /dev/null ++++ b/src/lzma-sdk/C/LzmaLib.h +@@ -0,0 +1,138 @@ ++/* LzmaLib.h -- LZMA library interface ++2021-04-03 : Igor Pavlov : Public domain */ ++ ++#ifndef __LZMA_LIB_H ++#define __LZMA_LIB_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++#define MY_STDAPI int MY_STD_CALL ++ ++#define LZMA_PROPS_SIZE 5 ++ ++/* ++RAM requirements for LZMA: ++ for compression: (dictSize * 11.5 + 6 MB) + state_size ++ for decompression: dictSize + state_size ++ state_size = (4 + (1.5 << (lc + lp))) KB ++ by default (lc=3, lp=0), state_size = 16 KB. ++ ++LZMA properties (5 bytes) format ++ Offset Size Description ++ 0 1 lc, lp and pb in encoded form. ++ 1 4 dictSize (little endian). ++*/ ++ ++/* ++LzmaCompress ++------------ ++ ++outPropsSize - ++ In: the pointer to the size of outProps buffer; *outPropsSize = LZMA_PROPS_SIZE = 5. ++ Out: the pointer to the size of written properties in outProps buffer; *outPropsSize = LZMA_PROPS_SIZE = 5. ++ ++ LZMA Encoder will use defult values for any parameter, if it is ++ -1 for any from: level, loc, lp, pb, fb, numThreads ++ 0 for dictSize ++ ++level - compression level: 0 <= level <= 9; ++ ++ level dictSize algo fb ++ 0: 64 KB 0 32 ++ 1: 256 KB 0 32 ++ 2: 1 MB 0 32 ++ 3: 4 MB 0 32 ++ 4: 16 MB 0 32 ++ 5: 16 MB 1 32 ++ 6: 32 MB 1 32 ++ 7: 32 MB 1 64 ++ 8: 64 MB 1 64 ++ 9: 64 MB 1 64 ++ ++ The default value for "level" is 5. ++ ++ algo = 0 means fast method ++ algo = 1 means normal method ++ ++dictSize - The dictionary size in bytes. The maximum value is ++ 128 MB = (1 << 27) bytes for 32-bit version ++ 1 GB = (1 << 30) bytes for 64-bit version ++ The default value is 16 MB = (1 << 24) bytes. ++ It's recommended to use the dictionary that is larger than 4 KB and ++ that can be calculated as (1 << N) or (3 << N) sizes. ++ ++lc - The number of literal context bits (high bits of previous literal). ++ It can be in the range from 0 to 8. The default value is 3. ++ Sometimes lc=4 gives the gain for big files. ++ ++lp - The number of literal pos bits (low bits of current position for literals). ++ It can be in the range from 0 to 4. The default value is 0. ++ The lp switch is intended for periodical data when the period is equal to 2^lp. ++ For example, for 32-bit (4 bytes) periodical data you can use lp=2. Often it's ++ better to set lc=0, if you change lp switch. ++ ++pb - The number of pos bits (low bits of current position). ++ It can be in the range from 0 to 4. The default value is 2. ++ The pb switch is intended for periodical data when the period is equal 2^pb. ++ ++fb - Word size (the number of fast bytes). ++ It can be in the range from 5 to 273. The default value is 32. ++ Usually, a big number gives a little bit better compression ratio and ++ slower compression process. ++ ++numThreads - The number of thereads. 1 or 2. The default value is 2. ++ Fast mode (algo = 0) can use only 1 thread. ++ ++In: ++ dest - output data buffer ++ destLen - output data buffer size ++ src - input data ++ srcLen - input data size ++Out: ++ destLen - processed output size ++Returns: ++ SZ_OK - OK ++ SZ_ERROR_MEM - Memory allocation error ++ SZ_ERROR_PARAM - Incorrect paramater ++ SZ_ERROR_OUTPUT_EOF - output buffer overflow ++ SZ_ERROR_THREAD - errors in multithreading functions (only for Mt version) ++*/ ++ ++MY_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen, ++ unsigned char *outProps, size_t *outPropsSize, /* *outPropsSize must be = 5 */ ++ int level, /* 0 <= level <= 9, default = 5 */ ++ unsigned dictSize, /* default = (1 << 24) */ ++ int lc, /* 0 <= lc <= 8, default = 3 */ ++ int lp, /* 0 <= lp <= 4, default = 0 */ ++ int pb, /* 0 <= pb <= 4, default = 2 */ ++ int fb, /* 5 <= fb <= 273, default = 32 */ ++ int numThreads /* 1 or 2, default = 2 */ ++ ); ++ ++/* ++LzmaUncompress ++-------------- ++In: ++ dest - output data buffer ++ destLen - output data buffer size ++ src - input data ++ srcLen - input data size ++Out: ++ destLen - processed output size ++ srcLen - processed input size ++Returns: ++ SZ_OK - OK ++ SZ_ERROR_DATA - Data error ++ SZ_ERROR_MEM - Memory allocation arror ++ SZ_ERROR_UNSUPPORTED - Unsupported properties ++ SZ_ERROR_INPUT_EOF - it needs more bytes in input buffer (src) ++*/ ++ ++MY_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, SizeT *srcLen, ++ const unsigned char *props, size_t propsSize); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/MtCoder.h b/src/lzma-sdk/C/MtCoder.h +new file mode 100644 +index 0000000..603329d +--- /dev/null ++++ b/src/lzma-sdk/C/MtCoder.h +@@ -0,0 +1,141 @@ ++/* MtCoder.h -- Multi-thread Coder ++2018-07-04 : Igor Pavlov : Public domain */ ++ ++#ifndef __MT_CODER_H ++#define __MT_CODER_H ++ ++#include "MtDec.h" ++ ++EXTERN_C_BEGIN ++ ++/* ++ if ( defined MTCODER__USE_WRITE_THREAD) : main thread writes all data blocks to output stream ++ if (not defined MTCODER__USE_WRITE_THREAD) : any coder thread can write data blocks to output stream ++*/ ++/* #define MTCODER__USE_WRITE_THREAD */ ++ ++#ifndef _7ZIP_ST ++ #define MTCODER__GET_NUM_BLOCKS_FROM_THREADS(numThreads) ((numThreads) + (numThreads) / 8 + 1) ++ #define MTCODER__THREADS_MAX 64 ++ #define MTCODER__BLOCKS_MAX (MTCODER__GET_NUM_BLOCKS_FROM_THREADS(MTCODER__THREADS_MAX) + 3) ++#else ++ #define MTCODER__THREADS_MAX 1 ++ #define MTCODER__BLOCKS_MAX 1 ++#endif ++ ++ ++#ifndef _7ZIP_ST ++ ++ ++typedef struct ++{ ++ ICompressProgress vt; ++ CMtProgress *mtProgress; ++ UInt64 inSize; ++ UInt64 outSize; ++} CMtProgressThunk; ++ ++void MtProgressThunk_CreateVTable(CMtProgressThunk *p); ++ ++#define MtProgressThunk_Init(p) { (p)->inSize = 0; (p)->outSize = 0; } ++ ++ ++struct _CMtCoder; ++ ++ ++typedef struct ++{ ++ struct _CMtCoder *mtCoder; ++ unsigned index; ++ int stop; ++ Byte *inBuf; ++ ++ CAutoResetEvent startEvent; ++ CThread thread; ++} CMtCoderThread; ++ ++ ++typedef struct ++{ ++ SRes (*Code)(void *p, unsigned coderIndex, unsigned outBufIndex, ++ const Byte *src, size_t srcSize, int finished); ++ SRes (*Write)(void *p, unsigned outBufIndex); ++} IMtCoderCallback2; ++ ++ ++typedef struct ++{ ++ SRes res; ++ unsigned bufIndex; ++ BoolInt finished; ++} CMtCoderBlock; ++ ++ ++typedef struct _CMtCoder ++{ ++ /* input variables */ ++ ++ size_t blockSize; /* size of input block */ ++ unsigned numThreadsMax; ++ UInt64 expectedDataSize; ++ ++ ISeqInStream *inStream; ++ const Byte *inData; ++ size_t inDataSize; ++ ++ ICompressProgress *progress; ++ ISzAllocPtr allocBig; ++ ++ IMtCoderCallback2 *mtCallback; ++ void *mtCallbackObject; ++ ++ ++ /* internal variables */ ++ ++ size_t allocatedBufsSize; ++ ++ CAutoResetEvent readEvent; ++ CSemaphore blocksSemaphore; ++ ++ BoolInt stopReading; ++ SRes readRes; ++ ++ #ifdef MTCODER__USE_WRITE_THREAD ++ CAutoResetEvent writeEvents[MTCODER__BLOCKS_MAX]; ++ #else ++ CAutoResetEvent finishedEvent; ++ SRes writeRes; ++ unsigned writeIndex; ++ Byte ReadyBlocks[MTCODER__BLOCKS_MAX]; ++ LONG numFinishedThreads; ++ #endif ++ ++ unsigned numStartedThreadsLimit; ++ unsigned numStartedThreads; ++ ++ unsigned numBlocksMax; ++ unsigned blockIndex; ++ UInt64 readProcessed; ++ ++ CCriticalSection cs; ++ ++ unsigned freeBlockHead; ++ unsigned freeBlockList[MTCODER__BLOCKS_MAX]; ++ ++ CMtProgress mtProgress; ++ CMtCoderBlock blocks[MTCODER__BLOCKS_MAX]; ++ CMtCoderThread threads[MTCODER__THREADS_MAX]; ++} CMtCoder; ++ ++ ++void MtCoder_Construct(CMtCoder *p); ++void MtCoder_Destruct(CMtCoder *p); ++SRes MtCoder_Code(CMtCoder *p); ++ ++ ++#endif ++ ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/MtDec.h b/src/lzma-sdk/C/MtDec.h +new file mode 100644 +index 0000000..7a30b6a +--- /dev/null ++++ b/src/lzma-sdk/C/MtDec.h +@@ -0,0 +1,202 @@ ++/* MtDec.h -- Multi-thread Decoder ++2020-03-05 : Igor Pavlov : Public domain */ ++ ++#ifndef __MT_DEC_H ++#define __MT_DEC_H ++ ++#include "7zTypes.h" ++ ++#ifndef _7ZIP_ST ++#include "Threads.h" ++#endif ++ ++EXTERN_C_BEGIN ++ ++#ifndef _7ZIP_ST ++ ++#ifndef _7ZIP_ST ++ #define MTDEC__THREADS_MAX 32 ++#else ++ #define MTDEC__THREADS_MAX 1 ++#endif ++ ++ ++typedef struct ++{ ++ ICompressProgress *progress; ++ SRes res; ++ UInt64 totalInSize; ++ UInt64 totalOutSize; ++ CCriticalSection cs; ++} CMtProgress; ++ ++void MtProgress_Init(CMtProgress *p, ICompressProgress *progress); ++SRes MtProgress_Progress_ST(CMtProgress *p); ++SRes MtProgress_ProgressAdd(CMtProgress *p, UInt64 inSize, UInt64 outSize); ++SRes MtProgress_GetError(CMtProgress *p); ++void MtProgress_SetError(CMtProgress *p, SRes res); ++ ++struct _CMtDec; ++ ++typedef struct ++{ ++ struct _CMtDec *mtDec; ++ unsigned index; ++ void *inBuf; ++ ++ size_t inDataSize_Start; // size of input data in start block ++ UInt64 inDataSize; // total size of input data in all blocks ++ ++ CThread thread; ++ CAutoResetEvent canRead; ++ CAutoResetEvent canWrite; ++ void *allocaPtr; ++} CMtDecThread; ++ ++void MtDecThread_FreeInBufs(CMtDecThread *t); ++ ++ ++typedef enum ++{ ++ MTDEC_PARSE_CONTINUE, // continue this block with more input data ++ MTDEC_PARSE_OVERFLOW, // MT buffers overflow, need switch to single-thread ++ MTDEC_PARSE_NEW, // new block ++ MTDEC_PARSE_END // end of block threading. But we still can return to threading after Write(&needContinue) ++} EMtDecParseState; ++ ++typedef struct ++{ ++ // in ++ int startCall; ++ const Byte *src; ++ size_t srcSize; ++ // in : (srcSize == 0) is allowed ++ // out : it's allowed to return less that actually was used ? ++ int srcFinished; ++ ++ // out ++ EMtDecParseState state; ++ BoolInt canCreateNewThread; ++ UInt64 outPos; // check it (size_t) ++} CMtDecCallbackInfo; ++ ++ ++typedef struct ++{ ++ void (*Parse)(void *p, unsigned coderIndex, CMtDecCallbackInfo *ci); ++ ++ // PreCode() and Code(): ++ // (SRes_return_result != SZ_OK) means stop decoding, no need another blocks ++ SRes (*PreCode)(void *p, unsigned coderIndex); ++ SRes (*Code)(void *p, unsigned coderIndex, ++ const Byte *src, size_t srcSize, int srcFinished, ++ UInt64 *inCodePos, UInt64 *outCodePos, int *stop); ++ // stop - means stop another Code calls ++ ++ ++ /* Write() must be called, if Parse() was called ++ set (needWrite) if ++ { ++ && (was not interrupted by progress) ++ && (was not interrupted in previous block) ++ } ++ ++ out: ++ if (*needContinue), decoder still need to continue decoding with new iteration, ++ even after MTDEC_PARSE_END ++ if (*canRecode), we didn't flush current block data, so we still can decode current block later. ++ */ ++ SRes (*Write)(void *p, unsigned coderIndex, ++ BoolInt needWriteToStream, ++ const Byte *src, size_t srcSize, BoolInt isCross, ++ // int srcFinished, ++ BoolInt *needContinue, ++ BoolInt *canRecode); ++ ++} IMtDecCallback2; ++ ++ ++ ++typedef struct _CMtDec ++{ ++ /* input variables */ ++ ++ size_t inBufSize; /* size of input block */ ++ unsigned numThreadsMax; ++ // size_t inBlockMax; ++ unsigned numThreadsMax_2; ++ ++ ISeqInStream *inStream; ++ // const Byte *inData; ++ // size_t inDataSize; ++ ++ ICompressProgress *progress; ++ ISzAllocPtr alloc; ++ ++ IMtDecCallback2 *mtCallback; ++ void *mtCallbackObject; ++ ++ ++ /* internal variables */ ++ ++ size_t allocatedBufsSize; ++ ++ BoolInt exitThread; ++ WRes exitThreadWRes; ++ ++ UInt64 blockIndex; ++ BoolInt isAllocError; ++ BoolInt overflow; ++ SRes threadingErrorSRes; ++ ++ BoolInt needContinue; ++ ++ // CAutoResetEvent finishedEvent; ++ ++ SRes readRes; ++ SRes codeRes; ++ ++ BoolInt wasInterrupted; ++ ++ unsigned numStartedThreads_Limit; ++ unsigned numStartedThreads; ++ ++ Byte *crossBlock; ++ size_t crossStart; ++ size_t crossEnd; ++ UInt64 readProcessed; ++ BoolInt readWasFinished; ++ UInt64 inProcessed; ++ ++ unsigned filledThreadStart; ++ unsigned numFilledThreads; ++ ++ #ifndef _7ZIP_ST ++ BoolInt needInterrupt; ++ UInt64 interruptIndex; ++ CMtProgress mtProgress; ++ CMtDecThread threads[MTDEC__THREADS_MAX]; ++ #endif ++} CMtDec; ++ ++ ++void MtDec_Construct(CMtDec *p); ++void MtDec_Destruct(CMtDec *p); ++ ++/* ++MtDec_Code() returns: ++ SZ_OK - in most cases ++ MY_SRes_HRESULT_FROM_WRes(WRes_error) - in case of unexpected error in threading function ++*/ ++ ++SRes MtDec_Code(CMtDec *p); ++Byte *MtDec_GetCrossBuff(CMtDec *p); ++ ++int MtDec_PrepareRead(CMtDec *p); ++const Byte *MtDec_Read(CMtDec *p, size_t *inLim); ++ ++#endif ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/Ppmd.h b/src/lzma-sdk/C/Ppmd.h +new file mode 100644 +index 0000000..ee93ece +--- /dev/null ++++ b/src/lzma-sdk/C/Ppmd.h +@@ -0,0 +1,167 @@ ++/* Ppmd.h -- PPMD codec common code ++2021-04-13 : Igor Pavlov : Public domain ++This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */ ++ ++#ifndef __PPMD_H ++#define __PPMD_H ++ ++#include "CpuArch.h" ++ ++EXTERN_C_BEGIN ++ ++#if defined(MY_CPU_SIZEOF_POINTER) && (MY_CPU_SIZEOF_POINTER == 4) ++/* ++ PPMD code always uses 32-bit internal fields in PPMD structures to store internal references in main block. ++ if (PPMD_32BIT is defined), the PPMD code stores internal pointers to 32-bit reference fields. ++ if (PPMD_32BIT is NOT defined), the PPMD code stores internal UInt32 offsets to reference fields. ++ if (pointer size is 64-bit), then (PPMD_32BIT) mode is not allowed, ++ if (pointer size is 32-bit), then (PPMD_32BIT) mode is optional, ++ and it's allowed to disable PPMD_32BIT mode even if pointer is 32-bit. ++ PPMD code works slightly faster in (PPMD_32BIT) mode. ++*/ ++ #define PPMD_32BIT ++#endif ++ ++#define PPMD_INT_BITS 7 ++#define PPMD_PERIOD_BITS 7 ++#define PPMD_BIN_SCALE (1 << (PPMD_INT_BITS + PPMD_PERIOD_BITS)) ++ ++#define PPMD_GET_MEAN_SPEC(summ, shift, round) (((summ) + (1 << ((shift) - (round)))) >> (shift)) ++#define PPMD_GET_MEAN(summ) PPMD_GET_MEAN_SPEC((summ), PPMD_PERIOD_BITS, 2) ++#define PPMD_UPDATE_PROB_0(prob) ((prob) + (1 << PPMD_INT_BITS) - PPMD_GET_MEAN(prob)) ++#define PPMD_UPDATE_PROB_1(prob) ((prob) - PPMD_GET_MEAN(prob)) ++ ++#define PPMD_N1 4 ++#define PPMD_N2 4 ++#define PPMD_N3 4 ++#define PPMD_N4 ((128 + 3 - 1 * PPMD_N1 - 2 * PPMD_N2 - 3 * PPMD_N3) / 4) ++#define PPMD_NUM_INDEXES (PPMD_N1 + PPMD_N2 + PPMD_N3 + PPMD_N4) ++ ++MY_CPU_pragma_pack_push_1 ++/* Most compilers works OK here even without #pragma pack(push, 1), but some GCC compilers need it. */ ++ ++/* SEE-contexts for PPM-contexts with masked symbols */ ++typedef struct ++{ ++ UInt16 Summ; /* Freq */ ++ Byte Shift; /* Speed of Freq change; low Shift is for fast change */ ++ Byte Count; /* Count to next change of Shift */ ++} CPpmd_See; ++ ++#define Ppmd_See_Update(p) if ((p)->Shift < PPMD_PERIOD_BITS && --(p)->Count == 0) \ ++ { (p)->Summ = (UInt16)((p)->Summ << 1); (p)->Count = (Byte)(3 << (p)->Shift++); } ++ ++ ++typedef struct ++{ ++ Byte Symbol; ++ Byte Freq; ++ UInt16 Successor_0; ++ UInt16 Successor_1; ++} CPpmd_State; ++ ++typedef struct CPpmd_State2_ ++{ ++ Byte Symbol; ++ Byte Freq; ++} CPpmd_State2; ++ ++typedef struct CPpmd_State4_ ++{ ++ UInt16 Successor_0; ++ UInt16 Successor_1; ++} CPpmd_State4; ++ ++MY_CPU_pragma_pop ++ ++/* ++ PPMD code can write full CPpmd_State structure data to CPpmd*_Context ++ at (byte offset = 2) instead of some fields of original CPpmd*_Context structure. ++ ++ If we use pointers to different types, but that point to shared ++ memory space, we can have aliasing problem (strict aliasing). ++ ++ XLC compiler in -O2 mode can change the order of memory write instructions ++ in relation to read instructions, if we have use pointers to different types. ++ ++ To solve that aliasing problem we use combined CPpmd*_Context structure ++ with unions that contain the fields from both structures: ++ the original CPpmd*_Context and CPpmd_State. ++ So we can access the fields from both structures via one pointer, ++ and the compiler doesn't change the order of write instructions ++ in relation to read instructions. ++ ++ If we don't use memory write instructions to shared memory in ++ some local code, and we use only reading instructions (read only), ++ then probably it's safe to use pointers to different types for reading. ++*/ ++ ++ ++ ++#ifdef PPMD_32BIT ++ ++ #define Ppmd_Ref_Type(type) type * ++ #define Ppmd_GetRef(p, ptr) (ptr) ++ #define Ppmd_GetPtr(p, ptr) (ptr) ++ #define Ppmd_GetPtr_Type(p, ptr, note_type) (ptr) ++ ++#else ++ ++ #define Ppmd_Ref_Type(type) UInt32 ++ #define Ppmd_GetRef(p, ptr) ((UInt32)((Byte *)(ptr) - (p)->Base)) ++ #define Ppmd_GetPtr(p, offs) ((void *)((p)->Base + (offs))) ++ #define Ppmd_GetPtr_Type(p, offs, type) ((type *)Ppmd_GetPtr(p, offs)) ++ ++#endif // PPMD_32BIT ++ ++ ++typedef Ppmd_Ref_Type(CPpmd_State) CPpmd_State_Ref; ++typedef Ppmd_Ref_Type(void) CPpmd_Void_Ref; ++typedef Ppmd_Ref_Type(Byte) CPpmd_Byte_Ref; ++ ++ ++/* ++#ifdef MY_CPU_LE_UNALIGN ++// the unaligned 32-bit access latency can be too large, if the data is not in L1 cache. ++#define Ppmd_GET_SUCCESSOR(p) ((CPpmd_Void_Ref)*(const UInt32 *)(const void *)&(p)->Successor_0) ++#define Ppmd_SET_SUCCESSOR(p, v) *(UInt32 *)(void *)(void *)&(p)->Successor_0 = (UInt32)(v) ++ ++#else ++*/ ++ ++/* ++ We can write 16-bit halves to 32-bit (Successor) field in any selected order. ++ But the native order is more consistent way. ++ So we use the native order, if LE/BE order can be detected here at compile time. ++*/ ++ ++#ifdef MY_CPU_BE ++ ++ #define Ppmd_GET_SUCCESSOR(p) \ ++ ( (CPpmd_Void_Ref) (((UInt32)(p)->Successor_0 << 16) | (p)->Successor_1) ) ++ ++ #define Ppmd_SET_SUCCESSOR(p, v) { \ ++ (p)->Successor_0 = (UInt16)(((UInt32)(v) >> 16) /* & 0xFFFF */); \ ++ (p)->Successor_1 = (UInt16)((UInt32)(v) /* & 0xFFFF */); } ++ ++#else ++ ++ #define Ppmd_GET_SUCCESSOR(p) \ ++ ( (CPpmd_Void_Ref) ((p)->Successor_0 | ((UInt32)(p)->Successor_1 << 16)) ) ++ ++ #define Ppmd_SET_SUCCESSOR(p, v) { \ ++ (p)->Successor_0 = (UInt16)((UInt32)(v) /* & 0xFFFF */); \ ++ (p)->Successor_1 = (UInt16)(((UInt32)(v) >> 16) /* & 0xFFFF */); } ++ ++#endif ++ ++// #endif ++ ++ ++#define PPMD_SetAllBitsIn256Bytes(p) \ ++ { size_t z; for (z = 0; z < 256 / sizeof(p[0]); z += 8) { \ ++ p[z+7] = p[z+6] = p[z+5] = p[z+4] = p[z+3] = p[z+2] = p[z+1] = p[z+0] = ~(size_t)0; }} ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/Ppmd7.h b/src/lzma-sdk/C/Ppmd7.h +new file mode 100644 +index 0000000..297e35f +--- /dev/null ++++ b/src/lzma-sdk/C/Ppmd7.h +@@ -0,0 +1,181 @@ ++/* Ppmd7.h -- Ppmd7 (PPMdH) compression codec ++2021-04-13 : Igor Pavlov : Public domain ++This code is based on: ++ PPMd var.H (2001): Dmitry Shkarin : Public domain */ ++ ++ ++#ifndef __PPMD7_H ++#define __PPMD7_H ++ ++#include "Ppmd.h" ++ ++EXTERN_C_BEGIN ++ ++#define PPMD7_MIN_ORDER 2 ++#define PPMD7_MAX_ORDER 64 ++ ++#define PPMD7_MIN_MEM_SIZE (1 << 11) ++#define PPMD7_MAX_MEM_SIZE (0xFFFFFFFF - 12 * 3) ++ ++struct CPpmd7_Context_; ++ ++typedef Ppmd_Ref_Type(struct CPpmd7_Context_) CPpmd7_Context_Ref; ++ ++// MY_CPU_pragma_pack_push_1 ++ ++typedef struct CPpmd7_Context_ ++{ ++ UInt16 NumStats; ++ ++ ++ union ++ { ++ UInt16 SummFreq; ++ CPpmd_State2 State2; ++ } Union2; ++ ++ union ++ { ++ CPpmd_State_Ref Stats; ++ CPpmd_State4 State4; ++ } Union4; ++ ++ CPpmd7_Context_Ref Suffix; ++} CPpmd7_Context; ++ ++// MY_CPU_pragma_pop ++ ++#define Ppmd7Context_OneState(p) ((CPpmd_State *)&(p)->Union2) ++ ++ ++ ++ ++typedef struct ++{ ++ UInt32 Range; ++ UInt32 Code; ++ UInt32 Low; ++ IByteIn *Stream; ++} CPpmd7_RangeDec; ++ ++ ++typedef struct ++{ ++ UInt32 Range; ++ Byte Cache; ++ // Byte _dummy_[3]; ++ UInt64 Low; ++ UInt64 CacheSize; ++ IByteOut *Stream; ++} CPpmd7z_RangeEnc; ++ ++ ++typedef struct ++{ ++ CPpmd7_Context *MinContext, *MaxContext; ++ CPpmd_State *FoundState; ++ unsigned OrderFall, InitEsc, PrevSuccess, MaxOrder, HiBitsFlag; ++ Int32 RunLength, InitRL; /* must be 32-bit at least */ ++ ++ UInt32 Size; ++ UInt32 GlueCount; ++ UInt32 AlignOffset; ++ Byte *Base, *LoUnit, *HiUnit, *Text, *UnitsStart; ++ ++ ++ ++ ++ union ++ { ++ CPpmd7_RangeDec dec; ++ CPpmd7z_RangeEnc enc; ++ } rc; ++ ++ Byte Indx2Units[PPMD_NUM_INDEXES + 2]; // +2 for alignment ++ Byte Units2Indx[128]; ++ CPpmd_Void_Ref FreeList[PPMD_NUM_INDEXES]; ++ ++ Byte NS2BSIndx[256], NS2Indx[256]; ++ Byte ExpEscape[16]; ++ CPpmd_See DummySee, See[25][16]; ++ UInt16 BinSumm[128][64]; ++ // int LastSymbol; ++} CPpmd7; ++ ++ ++void Ppmd7_Construct(CPpmd7 *p); ++BoolInt Ppmd7_Alloc(CPpmd7 *p, UInt32 size, ISzAllocPtr alloc); ++void Ppmd7_Free(CPpmd7 *p, ISzAllocPtr alloc); ++void Ppmd7_Init(CPpmd7 *p, unsigned maxOrder); ++#define Ppmd7_WasAllocated(p) ((p)->Base != NULL) ++ ++ ++/* ---------- Internal Functions ---------- */ ++ ++#define Ppmd7_GetPtr(p, ptr) Ppmd_GetPtr(p, ptr) ++#define Ppmd7_GetContext(p, ptr) Ppmd_GetPtr_Type(p, ptr, CPpmd7_Context) ++#define Ppmd7_GetStats(p, ctx) Ppmd_GetPtr_Type(p, (ctx)->Union4.Stats, CPpmd_State) ++ ++void Ppmd7_Update1(CPpmd7 *p); ++void Ppmd7_Update1_0(CPpmd7 *p); ++void Ppmd7_Update2(CPpmd7 *p); ++ ++#define PPMD7_HiBitsFlag_3(sym) ((((unsigned)sym + 0xC0) >> (8 - 3)) & (1 << 3)) ++#define PPMD7_HiBitsFlag_4(sym) ((((unsigned)sym + 0xC0) >> (8 - 4)) & (1 << 4)) ++// #define PPMD7_HiBitsFlag_3(sym) ((sym) < 0x40 ? 0 : (1 << 3)) ++// #define PPMD7_HiBitsFlag_4(sym) ((sym) < 0x40 ? 0 : (1 << 4)) ++ ++#define Ppmd7_GetBinSumm(p) \ ++ &p->BinSumm[(size_t)(unsigned)Ppmd7Context_OneState(p->MinContext)->Freq - 1] \ ++ [ p->PrevSuccess + ((p->RunLength >> 26) & 0x20) \ ++ + p->NS2BSIndx[(size_t)Ppmd7_GetContext(p, p->MinContext->Suffix)->NumStats - 1] \ ++ + PPMD7_HiBitsFlag_4(Ppmd7Context_OneState(p->MinContext)->Symbol) \ ++ + (p->HiBitsFlag = PPMD7_HiBitsFlag_3(p->FoundState->Symbol)) ] ++ ++CPpmd_See *Ppmd7_MakeEscFreq(CPpmd7 *p, unsigned numMasked, UInt32 *scale); ++ ++ ++/* ++We support two versions of Ppmd7 (PPMdH) methods that use same CPpmd7 structure: ++ 1) Ppmd7a_*: original PPMdH ++ 2) Ppmd7z_*: modified PPMdH with 7z Range Coder ++Ppmd7_*: the structures and functions that are common for both versions of PPMd7 (PPMdH) ++*/ ++ ++/* ---------- Decode ---------- */ ++ ++#define PPMD7_SYM_END (-1) ++#define PPMD7_SYM_ERROR (-2) ++ ++/* ++You must set (CPpmd7::rc.dec.Stream) before Ppmd7*_RangeDec_Init() ++ ++Ppmd7*_DecodeSymbol() ++out: ++ >= 0 : decoded byte ++ -1 : PPMD7_SYM_END : End of payload marker ++ -2 : PPMD7_SYM_ERROR : Data error ++*/ ++ ++/* Ppmd7a_* : original PPMdH */ ++BoolInt Ppmd7a_RangeDec_Init(CPpmd7_RangeDec *p); ++#define Ppmd7a_RangeDec_IsFinishedOK(p) ((p)->Code == 0) ++int Ppmd7a_DecodeSymbol(CPpmd7 *p); ++ ++/* Ppmd7z_* : modified PPMdH with 7z Range Coder */ ++BoolInt Ppmd7z_RangeDec_Init(CPpmd7_RangeDec *p); ++#define Ppmd7z_RangeDec_IsFinishedOK(p) ((p)->Code == 0) ++int Ppmd7z_DecodeSymbol(CPpmd7 *p); ++// Byte *Ppmd7z_DecodeSymbols(CPpmd7 *p, Byte *buf, const Byte *lim); ++ ++ ++/* ---------- Encode ---------- */ ++ ++void Ppmd7z_Init_RangeEnc(CPpmd7 *p); ++void Ppmd7z_Flush_RangeEnc(CPpmd7 *p); ++// void Ppmd7z_EncodeSymbol(CPpmd7 *p, int symbol); ++void Ppmd7z_EncodeSymbols(CPpmd7 *p, const Byte *buf, const Byte *lim); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/Precomp.h b/src/lzma-sdk/C/Precomp.h +new file mode 100644 +index 0000000..edb5814 +--- /dev/null ++++ b/src/lzma-sdk/C/Precomp.h +@@ -0,0 +1,10 @@ ++/* Precomp.h -- StdAfx ++2013-11-12 : Igor Pavlov : Public domain */ ++ ++#ifndef __7Z_PRECOMP_H ++#define __7Z_PRECOMP_H ++ ++#include "Compiler.h" ++/* #include "7zTypes.h" */ ++ ++#endif +diff --git a/src/lzma-sdk/C/RotateDefs.h b/src/lzma-sdk/C/RotateDefs.h +new file mode 100644 +index 0000000..6c790e7 +--- /dev/null ++++ b/src/lzma-sdk/C/RotateDefs.h +@@ -0,0 +1,30 @@ ++/* RotateDefs.h -- Rotate functions ++2015-03-25 : Igor Pavlov : Public domain */ ++ ++#ifndef __ROTATE_DEFS_H ++#define __ROTATE_DEFS_H ++ ++#ifdef _MSC_VER ++ ++#include ++ ++/* don't use _rotl with MINGW. It can insert slow call to function. */ ++ ++/* #if (_MSC_VER >= 1200) */ ++#pragma intrinsic(_rotl) ++#pragma intrinsic(_rotr) ++/* #endif */ ++ ++#define rotlFixed(x, n) _rotl((x), (n)) ++#define rotrFixed(x, n) _rotr((x), (n)) ++ ++#else ++ ++/* new compilers can translate these macros to fast commands. */ ++ ++#define rotlFixed(x, n) (((x) << (n)) | ((x) >> (32 - (n)))) ++#define rotrFixed(x, n) (((x) >> (n)) | ((x) << (32 - (n)))) ++ ++#endif ++ ++#endif +diff --git a/src/lzma-sdk/C/Sha256.h b/src/lzma-sdk/C/Sha256.h +new file mode 100644 +index 0000000..f529339 +--- /dev/null ++++ b/src/lzma-sdk/C/Sha256.h +@@ -0,0 +1,76 @@ ++/* Sha256.h -- SHA-256 Hash ++2021-01-01 : Igor Pavlov : Public domain */ ++ ++#ifndef __7Z_SHA256_H ++#define __7Z_SHA256_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++#define SHA256_NUM_BLOCK_WORDS 16 ++#define SHA256_NUM_DIGEST_WORDS 8 ++ ++#define SHA256_BLOCK_SIZE (SHA256_NUM_BLOCK_WORDS * 4) ++#define SHA256_DIGEST_SIZE (SHA256_NUM_DIGEST_WORDS * 4) ++ ++typedef void (MY_FAST_CALL *SHA256_FUNC_UPDATE_BLOCKS)(UInt32 state[8], const Byte *data, size_t numBlocks); ++ ++/* ++ if (the system supports different SHA256 code implementations) ++ { ++ (CSha256::func_UpdateBlocks) will be used ++ (CSha256::func_UpdateBlocks) can be set by ++ Sha256_Init() - to default (fastest) ++ Sha256_SetFunction() - to any algo ++ } ++ else ++ { ++ (CSha256::func_UpdateBlocks) is ignored. ++ } ++*/ ++ ++typedef struct ++{ ++ SHA256_FUNC_UPDATE_BLOCKS func_UpdateBlocks; ++ UInt64 count; ++ UInt64 __pad_2[2]; ++ UInt32 state[SHA256_NUM_DIGEST_WORDS]; ++ ++ Byte buffer[SHA256_BLOCK_SIZE]; ++} CSha256; ++ ++ ++#define SHA256_ALGO_DEFAULT 0 ++#define SHA256_ALGO_SW 1 ++#define SHA256_ALGO_HW 2 ++ ++/* ++Sha256_SetFunction() ++return: ++ 0 - (algo) value is not supported, and func_UpdateBlocks was not changed ++ 1 - func_UpdateBlocks was set according (algo) value. ++*/ ++ ++BoolInt Sha256_SetFunction(CSha256 *p, unsigned algo); ++ ++void Sha256_InitState(CSha256 *p); ++void Sha256_Init(CSha256 *p); ++void Sha256_Update(CSha256 *p, const Byte *data, size_t size); ++void Sha256_Final(CSha256 *p, Byte *digest); ++ ++ ++ ++ ++// void MY_FAST_CALL Sha256_UpdateBlocks(UInt32 state[8], const Byte *data, size_t numBlocks); ++ ++/* ++call Sha256Prepare() once at program start. ++It prepares all supported implementations, and detects the fastest implementation. ++*/ ++ ++void Sha256Prepare(void); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/Sort.h b/src/lzma-sdk/C/Sort.h +new file mode 100644 +index 0000000..7209d78 +--- /dev/null ++++ b/src/lzma-sdk/C/Sort.h +@@ -0,0 +1,18 @@ ++/* Sort.h -- Sort functions ++2014-04-05 : Igor Pavlov : Public domain */ ++ ++#ifndef __7Z_SORT_H ++#define __7Z_SORT_H ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++void HeapSort(UInt32 *p, size_t size); ++void HeapSort64(UInt64 *p, size_t size); ++ ++/* void HeapSortRef(UInt32 *p, UInt32 *vals, size_t size); */ ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/Threads.h b/src/lzma-sdk/C/Threads.h +new file mode 100644 +index 0000000..e9493af +--- /dev/null ++++ b/src/lzma-sdk/C/Threads.h +@@ -0,0 +1,232 @@ ++/* Threads.h -- multithreading library ++2021-12-21 : Igor Pavlov : Public domain */ ++ ++#ifndef __7Z_THREADS_H ++#define __7Z_THREADS_H ++ ++#ifdef _WIN32 ++#include ++#else ++ ++#if defined(__linux__) ++#if !defined(__APPLE__) && !defined(_AIX) && !defined(__ANDROID__) ++#ifndef _7ZIP_AFFINITY_DISABLE ++#define _7ZIP_AFFINITY_SUPPORTED ++// #pragma message(" ==== _7ZIP_AFFINITY_SUPPORTED") ++// #define _GNU_SOURCE ++#endif ++#endif ++#endif ++ ++#include ++ ++#endif ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++#ifdef _WIN32 ++ ++WRes HandlePtr_Close(HANDLE *h); ++WRes Handle_WaitObject(HANDLE h); ++ ++typedef HANDLE CThread; ++ ++#define Thread_Construct(p) { *(p) = NULL; } ++#define Thread_WasCreated(p) (*(p) != NULL) ++#define Thread_Close(p) HandlePtr_Close(p) ++// #define Thread_Wait(p) Handle_WaitObject(*(p)) ++ ++#ifdef UNDER_CE ++ // if (USE_THREADS_CreateThread is defined), we use _beginthreadex() ++ // if (USE_THREADS_CreateThread is not definned), we use CreateThread() ++ #define USE_THREADS_CreateThread ++#endif ++ ++typedef ++ #ifdef USE_THREADS_CreateThread ++ DWORD ++ #else ++ unsigned ++ #endif ++ THREAD_FUNC_RET_TYPE; ++ ++typedef DWORD_PTR CAffinityMask; ++typedef DWORD_PTR CCpuSet; ++ ++#define CpuSet_Zero(p) { *(p) = 0; } ++#define CpuSet_Set(p, cpu) { *(p) |= ((DWORD_PTR)1 << (cpu)); } ++ ++#else // _WIN32 ++ ++typedef struct _CThread ++{ ++ pthread_t _tid; ++ int _created; ++} CThread; ++ ++#define Thread_Construct(p) { (p)->_tid = 0; (p)->_created = 0; } ++#define Thread_WasCreated(p) ((p)->_created != 0) ++WRes Thread_Close(CThread *p); ++// #define Thread_Wait Thread_Wait_Close ++ ++typedef void * THREAD_FUNC_RET_TYPE; ++ ++typedef UInt64 CAffinityMask; ++ ++#ifdef _7ZIP_AFFINITY_SUPPORTED ++ ++typedef cpu_set_t CCpuSet; ++#define CpuSet_Zero(p) CPU_ZERO(p) ++#define CpuSet_Set(p, cpu) CPU_SET(cpu, p) ++#define CpuSet_IsSet(p, cpu) CPU_ISSET(cpu, p) ++ ++#else ++ ++typedef UInt64 CCpuSet; ++#define CpuSet_Zero(p) { *(p) = 0; } ++#define CpuSet_Set(p, cpu) { *(p) |= ((UInt64)1 << (cpu)); } ++#define CpuSet_IsSet(p, cpu) ((*(p) & ((UInt64)1 << (cpu))) != 0) ++ ++#endif ++ ++ ++#endif // _WIN32 ++ ++ ++#define THREAD_FUNC_CALL_TYPE MY_STD_CALL ++ ++#if defined(_WIN32) && defined(__GNUC__) ++/* GCC compiler for x86 32-bit uses the rule: ++ the stack is 16-byte aligned before CALL instruction for function calling. ++ But only root function main() contains instructions that ++ set 16-byte alignment for stack pointer. And another functions ++ just keep alignment, if it was set in some parent function. ++ ++ The problem: ++ if we create new thread in MinGW (GCC) 32-bit x86 via _beginthreadex() or CreateThread(), ++ the root function of thread doesn't set 16-byte alignment. ++ And stack frames in all child functions also will be unaligned in that case. ++ ++ Here we set (force_align_arg_pointer) attribute for root function of new thread. ++ Do we need (force_align_arg_pointer) also for another systems? */ ++ ++ #define THREAD_FUNC_ATTRIB_ALIGN_ARG __attribute__((force_align_arg_pointer)) ++ // #define THREAD_FUNC_ATTRIB_ALIGN_ARG // for debug : bad alignment in SSE functions ++#else ++ #define THREAD_FUNC_ATTRIB_ALIGN_ARG ++#endif ++ ++#define THREAD_FUNC_DECL THREAD_FUNC_ATTRIB_ALIGN_ARG THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE ++ ++typedef THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE * THREAD_FUNC_TYPE)(void *); ++WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param); ++WRes Thread_Create_With_Affinity(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, CAffinityMask affinity); ++WRes Thread_Wait_Close(CThread *p); ++ ++#ifdef _WIN32 ++#define Thread_Create_With_CpuSet(p, func, param, cs) \ ++ Thread_Create_With_Affinity(p, func, param, *cs) ++#else ++WRes Thread_Create_With_CpuSet(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, const CCpuSet *cpuSet); ++#endif ++ ++ ++#ifdef _WIN32 ++ ++typedef HANDLE CEvent; ++typedef CEvent CAutoResetEvent; ++typedef CEvent CManualResetEvent; ++#define Event_Construct(p) *(p) = NULL ++#define Event_IsCreated(p) (*(p) != NULL) ++#define Event_Close(p) HandlePtr_Close(p) ++#define Event_Wait(p) Handle_WaitObject(*(p)) ++WRes Event_Set(CEvent *p); ++WRes Event_Reset(CEvent *p); ++WRes ManualResetEvent_Create(CManualResetEvent *p, int signaled); ++WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *p); ++WRes AutoResetEvent_Create(CAutoResetEvent *p, int signaled); ++WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *p); ++ ++typedef HANDLE CSemaphore; ++#define Semaphore_Construct(p) *(p) = NULL ++#define Semaphore_IsCreated(p) (*(p) != NULL) ++#define Semaphore_Close(p) HandlePtr_Close(p) ++#define Semaphore_Wait(p) Handle_WaitObject(*(p)) ++WRes Semaphore_Create(CSemaphore *p, UInt32 initCount, UInt32 maxCount); ++WRes Semaphore_OptCreateInit(CSemaphore *p, UInt32 initCount, UInt32 maxCount); ++WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 num); ++WRes Semaphore_Release1(CSemaphore *p); ++ ++typedef CRITICAL_SECTION CCriticalSection; ++WRes CriticalSection_Init(CCriticalSection *p); ++#define CriticalSection_Delete(p) DeleteCriticalSection(p) ++#define CriticalSection_Enter(p) EnterCriticalSection(p) ++#define CriticalSection_Leave(p) LeaveCriticalSection(p) ++ ++ ++#else // _WIN32 ++ ++typedef struct _CEvent ++{ ++ int _created; ++ int _manual_reset; ++ int _state; ++ pthread_mutex_t _mutex; ++ pthread_cond_t _cond; ++} CEvent; ++ ++typedef CEvent CAutoResetEvent; ++typedef CEvent CManualResetEvent; ++ ++#define Event_Construct(p) (p)->_created = 0 ++#define Event_IsCreated(p) ((p)->_created) ++ ++WRes ManualResetEvent_Create(CManualResetEvent *p, int signaled); ++WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *p); ++WRes AutoResetEvent_Create(CAutoResetEvent *p, int signaled); ++WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *p); ++WRes Event_Set(CEvent *p); ++WRes Event_Reset(CEvent *p); ++WRes Event_Wait(CEvent *p); ++WRes Event_Close(CEvent *p); ++ ++ ++typedef struct _CSemaphore ++{ ++ int _created; ++ UInt32 _count; ++ UInt32 _maxCount; ++ pthread_mutex_t _mutex; ++ pthread_cond_t _cond; ++} CSemaphore; ++ ++#define Semaphore_Construct(p) (p)->_created = 0 ++#define Semaphore_IsCreated(p) ((p)->_created) ++ ++WRes Semaphore_Create(CSemaphore *p, UInt32 initCount, UInt32 maxCount); ++WRes Semaphore_OptCreateInit(CSemaphore *p, UInt32 initCount, UInt32 maxCount); ++WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 num); ++#define Semaphore_Release1(p) Semaphore_ReleaseN(p, 1) ++WRes Semaphore_Wait(CSemaphore *p); ++WRes Semaphore_Close(CSemaphore *p); ++ ++ ++typedef struct _CCriticalSection ++{ ++ pthread_mutex_t _mutex; ++} CCriticalSection; ++ ++WRes CriticalSection_Init(CCriticalSection *p); ++void CriticalSection_Delete(CCriticalSection *cs); ++void CriticalSection_Enter(CCriticalSection *cs); ++void CriticalSection_Leave(CCriticalSection *cs); ++ ++LONG InterlockedIncrement(LONG volatile *addend); ++ ++#endif // _WIN32 ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/Util/7z/Precomp.h b/src/lzma-sdk/C/Util/7z/Precomp.h +new file mode 100644 +index 0000000..9f398d0 +--- /dev/null ++++ b/src/lzma-sdk/C/Util/7z/Precomp.h +@@ -0,0 +1,10 @@ ++/* Precomp.h -- StdAfx ++2013-06-16 : Igor Pavlov : Public domain */ ++ ++#ifndef __7Z_PRECOMP_H ++#define __7Z_PRECOMP_H ++ ++#include "../../Compiler.h" ++#include "../../7zTypes.h" ++ ++#endif +diff --git a/src/lzma-sdk/C/Util/SfxSetup/Precomp.h b/src/lzma-sdk/C/Util/SfxSetup/Precomp.h +new file mode 100644 +index 0000000..9f398d0 +--- /dev/null ++++ b/src/lzma-sdk/C/Util/SfxSetup/Precomp.h +@@ -0,0 +1,10 @@ ++/* Precomp.h -- StdAfx ++2013-06-16 : Igor Pavlov : Public domain */ ++ ++#ifndef __7Z_PRECOMP_H ++#define __7Z_PRECOMP_H ++ ++#include "../../Compiler.h" ++#include "../../7zTypes.h" ++ ++#endif +diff --git a/src/lzma-sdk/C/Xz.h b/src/lzma-sdk/C/Xz.h +new file mode 100644 +index 0000000..cf9458e +--- /dev/null ++++ b/src/lzma-sdk/C/Xz.h +@@ -0,0 +1,517 @@ ++/* Xz.h - Xz interface ++2021-04-01 : Igor Pavlov : Public domain */ ++ ++#ifndef __XZ_H ++#define __XZ_H ++ ++#include "Sha256.h" ++ ++EXTERN_C_BEGIN ++ ++#define XZ_ID_Subblock 1 ++#define XZ_ID_Delta 3 ++#define XZ_ID_X86 4 ++#define XZ_ID_PPC 5 ++#define XZ_ID_IA64 6 ++#define XZ_ID_ARM 7 ++#define XZ_ID_ARMT 8 ++#define XZ_ID_SPARC 9 ++#define XZ_ID_LZMA2 0x21 ++ ++unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value); ++unsigned Xz_WriteVarInt(Byte *buf, UInt64 v); ++ ++/* ---------- xz block ---------- */ ++ ++#define XZ_BLOCK_HEADER_SIZE_MAX 1024 ++ ++#define XZ_NUM_FILTERS_MAX 4 ++#define XZ_BF_NUM_FILTERS_MASK 3 ++#define XZ_BF_PACK_SIZE (1 << 6) ++#define XZ_BF_UNPACK_SIZE (1 << 7) ++ ++#define XZ_FILTER_PROPS_SIZE_MAX 20 ++ ++typedef struct ++{ ++ UInt64 id; ++ UInt32 propsSize; ++ Byte props[XZ_FILTER_PROPS_SIZE_MAX]; ++} CXzFilter; ++ ++typedef struct ++{ ++ UInt64 packSize; ++ UInt64 unpackSize; ++ Byte flags; ++ CXzFilter filters[XZ_NUM_FILTERS_MAX]; ++} CXzBlock; ++ ++#define XzBlock_GetNumFilters(p) (((unsigned)(p)->flags & XZ_BF_NUM_FILTERS_MASK) + 1) ++#define XzBlock_HasPackSize(p) (((p)->flags & XZ_BF_PACK_SIZE) != 0) ++#define XzBlock_HasUnpackSize(p) (((p)->flags & XZ_BF_UNPACK_SIZE) != 0) ++#define XzBlock_HasUnsupportedFlags(p) (((p)->flags & ~(XZ_BF_NUM_FILTERS_MASK | XZ_BF_PACK_SIZE | XZ_BF_UNPACK_SIZE)) != 0) ++ ++SRes XzBlock_Parse(CXzBlock *p, const Byte *header); ++SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStream *inStream, BoolInt *isIndex, UInt32 *headerSizeRes); ++ ++/* ---------- xz stream ---------- */ ++ ++#define XZ_SIG_SIZE 6 ++#define XZ_FOOTER_SIG_SIZE 2 ++ ++extern const Byte XZ_SIG[XZ_SIG_SIZE]; ++ ++/* ++extern const Byte XZ_FOOTER_SIG[XZ_FOOTER_SIG_SIZE]; ++*/ ++ ++#define XZ_FOOTER_SIG_0 'Y' ++#define XZ_FOOTER_SIG_1 'Z' ++ ++#define XZ_STREAM_FLAGS_SIZE 2 ++#define XZ_STREAM_CRC_SIZE 4 ++ ++#define XZ_STREAM_HEADER_SIZE (XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE + XZ_STREAM_CRC_SIZE) ++#define XZ_STREAM_FOOTER_SIZE (XZ_FOOTER_SIG_SIZE + XZ_STREAM_FLAGS_SIZE + XZ_STREAM_CRC_SIZE + 4) ++ ++#define XZ_CHECK_MASK 0xF ++#define XZ_CHECK_NO 0 ++#define XZ_CHECK_CRC32 1 ++#define XZ_CHECK_CRC64 4 ++#define XZ_CHECK_SHA256 10 ++ ++typedef struct ++{ ++ unsigned mode; ++ UInt32 crc; ++ UInt64 crc64; ++ CSha256 sha; ++} CXzCheck; ++ ++void XzCheck_Init(CXzCheck *p, unsigned mode); ++void XzCheck_Update(CXzCheck *p, const void *data, size_t size); ++int XzCheck_Final(CXzCheck *p, Byte *digest); ++ ++typedef UInt16 CXzStreamFlags; ++ ++#define XzFlags_IsSupported(f) ((f) <= XZ_CHECK_MASK) ++#define XzFlags_GetCheckType(f) ((f) & XZ_CHECK_MASK) ++#define XzFlags_HasDataCrc32(f) (Xz_GetCheckType(f) == XZ_CHECK_CRC32) ++unsigned XzFlags_GetCheckSize(CXzStreamFlags f); ++ ++SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf); ++SRes Xz_ReadHeader(CXzStreamFlags *p, ISeqInStream *inStream); ++ ++typedef struct ++{ ++ UInt64 unpackSize; ++ UInt64 totalSize; ++} CXzBlockSizes; ++ ++typedef struct ++{ ++ CXzStreamFlags flags; ++ size_t numBlocks; ++ CXzBlockSizes *blocks; ++ UInt64 startOffset; ++} CXzStream; ++ ++void Xz_Construct(CXzStream *p); ++void Xz_Free(CXzStream *p, ISzAllocPtr alloc); ++ ++#define XZ_SIZE_OVERFLOW ((UInt64)(Int64)-1) ++ ++UInt64 Xz_GetUnpackSize(const CXzStream *p); ++UInt64 Xz_GetPackSize(const CXzStream *p); ++ ++typedef struct ++{ ++ size_t num; ++ size_t numAllocated; ++ CXzStream *streams; ++} CXzs; ++ ++void Xzs_Construct(CXzs *p); ++void Xzs_Free(CXzs *p, ISzAllocPtr alloc); ++SRes Xzs_ReadBackward(CXzs *p, ILookInStream *inStream, Int64 *startOffset, ICompressProgress *progress, ISzAllocPtr alloc); ++ ++UInt64 Xzs_GetNumBlocks(const CXzs *p); ++UInt64 Xzs_GetUnpackSize(const CXzs *p); ++ ++ ++// ECoderStatus values are identical to ELzmaStatus values of LZMA2 decoder ++ ++typedef enum ++{ ++ CODER_STATUS_NOT_SPECIFIED, /* use main error code instead */ ++ CODER_STATUS_FINISHED_WITH_MARK, /* stream was finished with end mark. */ ++ CODER_STATUS_NOT_FINISHED, /* stream was not finished */ ++ CODER_STATUS_NEEDS_MORE_INPUT /* you must provide more input bytes */ ++} ECoderStatus; ++ ++ ++// ECoderFinishMode values are identical to ELzmaFinishMode ++ ++typedef enum ++{ ++ CODER_FINISH_ANY, /* finish at any point */ ++ CODER_FINISH_END /* block must be finished at the end */ ++} ECoderFinishMode; ++ ++ ++typedef struct _IStateCoder ++{ ++ void *p; ++ void (*Free)(void *p, ISzAllocPtr alloc); ++ SRes (*SetProps)(void *p, const Byte *props, size_t propSize, ISzAllocPtr alloc); ++ void (*Init)(void *p); ++ SRes (*Code2)(void *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ++ int srcWasFinished, ECoderFinishMode finishMode, ++ // int *wasFinished, ++ ECoderStatus *status); ++ SizeT (*Filter)(void *p, Byte *data, SizeT size); ++} IStateCoder; ++ ++ ++ ++#define MIXCODER_NUM_FILTERS_MAX 4 ++ ++typedef struct ++{ ++ ISzAllocPtr alloc; ++ Byte *buf; ++ unsigned numCoders; ++ ++ Byte *outBuf; ++ size_t outBufSize; ++ size_t outWritten; // is equal to lzmaDecoder.dicPos (in outBuf mode) ++ BoolInt wasFinished; ++ SRes res; ++ ECoderStatus status; ++ // BoolInt SingleBufMode; ++ ++ int finished[MIXCODER_NUM_FILTERS_MAX - 1]; ++ size_t pos[MIXCODER_NUM_FILTERS_MAX - 1]; ++ size_t size[MIXCODER_NUM_FILTERS_MAX - 1]; ++ UInt64 ids[MIXCODER_NUM_FILTERS_MAX]; ++ SRes results[MIXCODER_NUM_FILTERS_MAX]; ++ IStateCoder coders[MIXCODER_NUM_FILTERS_MAX]; ++} CMixCoder; ++ ++ ++typedef enum ++{ ++ XZ_STATE_STREAM_HEADER, ++ XZ_STATE_STREAM_INDEX, ++ XZ_STATE_STREAM_INDEX_CRC, ++ XZ_STATE_STREAM_FOOTER, ++ XZ_STATE_STREAM_PADDING, ++ XZ_STATE_BLOCK_HEADER, ++ XZ_STATE_BLOCK, ++ XZ_STATE_BLOCK_FOOTER ++} EXzState; ++ ++ ++typedef struct ++{ ++ EXzState state; ++ UInt32 pos; ++ unsigned alignPos; ++ unsigned indexPreSize; ++ ++ CXzStreamFlags streamFlags; ++ ++ UInt32 blockHeaderSize; ++ UInt64 packSize; ++ UInt64 unpackSize; ++ ++ UInt64 numBlocks; // number of finished blocks in current stream ++ UInt64 indexSize; ++ UInt64 indexPos; ++ UInt64 padSize; ++ ++ UInt64 numStartedStreams; ++ UInt64 numFinishedStreams; ++ UInt64 numTotalBlocks; ++ ++ UInt32 crc; ++ CMixCoder decoder; ++ CXzBlock block; ++ CXzCheck check; ++ CSha256 sha; ++ ++ BoolInt parseMode; ++ BoolInt headerParsedOk; ++ BoolInt decodeToStreamSignature; ++ unsigned decodeOnlyOneBlock; ++ ++ Byte *outBuf; ++ size_t outBufSize; ++ size_t outDataWritten; // the size of data in (outBuf) that were fully unpacked ++ ++ Byte shaDigest[SHA256_DIGEST_SIZE]; ++ Byte buf[XZ_BLOCK_HEADER_SIZE_MAX]; ++} CXzUnpacker; ++ ++/* alloc : aligned for cache line allocation is better */ ++void XzUnpacker_Construct(CXzUnpacker *p, ISzAllocPtr alloc); ++void XzUnpacker_Init(CXzUnpacker *p); ++void XzUnpacker_SetOutBuf(CXzUnpacker *p, Byte *outBuf, size_t outBufSize); ++void XzUnpacker_Free(CXzUnpacker *p); ++ ++/* ++ XzUnpacker ++ The sequence for decoding functions: ++ { ++ XzUnpacker_Construct() ++ [Decoding_Calls] ++ XzUnpacker_Free() ++ } ++ ++ [Decoding_Calls] ++ ++ There are 3 types of interfaces for [Decoding_Calls] calls: ++ ++ Interface-1 : Partial output buffers: ++ { ++ XzUnpacker_Init() ++ for() ++ { ++ XzUnpacker_Code(); ++ } ++ XzUnpacker_IsStreamWasFinished() ++ } ++ ++ Interface-2 : Direct output buffer: ++ Use it, if you know exact size of decoded data, and you need ++ whole xz unpacked data in one output buffer. ++ xz unpacker doesn't allocate additional buffer for lzma2 dictionary in that mode. ++ { ++ XzUnpacker_Init() ++ XzUnpacker_SetOutBufMode(); // to set output buffer and size ++ for() ++ { ++ XzUnpacker_Code(); // (dest = NULL) in XzUnpacker_Code() ++ } ++ XzUnpacker_IsStreamWasFinished() ++ } ++ ++ Interface-3 : Direct output buffer : One call full decoding ++ It unpacks whole input buffer to output buffer in one call. ++ It uses Interface-2 internally. ++ { ++ XzUnpacker_CodeFull() ++ XzUnpacker_IsStreamWasFinished() ++ } ++*/ ++ ++/* ++finishMode: ++ It has meaning only if the decoding reaches output limit (*destLen). ++ CODER_FINISH_ANY - use smallest number of input bytes ++ CODER_FINISH_END - read EndOfStream marker after decoding ++ ++Returns: ++ SZ_OK ++ status: ++ CODER_STATUS_NOT_FINISHED, ++ CODER_STATUS_NEEDS_MORE_INPUT - the decoder can return it in two cases: ++ 1) it needs more input data to finish current xz stream ++ 2) xz stream was finished successfully. But the decoder supports multiple ++ concatented xz streams. So it expects more input data for new xz streams. ++ Call XzUnpacker_IsStreamWasFinished() to check that latest xz stream was finished successfully. ++ ++ SZ_ERROR_MEM - Memory allocation error ++ SZ_ERROR_DATA - Data error ++ SZ_ERROR_UNSUPPORTED - Unsupported method or method properties ++ SZ_ERROR_CRC - CRC error ++ // SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src). ++ ++ SZ_ERROR_NO_ARCHIVE - the error with xz Stream Header with one of the following reasons: ++ - xz Stream Signature failure ++ - CRC32 of xz Stream Header is failed ++ - The size of Stream padding is not multiple of four bytes. ++ It's possible to get that error, if xz stream was finished and the stream ++ contains some another data. In that case you can call XzUnpacker_GetExtraSize() ++ function to get real size of xz stream. ++*/ ++ ++ ++SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen, ++ const Byte *src, SizeT *srcLen, int srcFinished, ++ ECoderFinishMode finishMode, ECoderStatus *status); ++ ++SRes XzUnpacker_CodeFull(CXzUnpacker *p, Byte *dest, SizeT *destLen, ++ const Byte *src, SizeT *srcLen, ++ ECoderFinishMode finishMode, ECoderStatus *status); ++ ++/* ++If you decode full xz stream(s), then you can call XzUnpacker_IsStreamWasFinished() ++after successful XzUnpacker_CodeFull() or after last call of XzUnpacker_Code(). ++*/ ++ ++BoolInt XzUnpacker_IsStreamWasFinished(const CXzUnpacker *p); ++ ++/* ++XzUnpacker_GetExtraSize() returns then number of unconfirmed bytes, ++ if it's in (XZ_STATE_STREAM_HEADER) state or in (XZ_STATE_STREAM_PADDING) state. ++These bytes can be some data after xz archive, or ++it can be start of new xz stream. ++ ++Call XzUnpacker_GetExtraSize() after XzUnpacker_Code() function to detect real size of ++xz stream in two cases, if XzUnpacker_Code() returns: ++ res == SZ_OK && status == CODER_STATUS_NEEDS_MORE_INPUT ++ res == SZ_ERROR_NO_ARCHIVE ++*/ ++ ++UInt64 XzUnpacker_GetExtraSize(const CXzUnpacker *p); ++ ++ ++/* ++ for random block decoding: ++ XzUnpacker_Init(); ++ set CXzUnpacker::streamFlags ++ XzUnpacker_PrepareToRandomBlockDecoding() ++ loop ++ { ++ XzUnpacker_Code() ++ XzUnpacker_IsBlockFinished() ++ } ++*/ ++ ++void XzUnpacker_PrepareToRandomBlockDecoding(CXzUnpacker *p); ++BoolInt XzUnpacker_IsBlockFinished(const CXzUnpacker *p); ++ ++#define XzUnpacker_GetPackSizeForIndex(p) ((p)->packSize + (p)->blockHeaderSize + XzFlags_GetCheckSize((p)->streamFlags)) ++ ++ ++ ++ ++ ++ ++/* ---- Single-Thread and Multi-Thread xz Decoding with Input/Output Streams ---- */ ++ ++/* ++ if (CXzDecMtProps::numThreads > 1), the decoder can try to use ++ Multi-Threading. The decoder analyses xz block header, and if ++ there are pack size and unpack size values stored in xz block header, ++ the decoder reads compressed data of block to internal buffers, ++ and then it can start parallel decoding, if there are another blocks. ++ The decoder can switch back to Single-Thread decoding after some conditions. ++ ++ The sequence of calls for xz decoding with in/out Streams: ++ { ++ XzDecMt_Create() ++ XzDecMtProps_Init(XzDecMtProps) to set default values of properties ++ // then you can change some XzDecMtProps parameters with required values ++ // here you can set the number of threads and (memUseMax) - the maximum ++ Memory usage for multithreading decoding. ++ for() ++ { ++ XzDecMt_Decode() // one call per one file ++ } ++ XzDecMt_Destroy() ++ } ++*/ ++ ++ ++typedef struct ++{ ++ size_t inBufSize_ST; // size of input buffer for Single-Thread decoding ++ size_t outStep_ST; // size of output buffer for Single-Thread decoding ++ BoolInt ignoreErrors; // if set to 1, the decoder can ignore some errors and it skips broken parts of data. ++ ++ #ifndef _7ZIP_ST ++ unsigned numThreads; // the number of threads for Multi-Thread decoding. if (umThreads == 1) it will use Single-thread decoding ++ size_t inBufSize_MT; // size of small input data buffers for Multi-Thread decoding. Big number of such small buffers can be created ++ size_t memUseMax; // the limit of total memory usage for Multi-Thread decoding. ++ // it's recommended to set (memUseMax) manually to value that is smaller of total size of RAM in computer. ++ #endif ++} CXzDecMtProps; ++ ++void XzDecMtProps_Init(CXzDecMtProps *p); ++ ++ ++typedef void * CXzDecMtHandle; ++ ++/* ++ alloc : XzDecMt uses CAlignOffsetAlloc internally for addresses allocated by (alloc). ++ allocMid : for big allocations, aligned allocation is better ++*/ ++ ++CXzDecMtHandle XzDecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid); ++void XzDecMt_Destroy(CXzDecMtHandle p); ++ ++ ++typedef struct ++{ ++ Byte UnpackSize_Defined; ++ Byte NumStreams_Defined; ++ Byte NumBlocks_Defined; ++ ++ Byte DataAfterEnd; // there are some additional data after good xz streams, and that data is not new xz stream. ++ Byte DecodingTruncated; // Decoding was Truncated, we need only partial output data ++ ++ UInt64 InSize; // pack size processed. That value doesn't include the data after ++ // end of xz stream, if that data was not correct ++ UInt64 OutSize; ++ ++ UInt64 NumStreams; ++ UInt64 NumBlocks; ++ ++ SRes DecodeRes; // the error code of xz streams data decoding ++ SRes ReadRes; // error code from ISeqInStream:Read() ++ SRes ProgressRes; // error code from ICompressProgress:Progress() ++ ++ SRes CombinedRes; // Combined result error code that shows main rusult ++ // = S_OK, if there is no error. ++ // but check also (DataAfterEnd) that can show additional minor errors. ++ ++ SRes CombinedRes_Type; // = SZ_ERROR_READ, if error from ISeqInStream ++ // = SZ_ERROR_PROGRESS, if error from ICompressProgress ++ // = SZ_ERROR_WRITE, if error from ISeqOutStream ++ // = SZ_ERROR_* codes for decoding ++} CXzStatInfo; ++ ++void XzStatInfo_Clear(CXzStatInfo *p); ++ ++/* ++ ++XzDecMt_Decode() ++SRes: it's combined decoding result. It also is equal to stat->CombinedRes. ++ ++ SZ_OK - no error ++ check also output value in (stat->DataAfterEnd) ++ that can show additional possible error ++ ++ SZ_ERROR_MEM - Memory allocation error ++ SZ_ERROR_NO_ARCHIVE - is not xz archive ++ SZ_ERROR_ARCHIVE - Headers error ++ SZ_ERROR_DATA - Data Error ++ SZ_ERROR_UNSUPPORTED - Unsupported method or method properties ++ SZ_ERROR_CRC - CRC Error ++ SZ_ERROR_INPUT_EOF - it needs more input data ++ SZ_ERROR_WRITE - ISeqOutStream error ++ (SZ_ERROR_READ) - ISeqInStream errors ++ (SZ_ERROR_PROGRESS) - ICompressProgress errors ++ // SZ_ERROR_THREAD - error in multi-threading functions ++ MY_SRes_HRESULT_FROM_WRes(WRes_error) - error in multi-threading function ++*/ ++ ++SRes XzDecMt_Decode(CXzDecMtHandle p, ++ const CXzDecMtProps *props, ++ const UInt64 *outDataSize, // NULL means undefined ++ int finishMode, // 0 - partial unpacking is allowed, 1 - xz stream(s) must be finished ++ ISeqOutStream *outStream, ++ // Byte *outBuf, size_t *outBufSize, ++ ISeqInStream *inStream, ++ // const Byte *inData, size_t inDataSize, ++ CXzStatInfo *stat, // out: decoding results and statistics ++ int *isMT, // out: 0 means that ST (Single-Thread) version was used ++ // 1 means that MT (Multi-Thread) version was used ++ ICompressProgress *progress); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/XzCrc64.h b/src/lzma-sdk/C/XzCrc64.h +new file mode 100644 +index 0000000..71b10d5 +--- /dev/null ++++ b/src/lzma-sdk/C/XzCrc64.h +@@ -0,0 +1,26 @@ ++/* XzCrc64.h -- CRC64 calculation ++2013-01-18 : Igor Pavlov : Public domain */ ++ ++#ifndef __XZ_CRC64_H ++#define __XZ_CRC64_H ++ ++#include ++ ++#include "7zTypes.h" ++ ++EXTERN_C_BEGIN ++ ++extern UInt64 g_Crc64Table[]; ++ ++void MY_FAST_CALL Crc64GenerateTable(void); ++ ++#define CRC64_INIT_VAL UINT64_CONST(0xFFFFFFFFFFFFFFFF) ++#define CRC64_GET_DIGEST(crc) ((crc) ^ CRC64_INIT_VAL) ++#define CRC64_UPDATE_BYTE(crc, b) (g_Crc64Table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8)) ++ ++UInt64 MY_FAST_CALL Crc64Update(UInt64 crc, const void *data, size_t size); ++UInt64 MY_FAST_CALL Crc64Calc(const void *data, size_t size); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/lzma-sdk/C/XzEnc.h b/src/lzma-sdk/C/XzEnc.h +new file mode 100644 +index 0000000..529ac3f +--- /dev/null ++++ b/src/lzma-sdk/C/XzEnc.h +@@ -0,0 +1,60 @@ ++/* XzEnc.h -- Xz Encode ++2017-06-27 : Igor Pavlov : Public domain */ ++ ++#ifndef __XZ_ENC_H ++#define __XZ_ENC_H ++ ++#include "Lzma2Enc.h" ++ ++#include "Xz.h" ++ ++EXTERN_C_BEGIN ++ ++ ++#define XZ_PROPS__BLOCK_SIZE__AUTO LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO ++#define XZ_PROPS__BLOCK_SIZE__SOLID LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID ++ ++ ++typedef struct ++{ ++ UInt32 id; ++ UInt32 delta; ++ UInt32 ip; ++ int ipDefined; ++} CXzFilterProps; ++ ++void XzFilterProps_Init(CXzFilterProps *p); ++ ++ ++typedef struct ++{ ++ CLzma2EncProps lzma2Props; ++ CXzFilterProps filterProps; ++ unsigned checkId; ++ UInt64 blockSize; ++ int numBlockThreads_Reduced; ++ int numBlockThreads_Max; ++ int numTotalThreads; ++ int forceWriteSizesInHeader; ++ UInt64 reduceSize; ++} CXzProps; ++ ++void XzProps_Init(CXzProps *p); ++ ++ ++typedef void * CXzEncHandle; ++ ++CXzEncHandle XzEnc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig); ++void XzEnc_Destroy(CXzEncHandle p); ++SRes XzEnc_SetProps(CXzEncHandle p, const CXzProps *props); ++void XzEnc_SetDataSize(CXzEncHandle p, UInt64 expectedDataSiize); ++SRes XzEnc_Encode(CXzEncHandle p, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress); ++ ++SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream, ++ const CXzProps *props, ICompressProgress *progress); ++ ++SRes Xz_EncodeEmpty(ISeqOutStream *outStream); ++ ++EXTERN_C_END ++ ++#endif +diff --git a/src/uadk/v1/uacce.h b/src/uadk/v1/uacce.h +new file mode 100644 +index 0000000..d45062e +--- /dev/null ++++ b/src/uadk/v1/uacce.h +@@ -0,0 +1,86 @@ ++/* ++ * Copyright 2019 Huawei Technologies Co.,Ltd.All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef _UAPI_WD_UACCE_H ++#define _UAPI_WD_UACCE_H ++ ++#include ++#include ++ ++#define WD_UACCE_CLASS_NAME "uacce" ++ ++/** ++ * WD_UACCE Device Attributes: ++ * ++ * NOIOMMU: the device has no IOMMU support ++ * can do ssva, but no map to the dev ++ * IOMMU: the device has IOMMU support ++ * PASID: the device has IOMMU which support PASID setting ++ * can do ssva, mapped to dev per process ++ * FAULT_FROM_DEV: the device has IOMMU which can do page fault request ++ * no need for ssva, should be used with PASID ++ * KMAP_DUS: map the Device user-shared space to kernel ++ * DRVMAP_DUS: Driver self-maintain its DUS ++ * SVA: full function device ++ * SHARE_DOMAIN: no PASID, can do ssva only for one process and the kernel ++ */ ++#define WD_UACCE_DEV_SVA (1<<0) ++#define WD_UACCE_DEV_NOIOMMU (1<<1) ++#define WD_UACCE_DEV_PASID (1<<2) ++#define WD_UACCE_DEV_IOMMU (1<<7) ++ ++/* uacce mode of the driver */ ++#define WD_UACCE_MODE_NOWD_UACCE 0 /* don't use uacce */ ++#define WD_UACCE_MODE_NOIOMMU 2 /* use uacce noiommu mode */ ++ ++#define WD_UACCE_API_VER_NOIOMMU_SUBFIX "_noiommu" ++#define WD_UACCE_QFR_NA ((unsigned long)-1) ++ ++/** ++ * enum uacce_qfrt: queue file region type ++ * @WD_UACCE_QFRT_MMIO: device mmio region ++ * @WD_UACCE_QFRT_DUS: device user share region ++ * @WD_UACCE_QFRT_SS: static share memory(no-sva) ++ */ ++enum uacce_qfrt { ++ WD_UACCE_QFRT_MMIO = 0, /* device mmio region */ ++ WD_UACCE_QFRT_DUS, /* device user share */ ++ WD_UACCE_QFRT_SS, /* static share memory */ ++ WD_UACCE_QFRT_MAX, ++}; ++ ++#define WD_UACCE_QFRT_INVALID WD_UACCE_QFRT_MAX ++ ++/* Pass DMA SS region slice size by granularity 64KB */ ++#define WD_UACCE_GRAN_SIZE 0x10000ull ++#define WD_UACCE_GRAN_SHIFT 16 ++#define WD_UACCE_GRAN_NUM_MASK 0xfffull ++ ++/* ++ * WD_UACCE_CMD_START_Q: Start queue ++ */ ++#define WD_UACCE_CMD_START_Q _IO('W', 0) ++ ++/* ++ * WD_UACCE_CMD_PUT_Q: ++ * User actively stop queue and free queue resource immediately ++ * Optimization method since close fd may delay ++ */ ++#define WD_UACCE_CMD_PUT_Q _IO('W', 1) ++#define WD_UACCE_CMD_SHARE_SVAS _IO('W', 2) ++#define WD_UACCE_CMD_GET_SS_DMA _IOR('W', 3, unsigned long) ++ ++#endif +diff --git a/src/uadk/v1/wd.h b/src/uadk/v1/wd.h +new file mode 100644 +index 0000000..1bd9669 +--- /dev/null ++++ b/src/uadk/v1/wd.h +@@ -0,0 +1,214 @@ ++/* ++ * Copyright 2018-2019 Huawei Technologies Co.,Ltd.All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef __WD_H ++#define __WD_H ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include "uacce.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#define SYS_VAL_SIZE 16 ++#define PATH_STR_SIZE 256 ++#define MAX_ATTR_STR_SIZE 256 ++#define WD_NAME_SIZE 64 ++#define WCRYPTO_MAX_BURST_NUM 16 ++ ++/* WD error code */ ++#define WD_SUCCESS 0 ++#define WD_STREAM_END 1 ++#define WD_STREAM_START 2 ++#define WD_EIO EIO ++#define WD_EAGAIN EAGAIN ++#define WD_ENOMEM ENOMEM ++#define WD_EACCESS EACCESS ++#define WD_EBUSY EBUSY ++#define WD_ENODEV ENODEV ++#define WD_EINVAL EINVAL ++#define WD_ETIMEDOUT ETIMEDOUT ++#define WD_ADDR_ERR 61 ++#define WD_HW_EACCESS 62 ++#define WD_SGL_ERR 63 ++#define WD_VERIFY_ERR 64 ++#define WD_OUT_EPARA 66 ++#define WD_IN_EPARA 67 ++#define WD_ENOPROC 68 ++ ++typedef void (*wcrypto_cb)(const void *msg, void *tag); ++ ++typedef void (*wd_log)(const char *format, ...); ++ ++struct wcrypto_cb_tag { ++ void *ctx; /* user: context or other user relatives */ ++ void *tag; /* to store user tag */ ++ int ctx_id; /* user id: context ID or other user identifier */ ++}; ++ ++struct wcrypto_paras { ++ /* ++ * 0--encipher/compress .etc, 1 ---decipher/decomp .etc ++ * it not been used for HiSilicon SEC currently. ++ */ ++ __u8 direction; ++ __u8 is_poll; ++ ++ /* to be extended */ ++}; ++ ++enum wd_buff_type { ++ WD_FLAT_BUF, ++ WD_SGL_BUF, ++}; ++ ++/* memory APIs for Algorithm Layer */ ++typedef void *(*wd_alloc)(void *usr, size_t size); ++typedef void (*wd_free)(void *usr, void *va); ++ ++ /* memory VA to DMA address map */ ++typedef void *(*wd_map)(void *usr, void *va, size_t sz); ++typedef void (*wd_unmap)(void *usr, void *va, void *dma, size_t sz); ++typedef __u32 (*wd_bufsize)(void *usr); ++ ++/* Memory from user, it is given at ctx creating. */ ++struct wd_mm_br { ++ wd_alloc alloc; /* Memory allocation */ ++ wd_free free; /* Memory free */ ++ wd_map iova_map; /* get iova from user space VA */ ++ ++ /* destroy the mapping between the PA of VA and iova */ ++ wd_unmap iova_unmap; ++ void *usr; /* data for the above operations */ ++ wd_bufsize get_bufsize; /* optional */ ++}; ++ ++/* Warpdrive data buffer */ ++struct wd_dtb { ++ char *data; /* data/buffer start address */ ++ __u32 dsize; /* data size */ ++ __u32 bsize; /* buffer size */ ++}; ++ ++enum wcrypto_type { ++ WCRYPTO_RSA, ++ WCRYPTO_DH, ++ WCRYPTO_CIPHER, ++ WCRYPTO_DIGEST, ++ WCRYPTO_COMP, ++ WCRYPTO_EC, ++ WCRYPTO_RNG, ++ WCRYPTO_ECDH, ++ WCRYPTO_X25519, ++ WCRYPTO_X448, ++ WCRYPTO_ECDSA, ++ WCRYPTO_SM2, ++ WCRYPTO_AEAD, ++ WCRYPTO_MAX_ALG ++}; ++ ++#ifndef true ++#define true 1 ++#endif ++ ++#ifndef false ++#define false 0 ++#endif ++ ++#ifndef WD_ERR ++#ifndef WITH_LOG_FILE ++extern wd_log log_out; ++ ++#define __WD_FILENAME__ (strrchr(__FILE__, '/') ? \ ++ ((char *)((uintptr_t)strrchr(__FILE__, '/') + 1)) : __FILE__) ++ ++#define WD_ERR(format, args...) \ ++ (log_out ? log_out("[%s, %d, %s]:"format, \ ++ __WD_FILENAME__, __LINE__, __func__, ##args) : \ ++ fprintf(stderr, format, ##args)) ++#else ++extern FILE *flog_fd; ++#define WD_ERR(format, args...) do { \ ++ if (!flog_fd) \ ++ flog_fd = fopen(WITH_LOG_FILE, "a+"); \ ++ if (flog_fd) \ ++ fprintf(flog_fd, format, ##args); \ ++ else \ ++ fprintf(stderr, "log %s not exists!", \ ++ WITH_LOG_FILE); \ ++} while (0) ++#endif ++#endif ++ ++#define WD_CAPA_PRIV_DATA_SIZE 64 ++ ++/* Capabilities */ ++struct wd_capa { ++ /* Algorithm name */ ++ const char *alg; ++ /* throughput capability */ ++ int throughput; ++ /* latency capability */ ++ int latency; ++ /* other capabilities */ ++ __u32 flags; ++ ++ /* For algorithm parameters, now it is defined in extending notions */ ++ struct wcrypto_paras priv; ++}; ++ ++struct wd_queue { ++ struct wd_capa capa; ++ /* if denote dev name, get its Q */ ++ char dev_path[PATH_STR_SIZE]; ++ /* if denote dev node mask, get its Q */ ++ unsigned int node_mask; ++ /* queue private */ ++ void *qinfo; ++}; ++ ++int wd_request_queue(struct wd_queue *q); ++void wd_release_queue(struct wd_queue *q); ++int wd_send(struct wd_queue *q, void *req); ++int wd_recv(struct wd_queue *q, void **resp); ++int wd_wait(struct wd_queue *q, __u16 ms); ++int wd_recv_sync(struct wd_queue *q, void **resp, __u16 ms); ++void *wd_reserve_memory(struct wd_queue *q, size_t size); ++int wd_share_reserved_memory(struct wd_queue *q, ++ struct wd_queue *target_q); ++int wd_get_available_dev_num(const char *algorithm); ++int wd_get_node_id(struct wd_queue *q); ++void *wd_iova_map(struct wd_queue *q, void *va, size_t sz); ++void wd_iova_unmap(struct wd_queue *q, void *va, void *dma, size_t sz); ++void *wd_dma_to_va(struct wd_queue *q, void *dma); ++int wd_register_log(wd_log log); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/src/uadk/v1/wd_adapter.h b/src/uadk/v1/wd_adapter.h +new file mode 100644 +index 0000000..bcceff2 +--- /dev/null ++++ b/src/uadk/v1/wd_adapter.h +@@ -0,0 +1,75 @@ ++/* ++ * Copyright 2018-2019 Huawei Technologies Co.,Ltd.All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++/* the common driver header define the unified interface for wd */ ++#ifndef __WD_ADAPTER_H__ ++#define __WD_ADAPTER_H__ ++ ++#include ++#include ++#include ++#include ++#include ++ ++#include "wd.h" ++#include "wd_sgl.h" ++ ++/* Use to describe hardware SGL, different hardware has different SGL format */ ++struct hw_sgl_info { ++ __u32 sgl_sz; ++ __u32 sgl_align_sz; ++ __u32 sge_sz; ++ __u32 sge_align_sz; ++}; ++ ++struct wd_drv_dio_if { ++ /* vendor tag which is used to select right vendor driver */ ++ char *hw_type; ++ /* user space WD queue initialize */ ++ int (*open)(struct wd_queue *q); ++ /* user space WD queue uninitialize */ ++ void (*close)(struct wd_queue *q); ++ /* Send WCRYPTO message to WD queue */ ++ int (*send)(struct wd_queue *q, void **req, __u32 num); ++ /* Receive WCRYPTO message from WD queue */ ++ int (*recv)(struct wd_queue *q, void **req, __u32 num); ++ ++ /* Get hardware sgl information from WD queue */ ++ int (*get_sgl_info)(struct wd_queue *q, struct hw_sgl_info *info); ++ /* Initialize hardware sgl from WD queue */ ++ int (*init_sgl)(struct wd_queue *q, void *pool, struct wd_sgl *sgl); ++ /* Uninitialize hardware sgl from WD queue */ ++ int (*uninit_sgl)(struct wd_queue *q, void *pool, struct wd_sgl *sgl); ++ /* Merge two hardware sgls to 'dst_sgl' from WD queue */ ++ int (*sgl_merge)(struct wd_queue *q, void *pool, ++ struct wd_sgl *dst_sgl, struct wd_sgl *src_sgl); ++}; ++ ++int drv_open(struct wd_queue *q); ++void drv_close(struct wd_queue *q); ++int drv_send(struct wd_queue *q, void **req, __u32 num); ++int drv_recv(struct wd_queue *q, void **req, __u32 num); ++void drv_flush(struct wd_queue *q); ++void drv_free_slice(struct wd_queue *q); ++void *drv_reserve_mem(struct wd_queue *q, size_t size); ++void drv_unmap_reserve_mem(struct wd_queue *q, void *addr, size_t size); ++int drv_get_sgl_info(struct wd_queue *q, struct hw_sgl_info *info); ++int drv_init_sgl(struct wd_queue *q, void *pool, struct wd_sgl *sgl); ++int drv_uninit_sgl(struct wd_queue *q, void *pool, struct wd_sgl *sgl); ++int drv_sgl_merge(struct wd_queue *q, void *pool, ++ struct wd_sgl *dst_sgl, struct wd_sgl *src_sgl); ++ ++#endif +diff --git a/src/uadk/v1/wd_aead.h b/src/uadk/v1/wd_aead.h +new file mode 100644 +index 0000000..ae5697b +--- /dev/null ++++ b/src/uadk/v1/wd_aead.h +@@ -0,0 +1,213 @@ ++/* ++ * Copyright 2019 Huawei Technologies Co.,Ltd.All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef __WD_AEAD_H ++#define __WD_AEAD_H ++ ++#include ++#include ++#include ++#include "wd.h" ++#include "wd_cipher.h" ++#include "wd_digest.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++enum wcrypto_aead_op_type { ++ WCRYPTO_CIPHER_ENCRYPTION_DIGEST, ++ WCRYPTO_CIPHER_DECRYPTION_DIGEST, ++ WCRYPTO_DIGEST_CIPHER_ENCRYPTION, ++ WCRYPTO_DIGEST_CIPHER_DECRYPTION, ++}; ++ ++enum wcrypto_aead_mac_len { ++ WCRYPTO_CCM_GCM_LEN = 16, ++ WCRYPTO_SM3_LEN = 32, ++ WCRYPTO_MD5_LEN = 16, ++ WCRYPTO_SHA1_LEN = 20, ++ WCRYPTO_SHA256_LEN = 32, ++ WCRYPTO_SHA224_LEN = 28, ++ WCRYPTO_SHA384_LEN = 48, ++ WCRYPTO_SHA512_LEN = 64, ++ WCRYPTO_SHA512_224_LEN = 28, ++ WCRYPTO_SHA512_256_LEN = 32 ++}; ++ ++/** ++ * different contexts for different users/threads ++ * @cb: call back functions of user ++ * @calg: cipher algorithm type; denoted by enum wcrypto_cipher_alg ++ * @cmode: cipher algorithm mode; denoted by enum wcrypto_cipher_mode ++ * @dalg: digest algorithm type; denoted by enum wcrypto_digest_alg ++ * @dmode: digest algorithm mode; denoted by enum wcrypto_digest_mode ++ * @br: memory from user, it is given at ctx creating ++ * @data_fmt: denoted by enum wcrypto_buff_type ++ */ ++struct wcrypto_aead_ctx_setup { ++ wcrypto_cb cb; ++ enum wcrypto_cipher_alg calg; ++ enum wcrypto_cipher_mode cmode; ++ enum wcrypto_digest_alg dalg; ++ enum wcrypto_digest_mode dmode; ++ struct wd_mm_br br; ++ __u16 data_fmt; ++}; ++ ++/** ++ * operational data per I/O operation ++ * AEAD encryption input: assoc data || plaintext ++ * AEAD encryption output: assoc data || ciphertext || auth tag ++ * AEAD decryption input: assoc data || ciphertext || auth tag ++ * AEAD decryption output: assoc data || plaintext ++ * @op_type:aead operation type, denoted by enum wcrypto_aead_op_type ++ * @status:I/O operation return status ++ * @in: input data address ++ * @out:output data address ++ * @iv:initialization verctor data address ++ * @in_bytes: input data size ++ * @out_bytes:output data size ++ * @out_buf_bytes:output buffer size ++ * @iv_bytes:initialization verctor data size ++ * @assoc_size: aead associated data size ++ * @priv:reserved data field segment ++ */ ++struct wcrypto_aead_op_data { ++ enum wcrypto_aead_op_type op_type; ++ int status; ++ void *in; ++ void *out; ++ void *iv; ++ __u32 in_bytes; ++ __u32 out_bytes; ++ __u32 out_buf_bytes; ++ __u16 iv_bytes; ++ __u16 assoc_size; ++ void *priv; ++}; ++ ++/* AEAD message format of Warpdrive */ ++struct wcrypto_aead_msg { ++ __u8 alg_type:4; /* Denoted by enum wcrypto_type */ ++ __u8 op_type:4; /* Denoted by enum wcrypto_aead_op_type */ ++ __u8 calg:4; /* Denoted by enum wcrypto_cipher_type */ ++ __u8 cmode:4; /* Denoted by enum wcrypto_cipher_mode */ ++ __u8 dalg:4; /* Denoted by enum wcrypto_digest_type */ ++ __u8 dmode:4; /* Denoted by enum wcrypto_digest_mode */ ++ __u8 data_fmt; /* Data format, denoted by enum wcrypto_buff_type */ ++ __u8 result; /* Operation result, denoted by WD error code */ ++ ++ __u16 ckey_bytes; /* Key bytes */ ++ __u16 akey_bytes; /* Key bytes */ ++ __u16 assoc_bytes; /* Input associated data bytes */ ++ __u16 auth_bytes; /* Output authentication bytes */ ++ __u16 iv_bytes; /* IV bytes */ ++ __u32 in_bytes; /* Input data bytes */ ++ __u32 out_bytes; /* Output data bytes */ ++ ++ __u8 *ckey; /* Input key VA pointer, should be DMA buffer */ ++ __u8 *akey; /* Input authenticate key VA pointer, should be DMA buffer */ ++ __u8 *iv; /* Input IV VA pointer, should be DMA buffer */ ++ __u8 *aiv; /* Input auth IV VA pointer, should be DMA buffer */ ++ __u8 *in; /* Input data VA pointer, should be DMA buffer */ ++ __u8 *out; /* Output data VA pointer, should be DMA buffer */ ++ __u64 usr_data; /* user identifier: struct wcrypto_cb_tag */ ++}; ++ ++/** ++ * wcrypto_create_aead_ctx() - create a aead context on the wrapdrive queue. ++ * @q: wrapdrive queue, need requested by user. ++ * @setup:setup data of user ++ */ ++void *wcrypto_create_aead_ctx(struct wd_queue *q, ++ struct wcrypto_aead_ctx_setup *setup); ++ ++/** ++ * wcrypto_set_aead_ckey() - set cipher key to aead context. ++ * @ctx: aead context, created by wcrypto_create_aead_ctx. ++ * @key: cipher key addr ++ * @key_len: cipher key length ++ */ ++int wcrypto_set_aead_ckey(void *ctx, __u8 *key, __u16 key_len); ++ ++/** ++ * wcrypto_set_aead_akey() - set authenticate key to aead context. ++ * @ctx: aead context, created by wcrypto_create_aead_ctx. ++ * @key: authenticate key addr ++ * @key_len: authenticate key length ++ */ ++int wcrypto_set_aead_akey(void *ctx, __u8 *key, __u16 key_len); ++ ++/** ++ * wcrypto_aead_setauthsize() - set aead authsize to aead context. ++ * @ctx: aead context, created by wcrypto_create_aead_ctx. ++ * @authsize: aead authsize ++ */ ++int wcrypto_aead_setauthsize(void *ctx, __u16 authsize); ++ ++/** ++ * wcrypto_aead_getauthsize() - obtain maximum authentication data size ++ * @ctx: aead context, created by wcrypto_create_aead_ctx. ++ * Return: authentication data size / tag size in bytes ++ */ ++int wcrypto_aead_getauthsize(void *ctx); ++ ++/** ++ * wcrypto_aead_getmaxauthsize() - obtain maximum authentication data size ++ * @ctx: aead context, created by wcrypto_create_aead_ctx. ++ * Return: max authentication data size ++ */ ++int wcrypto_aead_get_maxauthsize(void *ctx); ++ ++/** ++ * wcrypto_do_aead() - syn/asynchronous aead operation ++ * @ctx: context of user, created by wcrypto_create_aead_ctx. ++ * @opdata: operational data ++ * @tag: asynchronous:user_tag; synchronous:NULL. ++ */ ++int wcrypto_do_aead(void *ctx, struct wcrypto_aead_op_data *opdata, ++ void *tag); ++ ++/** ++ * wcrypto_burst_aead() - (a)synchronous multiple aead operations ++ * @a_ctx: context of user, created by wcrypto_create_aead_ctx. ++ * @opdata: operational data ++ * @tag: asynchronous:user_tag; synchronous:NULL. ++ * @num: operations number per calling, maximum number is WCRYPTO_MAX_BURST_NUM. ++ */ ++int wcrypto_burst_aead(void *a_ctx, struct wcrypto_aead_op_data **opdata, ++ void **tag, __u32 num); ++ ++/** ++ * wcrypto_aead_poll() - poll operation for asynchronous operation ++ * @q:wrapdrive queue ++ * @num:how many respondences this poll has to get, 0 means get all finishings ++ */ ++int wcrypto_aead_poll(struct wd_queue *q, unsigned int num); ++ ++/** ++ * wcrypto_del_aead_ctx() - free aead context ++ * @ctx: the context to be free ++ */ ++void wcrypto_del_aead_ctx(void *ctx); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif ++ +diff --git a/src/uadk/v1/wd_bmm.h b/src/uadk/v1/wd_bmm.h +new file mode 100644 +index 0000000..88a8f9d +--- /dev/null ++++ b/src/uadk/v1/wd_bmm.h +@@ -0,0 +1,50 @@ ++/* ++ * Copyright 2019 Huawei Technologies Co.,Ltd.All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef _WD_BMM_H ++#define _WD_BMM_H ++ ++#include ++#include "wd.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* Memory pool creating parameters */ ++struct wd_blkpool_setup { ++ __u32 block_size; /* Block buffer size */ ++ __u32 block_num; /* Block buffer number */ ++ __u32 align_size; /* Block buffer starting address align size */ ++ struct wd_mm_br br; /* memory from user if don't use WD memory */ ++}; ++ ++void *wd_blkpool_create(struct wd_queue *q, ++ struct wd_blkpool_setup *setup); ++void wd_blkpool_destroy(void *pool); ++void *wd_alloc_blk(void *pool); ++void wd_free_blk(void *pool, void *blk); ++int wd_get_free_blk_num(void *pool, __u32 *free_num); ++int wd_blk_alloc_failures(void *pool, __u32 *fail_num); ++void *wd_blk_iova_map(void *pool, void *blk); ++void wd_blk_iova_unmap(void *pool, void *blk_dma, void *blk); ++__u32 wd_blksize(void *pool); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/src/uadk/v1/wd_cipher.h b/src/uadk/v1/wd_cipher.h +new file mode 100644 +index 0000000..591a590 +--- /dev/null ++++ b/src/uadk/v1/wd_cipher.h +@@ -0,0 +1,166 @@ ++/* ++ * Copyright 2019 Huawei Technologies Co.,Ltd.All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef __WD_CIPHER_H ++#define __WD_CIPHER_H ++ ++#include ++#include ++#include ++#include "wd.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++enum wcrypto_cipher_op_type { ++ WCRYPTO_CIPHER_ENCRYPTION, ++ WCRYPTO_CIPHER_DECRYPTION, ++}; ++ ++enum wcrypto_cipher_alg { ++ WCRYPTO_CIPHER_SM4, ++ WCRYPTO_CIPHER_AES, ++ WCRYPTO_CIPHER_DES, ++ WCRYPTO_CIPHER_3DES, ++}; ++ ++enum wcrypto_cipher_mode { ++ WCRYPTO_CIPHER_ECB, ++ WCRYPTO_CIPHER_CBC, ++ WCRYPTO_CIPHER_CTR, ++ WCRYPTO_CIPHER_XTS, ++ WCRYPTO_CIPHER_OFB, ++ WCRYPTO_CIPHER_CFB, ++ WCRYPTO_CIPHER_CCM, ++ WCRYPTO_CIPHER_GCM, ++}; ++ ++/** ++ * different contexts for different users/threads ++ * @cb: call back functions of user ++ * @alg: cipher algorithm type; denoted by enum wcrypto_cipher_alg ++ * @mode:cipher algorithm mode; denoted by enum wcrypto_cipher_mode ++ * @br: memory from user, it is given at ctx creating ++ * @data_fmt: data format, denoted by enum wcrypto_buff_type ++ */ ++struct wcrypto_cipher_ctx_setup { ++ wcrypto_cb cb; ++ enum wcrypto_cipher_alg alg; ++ enum wcrypto_cipher_mode mode; ++ struct wd_mm_br br; ++ __u16 data_fmt; ++}; ++ ++/** ++ * operational data per I/O operation ++ * @op_type:cipher operation type, denoted by enum wcrypto_cipher_op_type ++ * @status:I/O operation return status ++ * @in: input data address ++ * @out:output data address ++ * @iv:initialization verctor data address ++ * @in_bytes: input data size ++ * @out_bytes:output data size ++ * @iv_bytes:initialization verctor data size ++ * @priv:reserved data field segment ++ */ ++struct wcrypto_cipher_op_data { ++ enum wcrypto_cipher_op_type op_type; ++ int status; ++ void *in; ++ void *out; ++ void *iv; ++ __u32 in_bytes; ++ __u32 out_bytes; ++ __u32 iv_bytes; ++ void *priv; ++}; ++ ++/* Cipher message format of Warpdrive */ ++struct wcrypto_cipher_msg { ++ __u8 alg_type:4; /* Denoted by enum wcrypto_type */ ++ __u8 alg:4; /* Denoted by enum wcrypto_cipher_alg */ ++ __u8 op_type:4; /* Denoted by enum wcrypto_cipher_op_type */ ++ __u8 mode:4; /* Denoted by enum wcrypto_cipher_mode */ ++ __u8 data_fmt; /* Data format, denoted by enum wcrypto_buff_type */ ++ __u8 result; /* Operation result, denoted by WD error code */ ++ ++ __u16 key_bytes; /* Key bytes */ ++ __u16 iv_bytes; /* IV bytes */ ++ __u32 in_bytes; /* Input data bytes */ ++ __u32 out_bytes; /* Output data bytes */ ++ ++ __u8 *key; /* Input key VA pointer, should be DMA buffer */ ++ __u8 *iv; /* Input IV VA pointer, should be DMA buffer */ ++ __u8 *in; /* Input data VA pointer, should be DMA buffer */ ++ __u8 *out; /* Output data VA pointer, should be DMA buffer */ ++ __u64 usr_data; /* user identifier: struct wcrypto_cb_tag */ ++}; ++ ++/** ++ * wcrypto_create_cipher_ctx() - create a cipher context on the wrapdrive queue. ++ * @q: wrapdrive queue, need requested by user. ++ * @setup:setup data of user ++ */ ++void *wcrypto_create_cipher_ctx(struct wd_queue *q, ++ struct wcrypto_cipher_ctx_setup *setup); ++ ++/** ++ * wcrypto_set_cipher_key() - set cipher key to cipher context. ++ * @ctx: cipher context, created by wcrypto_create_cipher_ctx. ++ * @key: cipher key addr ++ * @key_len: cipher key length ++ */ ++int wcrypto_set_cipher_key(void *ctx, __u8 *key, __u16 key_len); ++ ++/** ++ * wcrypto_do_cipher() - syn/asynchronous cipher operation ++ * @ctx: context of user, created by wcrypto_create_cipher_ctx. ++ * @opdata: operational data ++ * @tag: asynchronous:user_tag; synchronous:NULL. ++ */ ++int wcrypto_do_cipher(void *ctx, struct wcrypto_cipher_op_data *opdata, ++ void *tag); ++ ++/** ++ * wcrypto_cipher_poll() - poll operation for asynchronous operation ++ * @q:wrapdrive queue ++ * @num:how many respondences this poll has to get, 0 means get all finishings ++ */ ++int wcrypto_cipher_poll(struct wd_queue *q, unsigned int num); ++ ++/** ++ * wcrypto_del_cipher_ctx() - free cipher context ++ * @ctx: the context to be free ++ */ ++void wcrypto_del_cipher_ctx(void *ctx); ++ ++/** ++ * wcrypto_burst_cipher() - (a)synchronous multiple cipher operations ++ * @ctx: context of user, created by wcrypto_create_cipher_ctx. ++ * @c_opdata: operational data ++ * @tag: asynchronous:user_tag; synchronous:NULL. ++ * @num: operations number per calling, maximum number is WCRYPTO_MAX_BURST_NUM. ++ */ ++int wcrypto_burst_cipher(void *ctx, struct wcrypto_cipher_op_data **c_opdata, ++ void **tag, __u32 num); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif ++ +diff --git a/src/uadk/v1/wd_comp.h b/src/uadk/v1/wd_comp.h +new file mode 100644 +index 0000000..580b968 +--- /dev/null ++++ b/src/uadk/v1/wd_comp.h +@@ -0,0 +1,256 @@ ++/* ++ * Copyright 2019 Huawei Technologies Co.,Ltd.All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef __WCRYPTO_COMP_H ++#define __WCRYPTO_COMP_H ++ ++#include ++#include ++#include "wd.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef unsigned char __u8; ++typedef unsigned int __u32; ++typedef unsigned long long __u64; ++ ++#define ZIP_LOG(format, args...) fprintf(stderr, format, ##args) ++ ++#define MAX_CTX_RSV_SIZE 65536 ++ ++/* now hw not support config */ ++enum wcrypto_comp_level { ++ WCRYPTO_COMP_L1 = 1, /* Compression level 1 */ ++ WCRYPTO_COMP_L2, /* Compression level 2 */ ++ WCRYPTO_COMP_L3, /* Compression level 3 */ ++ WCRYPTO_COMP_L4, /* Compression level 4 */ ++ WCRYPTO_COMP_L5, /* Compression level 5 */ ++ WCRYPTO_COMP_L6, /* Compression level 6 */ ++ WCRYPTO_COMP_L7, /* Compression level 7 */ ++ WCRYPTO_COMP_L8, /* Compression level 8 */ ++ WCRYPTO_COMP_L9, /* Compression level 9 */ ++}; ++ ++/* now hw not support config */ ++enum wcrypto_comp_win_type { ++ WCRYPTO_COMP_WS_4K, /* 4k bytes window size */ ++ WCRYPTO_COMP_WS_8K, /* 8k bytes window size */ ++ WCRYPTO_COMP_WS_16K, /* 16k bytes window size */ ++ WCRYPTO_COMP_WS_24K, /* 24k bytes window size */ ++ WCRYPTO_COMP_WS_32K, /* 32k bytes window size */ ++}; ++ ++/* Flush types */ ++enum wcrypto_comp_flush_type { ++ WCRYPTO_INVALID_FLUSH, ++ ++ /* output as much data as we can to improve performance */ ++ WCRYPTO_NO_FLUSH, ++ ++ /* output as bytes aligning or some other conditions satisfied */ ++ WCRYPTO_SYNC_FLUSH, ++ ++ /* indicates the end of the file/data */ ++ WCRYPTO_FINISH, ++}; ++ ++enum wcrypto_comp_alg_type { ++ WCRYPTO_ZLIB, ++ WCRYPTO_GZIP, ++ WCRYPTO_RAW_DEFLATE, ++ WCRYPTO_LZ77_ZSTD, ++ WCRYPTO_COMP_MAX_ALG, ++}; ++ ++/* Operational types for COMP */ ++enum wcrypto_comp_optype { ++ WCRYPTO_DEFLATE, ++ WCRYPTO_INFLATE, ++}; ++ ++enum wcrypto_op_result { ++ WCRYPTO_STATUS_NULL, ++ WCRYPTO_COMP_END, ++ WCRYPTO_DECOMP_END, ++ WCRYPTO_DECOMP_END_NOSPACE, ++ WCRYPTO_DECOMP_NO_CRC, ++ WCRYPTO_DECOMP_BLK_NOSTART, ++ WCRYPTO_SRC_DIF_ERR, ++ WCRYPTO_DST_DIF_ERR, ++ WCRYPTO_NEGTIVE_COMP_ERR, ++}; ++ ++enum wcrypto_comp_state { ++ WCRYPTO_COMP_STATELESS, ++ WCRYPTO_COMP_STATEFUL, ++}; ++ ++enum wcrypto_stream_status { ++ WCRYPTO_COMP_STREAM_OLD, ++ WCRYPTO_COMP_STREAM_NEW, /* indicates first packet */ ++}; ++ ++/** ++ * different contexts for different users/threads ++ * @cb: call back functions of user ++ * @alg_type:compressing algorithm type zlib/gzip ++ * @op_type:operational types deflate/inflate ++ * @stream_mode:stateless(block)/statefull ++ * @comp_lv: compressing level;now reserved ++ * @win_size: window size of algorithm; now reserved ++ * @data_fmt: buffer format ++ * @br: memory operations from user ++ */ ++struct wcrypto_comp_ctx_setup { ++ wcrypto_cb cb; ++ __u8 alg_type; ++ __u8 op_type; ++ __u8 stream_mode; ++ __u8 comp_lv; ++ __u16 win_size; ++ __u16 data_fmt; ++ struct wd_mm_br br; ++}; ++ ++/** ++ * operational out data when use zstd_lz77 in sgl format ++ * @literal:literals address when use zstd in sgl format ++ * @lit_len:avail literals size for hw when use zstd in sgl format, ++ * and avail literals is always <= (src_len + ZSTD_LIT_RSV_SIZE); ++ * @sequence:sequence address when use zstd in sgl format ++ * @seq_len:avail literals size for hw when use zstd in sgl format ++ */ ++struct wcrypto_zstd_out { ++ void *literal; ++ __u32 lit_sz; ++ void *sequence; ++ __u32 seq_sz; ++}; ++ ++/** ++ * operational data per I/O operation ++ * @alg_type:compressing algorithm type zlib/gzip ++ * @flush:input and output, denotes flush type or data status ++ * @stream_pos: denotes stream start ++ * @status:task status current time ++ * @in:input data address ++ * @out:output data address ++ * @in_len:input data size ++ * @avail_out:avail output size for hw ++ * @consumed:output, denotes how many bytes are consumed this time ++ * @produced:output, denotes how many bytes are produced this time ++ * @isize:gzip isize ++ * @checksum: protocol checksum ++ * @priv: private field for extend ++ */ ++struct wcrypto_comp_op_data { ++ __u8 alg_type; ++ __u8 flush; ++ __u8 stream_pos; ++ __u8 status; ++ __u8 *in; ++ __u8 *out; ++ __u32 in_len; ++ __u32 avail_out; ++ __u32 consumed; ++ __u32 produced; ++ __u32 isize; ++ __u32 checksum; ++ void *priv; ++}; ++ ++struct wcrypto_comp_msg { ++ __u8 alg_type; /* Denoted by enum wcrypto_comp_alg_type */ ++ __u8 op_type; /* Denoted by enum wcrypto_comp_op_type */ ++ __u8 flush_type; /* Denoted by enum wcrypto_comp_flush_type */ ++ __u8 stream_mode;/* Denoted by enum wcrypto_comp_state */ ++ __u8 stream_pos; /* Denoted by enum wcrypto_stream_status */ ++ __u8 comp_lv; /* Denoted by enum wcrypto_comp_level */ ++ __u8 data_fmt; /* Data format, denoted by enum wd_buff_type */ ++ __u8 win_size; /* Denoted by enum wcrypto_comp_win_type */ ++ __u32 in_size; /* Input data bytes */ ++ __u32 avail_out; /* Output buffer size */ ++ __u32 in_cons; /* consumed bytes of input data */ ++ __u32 produced; /* produced bytes of current operation */ ++ __u8 *src; /* Input data VA, buf should be DMA-able. */ ++ __u8 *dst; /* Output data VA pointer */ ++ __u32 tag; /* User-defined request identifier */ ++ __u32 status; /* Denoted by error code and enum wcrypto_op_result */ ++ __u32 isize; /* Denoted by gzip isize */ ++ __u32 checksum; /* Denoted by zlib/gzip CRC */ ++ void *ctx_buf; /* Denoted HW ctx cache, for stream mode */ ++ __u64 udata; /* Input user tag, identify data of stream/user */ ++}; ++ ++/** ++ * The output format defined by uadk and drivers should fill the format ++ * @literals_start:address of the literals data output by the hardware ++ * @sequences_start:address of the sequences data output by the hardware ++ * @lit_num:the size of literals ++ * @seq_num:the size of sequences ++ * @lit_length_overflow_cnt:the count of the literal length overflow ++ * @lit_length_overflow_pos:the position of the literal length overflow ++ * @freq:address of the frequency about sequences members ++ * @blk_type:the previous block status, 0 means an uncompressed block, ++ * 1 means a RLE block and 2 means a compressed block. ++ */ ++struct wcrypto_lz77_zstd_format { ++ void *literals_start; ++ void *sequences_start; ++ __u32 lit_num; ++ __u32 seq_num; ++ __u32 lit_length_overflow_cnt; ++ __u32 lit_length_overflow_pos; ++ void *freq; ++ __u32 blk_type; ++}; ++ ++/** ++ * wcrypto_create_comp_ctx() - create a compress context on the wrapdrive queue. ++ * @q: wrapdrive queue, need requested by user. ++ * @setup:setup data of user ++ */ ++void *wcrypto_create_comp_ctx(struct wd_queue *q, ++ struct wcrypto_comp_ctx_setup *setup); ++ ++/** ++ * wcrypto_do_comp() - syn/asynchronous compressing/decompressing operation ++ * @ctx: context of user ++ * @opdata: operational data ++ * @tag: asynchronous:user_tag; synchronous:NULL. ++ */ ++int wcrypto_do_comp(void *ctx, struct wcrypto_comp_op_data *opdata, void *tag); ++ ++/** ++ * wcrypto_comp_poll() - poll operation for asynchronous operation ++ * @q:wrapdrive queue ++ * @num:how many respondences this poll has to get, 0 means get all finishings ++ */ ++int wcrypto_comp_poll(struct wd_queue *q, unsigned int num); ++ ++/** ++ * wcrypto_del_comp_ctx() - free compress context ++ * @ctx: the context to be free ++ */ ++void wcrypto_del_comp_ctx(void *ctx); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/src/uadk/v1/wd_dh.h b/src/uadk/v1/wd_dh.h +new file mode 100644 +index 0000000..e411830 +--- /dev/null ++++ b/src/uadk/v1/wd_dh.h +@@ -0,0 +1,91 @@ ++/* ++ * Copyright 2019 Huawei Technologies Co.,Ltd.All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef __WD_DH_H ++#define __WD_DH_H ++ ++#include ++#include ++#include "wd.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++enum wcrypto_dh_op_type { ++ WCRYPTO_DH_INVALID, /* invalid DH operation */ ++ WCRYPTO_DH_PHASE1, /* Phase1 DH key generate */ ++ WCRYPTO_DH_PHASE2 /* Phase2 DH key compute */ ++}; ++ ++struct wcrypto_dh_ctx_setup { ++ wcrypto_cb cb; /* call back function from user */ ++ __u16 data_fmt; /* data format denoted by enum wd_buff_type */ ++ __u16 key_bits; /* DH key bites */ ++ bool is_g2; /* is g2 mode or not */ ++ struct wd_mm_br br; /* memory operations from user */ ++}; ++ ++struct wcrypto_dh_op_data { ++ void *x_p; /* x and p, should be DMA buffer */ ++ ++ /* it is g, but it is PV at phase 2, should be DMA buffer */ ++ void *pv; ++ ++ /* phase 1&&2 output, should be DMA buffer */ ++ void *pri; ++ __u16 pri_bytes; /* output bytes */ ++ ++ __u16 pbytes; /* p bytes */ ++ __u16 xbytes; /* x bytes */ ++ __u16 pvbytes; /* pv bytes */ ++ enum wcrypto_dh_op_type op_type; /* operational type */ ++ __u32 status; /* output status */ ++}; ++ ++struct wcrypto_dh_msg { ++ __u8 alg_type:3; /* Denoted by enum wcrypto_type */ ++ __u8 op_type:2; /* Denoted by enum wcrypto_dh_op_type */ ++ __u8 data_fmt:1; /* Data format, denoted by enum wd_buff_type */ ++ __u8 is_g2:2; /* g2 mode of phase 1 */ ++ __u8 result; /* Data format, denoted by WD error code */ ++ __u16 key_bytes; /* Key size */ ++ __u8 *x_p; /* This is Xa and p data in order. Should be DMA buffer */ ++ __u8 *g; /* This is PV also at phase 2. Should be DMA buffer */ ++ __u8 *out; /* Result address, should be DMA buffer */ ++ __u16 xbytes; /* parameter Xa size */ ++ __u16 pbytes; /* parameter p size */ ++ __u16 gbytes; /* parameter g size */ ++ __u16 out_bytes; /* output parameter size */ ++ __u64 usr_data; /* user identifier: struct wcrypto_cb_tag */ ++}; ++ ++void *wcrypto_create_dh_ctx(struct wd_queue *q, struct wcrypto_dh_ctx_setup *setup); ++bool wcrypto_dh_is_g2(const void *ctx); ++int wcrypto_dh_key_bits(const void *ctx); ++ ++/* Asynchronous/sync mode APIs of DH */ ++int wcrypto_do_dh(void *ctx, struct wcrypto_dh_op_data *opdata, void *tag); ++int wcrypto_dh_poll(struct wd_queue *q, unsigned int num); ++void wcrypto_del_dh_ctx(void *ctx); ++int wcrypto_set_dh_g(void *ctx, struct wd_dtb *g); ++void wcrypto_get_dh_g(void *ctx, struct wd_dtb **g); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/src/uadk/v1/wd_digest.h b/src/uadk/v1/wd_digest.h +new file mode 100644 +index 0000000..6ad4c85 +--- /dev/null ++++ b/src/uadk/v1/wd_digest.h +@@ -0,0 +1,168 @@ ++/* ++ * Copyright 2019 Huawei Technologies Co.,Ltd.All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef __WD_DIGEST_H ++#define __WD_DIGEST_H ++ ++#include ++#include ++#include ++#include "wd.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++enum wcrypto_digest_alg { ++ WCRYPTO_SM3, ++ WCRYPTO_MD5, ++ WCRYPTO_SHA1, ++ WCRYPTO_SHA256, ++ WCRYPTO_SHA224, ++ WCRYPTO_SHA384, ++ WCRYPTO_SHA512, ++ WCRYPTO_SHA512_224, ++ WCRYPTO_SHA512_256, ++ WCRYPTO_MAX_DIGEST_TYPE, ++}; ++ ++enum wd_digest_mac_len { ++ WCRYPTO_DIGEST_SM3_LEN = 32, ++ WCRYPTO_DIGEST_MD5_LEN = 16, ++ WCRYPTO_DIGEST_SHA1_LEN = 20, ++ WCRYPTO_DIGEST_SHA256_LEN = 32, ++ WCRYPTO_DIGEST_SHA224_LEN = 28, ++ WCRYPTO_DIGEST_SHA384_LEN = 48, ++ WCRYPTO_DIGEST_SHA512_LEN = 64, ++ WCRYPTO_DIGEST_SHA512_224_LEN = 28, ++ WCRYPTO_DIGEST_SHA512_256_LEN = 32 ++}; ++ ++enum wcrypto_digest_mode { ++ WCRYPTO_DIGEST_NORMAL, ++ WCRYPTO_DIGEST_HMAC, ++}; ++ ++/** ++ * different contexts for different users/threads ++ * @cb: call back functions of user ++ * @alg: digest algorithm type; denoted by enum wcrypto_digest_alg ++ * @mode:digest algorithm mode; denoted by enum wcrypto_digest_mode ++ * @br: memory from user, it is given at ctx creating ++ * @data_fmt: data format, denoted by enum wcrypto_buff_type ++ */ ++struct wcrypto_digest_ctx_setup { ++ wcrypto_cb cb; ++ enum wcrypto_digest_alg alg; ++ enum wcrypto_digest_mode mode; ++ struct wd_mm_br br; ++ __u16 data_fmt; ++}; ++ ++/** ++ * operational data per I/O operation ++ * @in: input data address ++ * @out:output data address ++ * @in_bytes: input data size ++ * @out_bytes:output data size ++ * @priv:reserved data field segment ++ * @status:I/O operation return status ++ * @has_next: is there next data block ++ */ ++struct wcrypto_digest_op_data { ++ void *in; ++ void *out; ++ __u32 in_bytes; ++ __u32 out_bytes; ++ void *priv; ++ int status; ++ bool has_next; ++}; ++ ++/* Digest message format of Warpdrive */ ++struct wcrypto_digest_msg { ++ __u8 alg_type; /* Denoted by enum wcrypto_type */ ++ __u8 alg:4; /* Denoted by enum wcrypto_digest_alg */ ++ __u8 has_next:1; /* is there next block data */ ++ __u8 mode:3; /* Denoted by enum wcrypto_digest_mode */ ++ __u8 data_fmt; /* Data format, denoted by enum wcrypto_buff_type */ ++ __u8 result; /* Operation result, denoted by WD error code */ ++ __u16 key_bytes; /* Key bytes */ ++ __u16 iv_bytes; /* IV bytes */ ++ ++ __u8 *key; /* Input key VA pointer, should be DMA buffer */ ++ __u8 *iv; /* Input IV VA pointer, should be DMA buffer */ ++ __u8 *in; /* Input data VA pointer, should be DMA buffer */ ++ __u8 *out; /* Output data VA pointer, should be DMA buffer */ ++ __u32 in_bytes; /* Input data bytes */ ++ __u32 out_bytes; /* Output data bytes */ ++ __u64 usr_data; /* user identifier: struct wcrypto_cb_tag */ ++}; ++ ++/** ++ * wcrypto_create_digest_ctx() - create a digest context on the wrapdrive queue. ++ * @q: wrapdrive queue, need requested by user. ++ * @setup:setup data of user ++ */ ++void *wcrypto_create_digest_ctx(struct wd_queue *q, ++ struct wcrypto_digest_ctx_setup *setup); ++ ++/** ++ * wcrypto_set_digest_key() - set auth key to digest context. ++ * @ctx: digest context, created by wcrypto_create_digest_ctx. ++ * @key: auth key addr ++ * @key_len: auth key length ++ */ ++int wcrypto_set_digest_key(void *ctx, __u8 *key, __u16 key_len); ++ ++/** ++ * wcrypto_do_digest() - syn/asynchronous digest operation ++ * @ctx: context of user, created by wcrypto_create_digest_ctx. ++ * @opdata: operational data ++ * @tag: asynchronous:user_tag; synchronous:NULL. ++ */ ++int wcrypto_do_digest(void *ctx, struct wcrypto_digest_op_data *opdata, ++ void *tag); ++ ++/** ++ * wcrypto_digest_poll() - poll operation for asynchronous operation ++ * @q:wrapdrive queue ++ * @num:how many respondences this poll has to get, 0 means get all finishings ++ */ ++int wcrypto_digest_poll(struct wd_queue *q, unsigned int num); ++ ++/** ++ * wcrypto_del_digest_ctx() - free digest context ++ * @ctx: the context to be free ++ */ ++void wcrypto_del_digest_ctx(void *ctx); ++ ++/** ++ * wcrypto_burst_digest() - (a)synchronous multiple digest operations ++ * @d_ctx: context of user, created by wcrypto_create_digest_ctx. ++ * @opdata: operational data ++ * @tag: asynchronous:user_tag; synchronous:NULL. ++ * @num: operations number per calling, maximum number is WCRYPTO_MAX_BURST_NUM. ++ */ ++int wcrypto_burst_digest(void *d_ctx, struct wcrypto_digest_op_data **opdata, ++ void **tag, __u32 num); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif ++ +diff --git a/src/uadk/v1/wd_ecc.h b/src/uadk/v1/wd_ecc.h +new file mode 100644 +index 0000000..84998ed +--- /dev/null ++++ b/src/uadk/v1/wd_ecc.h +@@ -0,0 +1,273 @@ ++/* ++ * Copyright 2020 Huawei Technologies Co.,Ltd.All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++#ifndef __WD_ECC_H ++#define __WD_ECC_H ++ ++#include ++#include ++#include ++#include "wd.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef int (*wcrypto_rand)(char *out, size_t out_len, void *usr); ++typedef int (*wcrypto_hash)(const char *in, size_t in_len, ++ char *out, size_t out_len, void *usr); ++ ++struct wcrypto_ecc_in; /* ecc input parameters */ ++struct wcrypto_ecc_key; /* ecc key parameters */ ++struct wcrypto_ecc_out; /* ecc output parameters */ ++ ++struct wcrypto_ecc_point { ++ struct wd_dtb x; /* x affine coordinates */ ++ struct wd_dtb y; /* y affine coordinates */ ++}; ++ ++/* ECC operational types */ ++enum wcrypto_ecc_op_type { ++ WCRYPTO_EC_OP_INVALID, /* invalid ecc operation */ ++ WCRYPTO_ECXDH_GEN_KEY, /* ECDH/X448/X25519 generate public key */ ++ WCRYPTO_ECXDH_COMPUTE_KEY, /* ECDH/X448/X25519 compute share key */ ++ WCRYPTO_ECDSA_SIGN, /* ECDSA sign */ ++ WCRYPTO_ECDSA_VERIFY, /* ECDSA verify */ ++ WCRYPTO_SM2_SIGN, /* SM2 sign */ ++ WCRYPTO_SM2_VERIFY, /* SM2 verify */ ++ WCRYPTO_SM2_ENCRYPT, /* SM2 encrypt */ ++ WCRYPTO_SM2_DECRYPT, /* SM2 decrypt */ ++ WCRYPTO_SM2_KG, /* SM2 key generate */ ++ WCRYPTO_EC_OP_MAX /* max operation */ ++}; ++ ++/* ECC operational types */ ++enum wcrypto_ecc_curve_id { ++ WCRYPTO_SECP128R1 = 0x10, /* SECG 128 bit prime field */ ++ WCRYPTO_SECP192K1 = 0x11, /* SECG 192 bit prime field */ ++ WCRYPTO_SECP256K1 = 0x12, /* SECG 256 bit prime field */ ++ WCRYPTO_BRAINPOOLP320R1 = 0x13, /* RFC5639 320 bit prime field */ ++ WCRYPTO_BRAINPOOLP384R1 = 0x14, /* RFC5639 384 bit prime field */ ++ WCRYPTO_SECP521R1 = 0x15, /* NIST/SECG 521 bit prime field */ ++}; ++ ++/* ECC hash callback function types */ ++enum wcrypto_ecc_hash_type { ++ WCRYPTO_HASH_SM3, ++ WCRYPTO_HASH_SHA1, ++ WCRYPTO_HASH_SHA224, ++ WCRYPTO_HASH_SHA256, ++ WCRYPTO_HASH_SHA384, ++ WCRYPTO_HASH_SHA512, ++ WCRYPTO_HASH_MD4, ++ WCRYPTO_HASH_MD5, ++ WCRYPTO_HASH_MAX ++}; ++ ++struct wcrypto_ecc_curve { ++ struct wd_dtb p; /* Prime field p */ ++ struct wd_dtb a; /* Elliptic curve equation a parameter */ ++ struct wd_dtb b; /* Elliptic curve equation b parameter */ ++ struct wcrypto_ecc_point g; /* Elliptic curve G point */ ++ struct wd_dtb n; /* Elliptic curve order */ ++}; ++ ++enum wcrypto_ecc_curve_cfg_type { ++ WCRYPTO_CV_CFG_ID, /* set curve parameter by denote curve ID */ ++ WCRYPTO_CV_CFG_PARAM /* set curve parameter by denote curve parameter */ ++}; ++ ++struct wcrypto_ecc_curve_cfg { ++ __u32 type; /* denoted by enum wcrypto_ecc_curve_cfg_type */ ++ union { ++ enum wcrypto_ecc_curve_id id; /* if WCRYPTO_CV_CFG_ID */ ++ struct wcrypto_ecc_curve *pparam; /* if WCRYPTO_CV_CFG_PARAM */ ++ } cfg; ++ __u8 resv[4]; /* reserve */ ++}; ++ ++struct wcrypto_rand_mt { ++ wcrypto_rand cb; /* rand callback */ ++ void *usr; /* user private parameter */ ++}; ++ ++struct wcrypto_hash_mt { ++ wcrypto_hash cb; /* hash callback */ ++ void *usr; /* user private parameter */ ++ __u8 type; /* hash type, denoted by enum wcrypto_ecc_hash_type */ ++ __u8 rsv[3]; /* reserve */ ++}; ++ ++/* ECC context setting up input parameters from user */ ++struct wcrypto_ecc_ctx_setup { ++ wcrypto_cb cb; /* call back function from user */ ++ __u16 data_fmt; /* data format denoted by enum wd_buff_type */ ++ __u16 key_bits; /* ECC key bits */ ++ struct wcrypto_ecc_curve_cfg cv; /* curve config denoted by user */ ++ struct wd_mm_br br; /* memory operations from user */ ++ struct wcrypto_rand_mt rand; /* rand method from user */ ++ struct wcrypto_hash_mt hash; /* hash method from user */ ++}; ++ ++struct wcrypto_ecc_op_data { ++ enum wcrypto_ecc_op_type op_type; /* ecc operation type */ ++ int status; /* ecc operation status */ ++ void *in; /* ecc operation input address, should be DMA-able */ ++ void *out; /* ecc operation output address, should be DMA-able */ ++ __u32 in_bytes; /* ecc operation input bytes */ ++ __u32 out_bytes; /* ecc operation output bytes */ ++}; ++ ++/* ECC message format of Warpdrive */ ++struct wcrypto_ecc_msg { ++ __u8 alg_type:4; /* Denoted by enum wcrypto_type */ ++ __u8 op_type:4; /* Denoted by enum wcrypto_ecc_op_type */ ++ __u8 curve_id:7; /* Ec curve denoted by enum wcrypto_ecc_curve_type */ ++ __u8 data_fmt:1; /* Data format, denoted by enum wd_buff_type */ ++ __u8 mtype; /* not used, reserve */ ++ __u8 result; /* alg op error code */ ++ __u16 key_bytes; /* key bytes */ ++ __u16 in_bytes; /* Input data bytes */ ++ __u16 out_bytes; /* Output data bytes */ ++ __u8 hash_type; /* hash method denoted by enum wcrypto_ecc_hash_type */ ++ __u8 *in; /* Input data VA, should be DMA buffer */ ++ __u8 *out; /* Output data VA, should be DMA buffer */ ++ __u8 *key; /* Input key VA, should be DMA buffer */ ++ /* ++ * Input user tag, used for identify data stream/user: ++ * struct wcrypto_cb_tag ++ */ ++ __u64 usr_data; ++}; ++ ++int wcrypto_get_ecc_key_bits(const void *ctx); ++void *wcrypto_create_ecc_ctx(struct wd_queue *q, ++ struct wcrypto_ecc_ctx_setup *setup); ++void wcrypto_del_ecc_ctx(void *ctx); ++struct wcrypto_ecc_key *wcrypto_get_ecc_key(void *ctx); ++int wcrypto_set_ecc_prikey(struct wcrypto_ecc_key *ecc_key, ++ struct wd_dtb *prikey); ++int wcrypto_get_ecc_prikey(struct wcrypto_ecc_key *ecc_key, ++ struct wd_dtb **prikey); ++int wcrypto_set_ecc_pubkey(struct wcrypto_ecc_key *ecc_key, ++ struct wcrypto_ecc_point *pubkey); ++int wcrypto_get_ecc_pubkey(struct wcrypto_ecc_key *ecc_key, ++ struct wcrypto_ecc_point **pubkey); ++void wcrypto_del_ecc_in(void *ctx, struct wcrypto_ecc_in *in); ++void wcrypto_del_ecc_out(void *ctx, struct wcrypto_ecc_out *out); ++void wcrypto_get_ecc_prikey_params(struct wcrypto_ecc_key *key, ++ struct wd_dtb **p, struct wd_dtb **a, ++ struct wd_dtb **b, struct wd_dtb **n, ++ struct wcrypto_ecc_point **g, ++ struct wd_dtb **d); ++void wcrypto_get_ecc_pubkey_params(struct wcrypto_ecc_key *key, ++ struct wd_dtb **p, struct wd_dtb **a, ++ struct wd_dtb **b, struct wd_dtb **n, ++ struct wcrypto_ecc_point **g, ++ struct wcrypto_ecc_point **pub); ++ ++/* APIs For ECDH */ ++void wcrypto_get_ecxdh_in_params(struct wcrypto_ecc_in *in, ++ struct wcrypto_ecc_point **pbk); ++void wcrypto_get_ecxdh_out_params(struct wcrypto_ecc_out *out, ++ struct wcrypto_ecc_point **key); ++struct wcrypto_ecc_in *wcrypto_new_ecxdh_in(void *ctx, ++ struct wcrypto_ecc_point *in); ++struct wcrypto_ecc_out *wcrypto_new_ecxdh_out(void *ctx); ++/** ++ * This is a pair of asynchronous mode ECDH/ECDSA/SM2 API as tag is not NULL, ++ * or it is synchronous mode ++ */ ++int wcrypto_do_ecxdh(void *ctx, struct wcrypto_ecc_op_data *opdata, void *tag); ++int wcrypto_ecxdh_poll(struct wd_queue *q, unsigned int num); ++ ++ ++/* APIs For ECDSA sign/verf */ ++struct wcrypto_ecc_in *wcrypto_new_ecdsa_sign_in(void *ctx, ++ struct wd_dtb *dgst, ++ struct wd_dtb *k); ++struct wcrypto_ecc_in *wcrypto_new_ecdsa_verf_in(void *ctx, ++ struct wd_dtb *dgst, ++ struct wd_dtb *r, ++ struct wd_dtb *s); ++struct wcrypto_ecc_out *wcrypto_new_ecdsa_sign_out(void *ctx); ++void wcrypto_get_ecdsa_sign_in_params(struct wcrypto_ecc_in *in, ++ struct wd_dtb **dgst, ++ struct wd_dtb **k); ++void wcrypto_get_ecdsa_verf_in_params(struct wcrypto_ecc_in *in, ++ struct wd_dtb **dgst, ++ struct wd_dtb **r, ++ struct wd_dtb **s); ++void wcrypto_get_ecdsa_sign_out_params(struct wcrypto_ecc_out *out, ++ struct wd_dtb **r, ++ struct wd_dtb **s); ++ ++/** ++ * This is a pair of asynchronous mode ECDSA API as tag is not NULL, ++ * or it is synchronous mode ++ */ ++int wcrypto_do_ecdsa(void *ctx, struct wcrypto_ecc_op_data *opdata, void *tag); ++int wcrypto_ecdsa_poll(struct wd_queue *q, unsigned int num); ++ ++/* APIs For SM2 sign/verf/kg */ ++struct wcrypto_ecc_in *wcrypto_new_sm2_sign_in(void *ctx, ++ struct wd_dtb *e, ++ struct wd_dtb *k, ++ struct wd_dtb *id, ++ __u8 is_dgst); ++struct wcrypto_ecc_in *wcrypto_new_sm2_verf_in(void *ctx, ++ struct wd_dtb *e, ++ struct wd_dtb *r, ++ struct wd_dtb *s, ++ struct wd_dtb *id, ++ __u8 is_dgst); ++struct wcrypto_ecc_out *wcrypto_new_sm2_sign_out(void *ctx); ++ ++void wcrypto_get_sm2_sign_out_params(struct wcrypto_ecc_out *out, ++ struct wd_dtb **r, ++ struct wd_dtb **s); ++ ++struct wcrypto_ecc_in *wcrypto_new_sm2_enc_in(void *ctx, ++ struct wd_dtb *k, ++ struct wd_dtb *plaintext); ++struct wcrypto_ecc_in *wcrypto_new_sm2_dec_in(void *ctx, ++ struct wcrypto_ecc_point *c1, ++ struct wd_dtb *c2, ++ struct wd_dtb *c3); ++struct wcrypto_ecc_out *wcrypto_new_sm2_enc_out(void *ctx, __u32 plaintext_len); ++struct wcrypto_ecc_out *wcrypto_new_sm2_dec_out(void *ctx, __u32 plaintext_len); ++struct wcrypto_ecc_out *wcrypto_new_sm2_kg_out(void *ctx); ++void wcrypto_get_sm2_kg_out_params(struct wcrypto_ecc_out *out, ++ struct wd_dtb **privkey, ++ struct wcrypto_ecc_point **pubkey); ++void wcrypto_get_sm2_enc_out_params(struct wcrypto_ecc_out *out, ++ struct wcrypto_ecc_point **c1, ++ struct wd_dtb **c2, ++ struct wd_dtb **c3); ++void wcrypto_get_sm2_dec_out_params(struct wcrypto_ecc_out *out, ++ struct wd_dtb **plaintext); ++ ++ ++/** ++ * This is a pair of asynchronous mode SM2 API as tag is not NULL, ++ * or it is synchronous mode ++ */ ++int wcrypto_do_sm2(void *ctx, struct wcrypto_ecc_op_data *opdata, void *tag); ++int wcrypto_sm2_poll(struct wd_queue *q, unsigned int num); ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/src/uadk/v1/wd_rng.h b/src/uadk/v1/wd_rng.h +new file mode 100644 +index 0000000..fcde26d +--- /dev/null ++++ b/src/uadk/v1/wd_rng.h +@@ -0,0 +1,76 @@ ++/* ++ * Copyright 2019 Huawei Technologies Co.,Ltd.All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef __WD_RNG_H ++#define __WD_RNG_H ++ ++#include "wd.h" ++#include "wd_digest.h" ++#include "wd_cipher.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++struct wcrypto_rng_ctx_setup { ++ wcrypto_cb cb; ++ __u16 data_fmt; /* Data format, denoted by enum wd_buff_type */ ++ enum wcrypto_type type; /* Please refer to the definition of enum */ ++ enum wcrypto_cipher_alg calg; /* DRBG cipher algorithm */ ++ enum wcrypto_cipher_mode cmode; /* DRBG cipher mode */ ++ enum wcrypto_digest_alg dalg; /* DRBG digest algorithm */ ++ enum wcrypto_digest_mode dmode; /* DRBG digest mode */ ++}; ++ ++struct wcrypto_rng_msg { ++ __u8 alg_type; /* Denoted by enum wcrypto_type */ ++ __u8 op_type; /* Denoted by enum wcrypto_rng_op_type */ ++ __u8 data_fmt; /* Data format, denoted by enum wd_buff_type */ ++ __u8 result; /* Data format, denoted by WD error code */ ++ __u8 *out; /* Result address */ ++ __u8 *in; /* Input address */ ++ __u32 out_bytes; /* output bytes */ ++ __u32 in_bytes; /* input bytes */ ++ __u64 usr_tag; /* user identifier */ ++}; ++ ++enum wcrypto_rng_op_type { ++ WCRYPTO_RNG_INVALID, /* Invalid RNG operational type */ ++ WCRYPTO_DRBG_RESEED, /* seed operation */ ++ WCRYPTO_DRBG_GEN, /* deterministic random number generation */ ++ WCRYPTO_TRNG_GEN, /* true random number generation */ ++}; ++ ++struct wcrypto_rng_op_data { ++ enum wcrypto_rng_op_type op_type; ++ __u32 status; /* Operation result status */ ++ void *in; /* input */ ++ void *out; /* output */ ++ __u32 in_bytes; /* input bytes */ ++ __u32 out_bytes; /* output bytes */ ++}; ++ ++void *wcrypto_create_rng_ctx(struct wd_queue *q, ++ struct wcrypto_rng_ctx_setup *setup); ++void wcrypto_del_rng_ctx(void *ctx); ++int wcrypto_do_rng(void *ctx, struct wcrypto_rng_op_data *opdata, void *tag); ++int wcrypto_rng_poll(struct wd_queue *q, unsigned int num); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/src/uadk/v1/wd_rsa.h b/src/uadk/v1/wd_rsa.h +new file mode 100644 +index 0000000..480c088 +--- /dev/null ++++ b/src/uadk/v1/wd_rsa.h +@@ -0,0 +1,148 @@ ++/* ++ * Copyright 2019 Huawei Technologies Co.,Ltd.All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef __WD_RSA_H ++#define __WD_RSA_H ++ ++#include ++#include ++#include ++#include "wd.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++struct wcrypto_rsa_kg_in; /* rsa key generation input parameters */ ++struct wcrypto_rsa_kg_out; /* rsa key generation output parameters */ ++struct wcrypto_rsa_pubkey; /* rsa public key */ ++struct wcrypto_rsa_prikey; /* rsa private key */ ++ ++/* RSA operational types */ ++enum wcrypto_rsa_op_type { ++ WCRYPTO_RSA_INVALID, /* invalid rsa operation */ ++ WCRYPTO_RSA_SIGN, /* RSA sign */ ++ WCRYPTO_RSA_VERIFY, /* RSA verify */ ++ WCRYPTO_RSA_GENKEY, /* RSA key generation */ ++}; ++ ++/* RSA key types */ ++enum wcrypto_rsa_key_type { ++ WCRYPTO_RSA_INVALID_KEY, /* invalid rsa key type */ ++ WCRYPTO_RSA_PUBKEY, /* rsa public key type */ ++ WCRYPTO_RSA_PRIKEY1, /* invalid rsa private common key type */ ++ WCRYPTO_RSA_PRIKEY2, /* invalid rsa private CRT key type */ ++}; ++ ++/* RSA context setting up input parameters from user */ ++struct wcrypto_rsa_ctx_setup { ++ wcrypto_cb cb; /* call back function from user */ ++ __u16 data_fmt; /* data format denoted by enum wd_buff_type */ ++ __u16 key_bits; /* RSA key bits */ ++ bool is_crt; /* CRT mode or not */ ++ struct wd_mm_br br; /* memory operations from user */ ++}; ++ ++struct wcrypto_rsa_op_data { ++ enum wcrypto_rsa_op_type op_type; /* rsa operation type */ ++ int status; /* rsa operation status */ ++ void *in; /* rsa operation input address, should be DMA-able */ ++ void *out; /* rsa operation output address, should be DMA-able */ ++ __u32 in_bytes; /* rsa operation input bytes */ ++ __u32 out_bytes; /* rsa operation output bytes */ ++}; ++ ++/* RSA message format of Warpdrive */ ++struct wcrypto_rsa_msg { ++ __u8 alg_type:3; /* Denoted by enum wcrypto_type */ ++ __u8 op_type:2; /* Denoted by enum wcrypto_rsa_op_type */ ++ __u8 key_type:2; /* Denoted by enum wcrypto_rsa_key_type */ ++ __u8 data_fmt:1; /* Data format, denoted by enum wd_buff_type */ ++ __u8 result; /* Data format, denoted by WD error code */ ++ __u16 in_bytes; /* Input data bytes */ ++ __u16 out_bytes; /* Output data bytes */ ++ __u16 key_bytes; /* Input key bytes */ ++ __u8 *in; /* Input data VA, buf should be DMA buffer. */ ++ __u8 *out; /* Output data VA pointer, should be DMA buffer */ ++ __u8 *key; /* Input key VA pointer, should be DMA buffer */ ++ ++ /* ++ * Input user tag, used for identify data stream/user: ++ * struct wcrypto_cb_tag ++ */ ++ __u64 usr_data; ++}; ++ ++bool wcrypto_rsa_is_crt(const void *ctx); ++int wcrypto_rsa_key_bits(const void *ctx); ++void *wcrypto_create_rsa_ctx(struct wd_queue *q, struct wcrypto_rsa_ctx_setup *setup); ++void wcrypto_get_rsa_pubkey(void *ctx, struct wcrypto_rsa_pubkey **pubkey); ++void wcrypto_get_rsa_prikey(void *ctx, struct wcrypto_rsa_prikey **prikey); ++int wcrypto_set_rsa_pubkey_params(void *ctx, struct wd_dtb *e, struct wd_dtb *n); ++void wcrypto_get_rsa_pubkey_params(struct wcrypto_rsa_pubkey *pbk, ++ struct wd_dtb **e, struct wd_dtb **n); ++int wcrypto_set_rsa_prikey_params(void *ctx, struct wd_dtb *d, struct wd_dtb *n); ++void wcrypto_get_rsa_prikey_params(struct wcrypto_rsa_prikey *pvk, struct wd_dtb **d, ++ struct wd_dtb **n); ++int wcrypto_set_rsa_crt_prikey_params(void *ctx, struct wd_dtb *dq, ++ struct wd_dtb *dp, ++ struct wd_dtb *qinv, ++ struct wd_dtb *q, ++ struct wd_dtb *p); ++void wcrypto_get_rsa_crt_prikey_params(struct wcrypto_rsa_prikey *pvk, ++ struct wd_dtb **dq, struct wd_dtb **dp, ++ struct wd_dtb **qinv, struct wd_dtb **q, ++ struct wd_dtb **p); ++ ++/* APIs For RSA key generate */ ++struct wcrypto_rsa_kg_in *wcrypto_new_kg_in(void *ctx, struct wd_dtb *e, ++ struct wd_dtb *p, struct wd_dtb *q); ++void wcrypto_del_kg_in(void *ctx, struct wcrypto_rsa_kg_in *ki); ++void wcrypto_get_rsa_kg_in_params(struct wcrypto_rsa_kg_in *kin, struct wd_dtb *e, ++ struct wd_dtb *q, struct wd_dtb *p); ++ ++struct wcrypto_rsa_kg_out *wcrypto_new_kg_out(void *ctx); ++void wcrypto_del_kg_out(void *ctx, struct wcrypto_rsa_kg_out *kout); ++void wcrypto_get_rsa_kg_out_params(struct wcrypto_rsa_kg_out *kout, ++ struct wd_dtb *d, ++ struct wd_dtb *n); ++void wcrypto_get_rsa_kg_out_crt_params(struct wcrypto_rsa_kg_out *kout, ++ struct wd_dtb *qinv, ++ struct wd_dtb *dq, struct wd_dtb *dp); ++ ++int wcrypto_rsa_kg_in_data(struct wcrypto_rsa_kg_in *ki, char **data); ++int wcrypto_rsa_kg_out_data(struct wcrypto_rsa_kg_out *ko, char **data); ++void wcrypto_set_rsa_kg_out_crt_psz(struct wcrypto_rsa_kg_out *kout, ++ size_t qinv_sz, ++ size_t dq_sz, ++ size_t dp_sz); ++void wcrypto_set_rsa_kg_out_psz(struct wcrypto_rsa_kg_out *kout, ++ size_t d_sz, ++ size_t n_sz); ++ ++/** ++ * This is a pair of asynchronous mode RSA API as tag is not NULL, ++ * or it is synchronous mode ++ */ ++int wcrypto_do_rsa(void *ctx, struct wcrypto_rsa_op_data *opdata, void *tag); ++int wcrypto_rsa_poll(struct wd_queue *q, unsigned int num); ++void wcrypto_del_rsa_ctx(void *ctx); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/src/uadk/v1/wd_sgl.h b/src/uadk/v1/wd_sgl.h +new file mode 100644 +index 0000000..e2e82f2 +--- /dev/null ++++ b/src/uadk/v1/wd_sgl.h +@@ -0,0 +1,74 @@ ++/* ++ * Copyright 2020 Huawei Technologies Co.,Ltd.All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef _WD_SGL_H ++#define _WD_SGL_H ++ ++#include ++#include ++#include "wd.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++struct wd_sgl; ++struct wd_sglpool_setup { ++ /* Total number of SGEs with buffer slices */ ++ __u32 buf_num; ++ /* memory size of entry buffer */ ++ __u32 buf_size; ++ /* Fixed SGE number in the SGL of the pool */ ++ __u8 sge_num_in_sgl; ++ /* Initiated buf number in the SGL of the pool, changeable */ ++ __u8 buf_num_in_sgl; ++ /* Total number of sgl for entries and buffers */ ++ __u16 sgl_num; ++ /* SGE data buffer starting address align size */ ++ __u32 align_size; ++ /* memory from user if don't use WD memory */ ++ struct wd_mm_br br; ++}; ++ ++void *wd_sglpool_create(struct wd_queue *q, struct wd_sglpool_setup *setup); ++void wd_sglpool_destroy(void *pool); ++struct wd_sgl *wd_alloc_sgl(void *pool, __u32 size); ++void wd_free_sgl(void *pool, struct wd_sgl *sgl); ++int wd_sgl_merge(struct wd_sgl *dst_sgl, struct wd_sgl *src_sgl); ++int wd_sgl_cp_to_pbuf(struct wd_sgl *sgl, size_t offset, void *pbuf, size_t size); ++int wd_sgl_cp_from_pbuf(struct wd_sgl *sgl, size_t offset, void *pbuf, size_t size); ++void *wd_sgl_iova_map(void *pool, struct wd_sgl *sgl, size_t sz); ++void wd_sgl_iova_unmap(void *pool, void *sgl_iova, struct wd_sgl *sgl); ++ ++void *wd_get_last_sge_buf(struct wd_sgl *sgl); ++void *wd_get_first_sge_buf(struct wd_sgl *sgl); ++int wd_get_sgl_sge_num(struct wd_sgl *sgl); ++int wd_get_sgl_buf_num(struct wd_sgl *sgl); ++void *wd_get_sge_buf(struct wd_sgl *sgl, __u32 num); ++int wd_get_sgl_buf_sum(struct wd_sgl *sgl); ++int wd_get_sgl_mem_size(struct wd_sgl *sgl, size_t *size); ++int wd_get_free_sgl_num(void *pool, __u32 *free_sgl_num); ++int wd_get_free_sgl_sge_num(struct wd_sgl *sgl, __u32 *free_sgl_sge_num); ++int wd_get_free_buf_num(void *pool, __u32 *free_buf_num); ++int wd_get_sgl_datalen(struct wd_sgl *sgl, __u32 *dtsize); ++int wd_get_sge_datalen(struct wd_sgl *sgl, __u32 num, __u32 *dtsize); ++int wd_get_sgl_bufsize(struct wd_sgl *sgl, __u32 *bufsz); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* _WD_SGL_H */ +diff --git a/src/uadk/v1/wd_util.h b/src/uadk/v1/wd_util.h +new file mode 100644 +index 0000000..228493c +--- /dev/null ++++ b/src/uadk/v1/wd_util.h +@@ -0,0 +1,393 @@ ++/* ++ * Copyright 2019 Huawei Technologies Co.,Ltd.All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++/* the common driver header define the unified interface for wd */ ++#ifndef __WD_UTIL_H__ ++#define __WD_UTIL_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "v1/wd.h" ++#include "v1/wd_ecc.h" ++#include "v1/wd_adapter.h" ++ ++#define WD_CTX_MSG_NUM 64 ++#define WD_HPRE_CTX_MSG_NUM 64 ++#define WD_RNG_CTX_MSG_NUM 256 ++#define WD_MAX_CTX_NUM 256 ++#define BYTE_BITS 8 ++#define BYTE_BITS_SHIFT 3 ++#define CRT_PARAMS_SZ(key_size) ((5 * (key_size)) >> 1) ++#define CRT_GEN_PARAMS_SZ(key_size) ((7 * (key_size)) >> 1) ++#define GEN_PARAMS_SZ(key_size) ((key_size) << 1) ++#define CRT_PARAM_SZ(key_size) ((key_size) >> 1) ++#define GET_NEGATIVE(val) (0 - (val)) ++#define XTS_MODE_KEY_SHIFT 1 ++#define AES_KEYSIZE_128 16 ++#define AES_KEYSIZE_192 24 ++#define AES_KEYSIZE_256 32 ++#define CTX_ID_MAX_NUM 64 ++#define CTX_ID_MAX_NUM_BYTES 512 ++ ++/* ECC */ ++#define ECDH_IN_PARAM_NUM 2 ++#define ECDH_OUT_PARAM_NUM 2 ++#define ECC_SIGN_IN_PARAM_NUM 2 ++#define ECC_SIGN_OUT_PARAM_NUM 2 ++#define ECC_VERF_IN_PARAM_NUM 3 ++#define ECC_PRIKEY_PARAM_NUM 7 ++#define ECDH_HW_KEY_PARAM_NUM 5 ++#define ECC_PUBKEY_PARAM_NUM 8 ++#define SM2_KG_OUT_PARAM_NUM 3 ++#define ECC_POINT_PARAM_NUM 2 ++ ++#define ECDH_HW_KEY_SZ(hsz) ((hsz) * ECDH_HW_KEY_PARAM_NUM) ++#define ECC_PRIKEY_SZ(hsz) ((hsz) * ECC_PRIKEY_PARAM_NUM) ++#define ECC_PUBKEY_SZ(hsz) ((hsz) * ECC_PUBKEY_PARAM_NUM) ++#define ECDH_OUT_PARAMS_SZ(hsz) ((hsz) * ECDH_OUT_PARAM_NUM) ++ ++/* x25519/x448 */ ++#define X_DH_OUT_PARAM_NUM 1 ++#define X_DH_HW_KEY_PARAM_NUM 3 ++ ++#define X_DH_OUT_PARAMS_SZ(hsz) ((hsz) * X_DH_OUT_PARAM_NUM) ++#define X_DH_HW_KEY_SZ(hsz) ((hsz) * X_DH_HW_KEY_PARAM_NUM) ++#define SM2_KG_OUT_PARAMS_SZ(hsz) ((hsz) * SM2_KG_OUT_PARAM_NUM) ++#define BITS_TO_BYTES(bits) (((bits) + 7) >> 3) ++#define ECC_SIGN_IN_PARAMS_SZ(hsz) ((hsz) * ECC_SIGN_IN_PARAM_NUM) ++#define ECC_SIGN_OUT_PARAMS_SZ(hsz) ((hsz) * ECC_SIGN_OUT_PARAM_NUM) ++#define ECC_VERF_IN_PARAMS_SZ(hsz) ((hsz) * ECC_VERF_IN_PARAM_NUM) ++#define ECC_VERF_OUT_PARAMS_SZ 1 ++ ++/* Required compiler attributes */ ++#define likely(x) __builtin_expect(!!(x), 1) ++#define unlikely(x) __builtin_expect(!!(x), 0) ++#define MIN(a, b) (((a) < (b)) ? (a) : (b)) ++ ++struct wd_lock { ++ __u8 lock; ++}; ++ ++struct wd_ss_region { ++ void *va; ++ unsigned long long pa; ++ size_t size; ++ ++ TAILQ_ENTRY(wd_ss_region) next; ++}; ++ ++TAILQ_HEAD(wd_ss_region_list, wd_ss_region); ++ ++struct q_info { ++ const char *hw_type; ++ int hw_type_id; ++ int ref; ++ void *priv; /* private data used by the drive layer */ ++ const void *dev_info; ++ void *ss_va; ++ int fd; ++ int iommu_type; ++ struct wd_ss_region_list ss_list; ++ struct wd_ss_region_list *head; ++ unsigned int dev_flags; ++ unsigned long ss_size; ++ enum wcrypto_type atype; ++ int ctx_num; ++ struct wd_mm_br br; ++ struct wcrypto_hash_mt hash; ++ unsigned long qfrs_offset[WD_UACCE_QFRT_MAX]; ++ struct wd_lock qlock; ++ __u8 ctx_id[WD_MAX_CTX_NUM]; ++}; ++ ++struct wd_cookie_pool { ++ void *cookies; ++ __u8 *cstatus; ++ __u32 cookies_num; ++ __u32 cookies_size; ++ __u32 cid; ++}; ++ ++struct wd_dif_gen { ++ __u32 page_layout_gen_type:4; ++ __u32 grd_gen_type:4; ++ __u32 ver_gen_type:4; ++ __u32 app_gen_type:4; ++ __u32 ref_gen_type:4; ++ __u32 page_layout_pad_type:2; ++ __u32 reserved:10; ++}; ++ ++struct wd_dif_verify { ++ __u16 page_layout_pad_type:2; ++ __u16 grd_verify_type:4; ++ __u16 ref_verify_type:4; ++ __u16 reserved:6; ++}; ++ ++struct wd_dif_ctrl { ++ struct wd_dif_gen gen; ++ struct wd_dif_verify verify; ++ __u8 dif_comp_ctrl; ++}; ++ ++struct wd_dif { ++ __u64 lba; ++ __u32 priv_info; ++ __u8 ver; ++ __u8 app; ++ struct wd_dif_ctrl ctrl; ++}; ++ ++struct wd_sec_udata { ++ __u32 src_offset; ++ __u32 dst_offset; ++ struct wd_dif dif; ++ __u16 block_size; ++ __u16 gran_num; ++ __u16 key_bytes; ++ __u8 *key; ++}; ++ ++/* Digest tag format of Warpdrive */ ++struct wcrypto_digest_tag { ++ struct wcrypto_cb_tag wcrypto_tag; ++ __u64 long_data_len; ++ void *priv; ++}; ++ ++/* Cipher tag format of Warpdrive */ ++struct wcrypto_cipher_tag { ++ struct wcrypto_cb_tag wcrypto_tag; ++ void *priv; ++}; ++ ++/* AEAD tag format of Warpdrive */ ++struct wcrypto_aead_tag { ++ struct wcrypto_cb_tag wcrypto_tag; ++ void *priv; ++}; ++ ++/* EC tag format of Warpdrive */ ++struct wcrypto_ec_tag { ++ struct wcrypto_cb_tag wcrypto_tag; ++ __u64 tbl_addr; ++ void *priv; ++}; ++ ++/* COMP tag format of Warpdrive */ ++struct wcrypto_comp_tag { ++ struct wcrypto_cb_tag wcrypto_tag; ++ void *priv; ++}; ++ ++/* ecc */ ++struct wcrypto_ecc_pubkey { ++ struct wd_dtb p; ++ struct wd_dtb a; ++ struct wd_dtb b; ++ struct wd_dtb n; ++ struct wcrypto_ecc_point g; ++ struct wcrypto_ecc_point pub; ++ __u32 size; ++ void *data; ++}; ++ ++struct wcrypto_ecc_prikey { ++ struct wd_dtb p; ++ struct wd_dtb a; ++ struct wd_dtb d; ++ struct wd_dtb b; ++ struct wd_dtb n; ++ struct wcrypto_ecc_point g; ++ __u32 size; ++ void *data; ++}; ++ ++struct wcrypto_ecc_key { ++ struct wcrypto_ecc_pubkey *pubkey; ++ struct wcrypto_ecc_prikey *prikey; ++ struct wcrypto_ecc_curve *cv; ++ struct wcrypto_ecc_point *pub; ++ struct wd_dtb *d; ++}; ++ ++struct wcrypto_ecc_dh_in { ++ struct wcrypto_ecc_point pbk; ++}; ++ ++struct wcrypto_ecc_sign_in { ++ struct wd_dtb dgst; /* hash message */ ++ struct wd_dtb k; /* random */ ++ struct wd_dtb plaintext; /* original text before hash */ ++ __u8 k_set; /* 1 - k parameter set 0 - not set */ ++ __u8 dgst_set; /* 1 - dgst parameter set 0 - not set */ ++}; ++ ++struct wcrypto_ecc_verf_in { ++ struct wd_dtb dgst; /* hash message */ ++ struct wd_dtb s; /* signature s parameter */ ++ struct wd_dtb r; /* signature r parameter */ ++ struct wd_dtb plaintext; /* original text before hash */ ++ __u8 dgst_set; /* 1 - dgst parameter set 0 - not set */ ++}; ++ ++struct wcrypto_ecc_dh_out { ++ struct wcrypto_ecc_point out; ++}; ++ ++struct wcrypto_ecc_sign_out { ++ struct wd_dtb r; /* signature r parameter */ ++ struct wd_dtb s; /* signature s parameter */ ++}; ++ ++struct wcrypto_sm2_enc_in { ++ struct wd_dtb k; /* random */ ++ struct wd_dtb plaintext; /* original text */ ++ __u8 k_set; /* 0 - not set 1 - set */ ++}; ++ ++struct wcrypto_sm2_enc_out { ++ struct wcrypto_ecc_point c1; ++ struct wd_dtb c2; ++ struct wd_dtb c3; ++}; ++ ++struct wcrypto_sm2_dec_in { ++ struct wcrypto_ecc_point c1; ++ struct wd_dtb c2; ++ struct wd_dtb c3; ++}; ++ ++struct wcrypto_sm2_kg_in { ++ struct wcrypto_ecc_point g; ++}; ++ ++struct wcrypto_sm2_dec_out { ++ struct wd_dtb plaintext; ++}; ++ ++struct wcrypto_sm2_kg_out { ++ struct wcrypto_ecc_point pub; ++ struct wd_dtb priv; ++}; ++ ++typedef union { ++ struct wcrypto_ecc_dh_in dh_in; ++ struct wcrypto_ecc_sign_in sin; ++ struct wcrypto_ecc_verf_in vin; ++ struct wcrypto_sm2_enc_in ein; ++ struct wcrypto_sm2_dec_in din; ++ struct wcrypto_sm2_kg_in kin; ++} wcrypto_ecc_in_param; ++ ++typedef union { ++ struct wcrypto_ecc_dh_out dh_out; ++ struct wcrypto_ecc_sign_out sout; ++ struct wcrypto_sm2_enc_out eout; ++ struct wcrypto_sm2_dec_out dout; ++ struct wcrypto_sm2_kg_out kout; ++} wcrypto_ecc_out_param; ++ ++struct wcrypto_ecc_in { ++ wcrypto_ecc_in_param param; ++ __u64 size; ++ char data[]; ++}; ++ ++struct wcrypto_ecc_out { ++ wcrypto_ecc_out_param param; ++ __u64 size; ++ char data[]; ++}; ++ ++#ifdef DEBUG_LOG ++#define dbg(msg, ...) fprintf(stderr, msg, ##__VA_ARGS__) ++#else ++#define dbg(msg, ...) ++#endif ++ ++#ifdef DEBUG ++#define ASSERT(f) assert(f) ++#else ++#define ASSERT(f) ++#endif ++ ++#if defined(__AARCH64_CMODEL_SMALL__) && __AARCH64_CMODEL_SMALL__ ++#define dsb(opt) { asm volatile("dsb " #opt : : : "memory"); } ++#define rmb() dsb(ld) /* read fence */ ++#define wmb() dsb(st) /* write fence */ ++#define mb() dsb(sy) /* rw fence */ ++#else ++#define rmb() __sync_synchronize() /* read fence */ ++#define wmb() __sync_synchronize() /* write fence */ ++#define mb() __sync_synchronize() /* rw fence */ ++#endif ++ ++static inline void wd_reg_write(void *reg_addr, uint32_t value) ++{ ++ *((uint32_t *)reg_addr) = value; ++ wmb(); /* load fence */ ++} ++ ++static inline uint32_t wd_reg_read(void *reg_addr) ++{ ++ uint32_t temp; ++ ++ temp = *((uint32_t *)reg_addr); ++ rmb(); /* load fence */ ++ ++ return temp; ++} ++ ++void wd_spinlock(struct wd_lock *lock); ++void wd_unspinlock(struct wd_lock *lock); ++void *wd_drv_mmap_qfr(struct wd_queue *q, enum uacce_qfrt qfrt, size_t size); ++void wd_drv_unmmap_qfr(struct wd_queue *q, void *addr, ++ enum uacce_qfrt qfrt, size_t size); ++void *drv_iova_map(struct wd_queue *q, void *va, size_t sz); ++void drv_iova_unmap(struct wd_queue *q, void *va, void *dma, size_t sz); ++int wd_init_cookie_pool(struct wd_cookie_pool *pool, ++ __u32 cookies_size, __u32 cookies_num); ++void wd_uninit_cookie_pool(struct wd_cookie_pool *pool); ++int wd_alloc_id(__u8 *buf, __u32 size, __u32 *id, __u32 last_id, __u32 id_max); ++void wd_free_id(__u8 *buf, __u32 size, __u32 id, __u32 id_max); ++int wd_get_cookies(struct wd_cookie_pool *pool, void **cookies, __u32 num); ++void wd_put_cookies(struct wd_cookie_pool *pool, void **cookies, __u32 num); ++const char *wd_get_drv(struct wd_queue *q); ++int wd_burst_send(struct wd_queue *q, void **req, __u32 num); ++int wd_burst_recv(struct wd_queue *q, void **resp, __u32 num); ++ ++void drv_set_sgl_sge_pri(struct wd_sgl *sgl, int num, void *priv); ++void *drv_get_sgl_sge_pri(struct wd_sgl *sgl, int num); ++void drv_set_sgl_pri(struct wd_sgl *sgl, void *priv); ++void *drv_get_sgl_pri(struct wd_sgl *sgl); ++struct wd_mm_br *drv_get_br(void *pool); ++void wd_sgl_memset(struct wd_sgl *sgl, int ch); ++ ++#endif +-- +2.33.0 + diff --git a/lzma2200_so.7z b/lzma2200_so.7z new file mode 100644 index 0000000000000000000000000000000000000000..a8c89043d46541cce0e2729c58edcc103ea52542 GIT binary patch literal 653953 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

*4{1HOc)Q?LTgeRKc)B1%ctyVS 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℘~lPFYeaFa@q@%433O3$=7{C3YI0} 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 z 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%0AZc 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

}j$*6emwE;qm4_qtpTH8HuAZ};FLO9+ux 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ⅈUTx5gNYx-g-@2nnbJFev1u!Vyca*j#NDQ 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 literal 0 HcmV?d00001 diff --git a/unizip-v0.0.3.zip b/unizip-v0.0.3.zip new file mode 100644 index 0000000000000000000000000000000000000000..59e4bc2e6ced90ba5ca04f0661a113b343235399 GIT binary patch literal 207742 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

4Q4asFb!tm_jm~IhZ0jteq$;ycap#a-; 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 literal 0 HcmV?d00001 diff --git a/unizip.spec b/unizip.spec new file mode 100644 index 0000000..8da9bea --- /dev/null +++ b/unizip.spec @@ -0,0 +1,75 @@ +#needsrootforbuild +%global debug_package %{nil} +%define __os_install_post %{nil} + +Name: unizip +Version: 0.0.3 +Release: 1 +Summary: unizip is a unified compression library that encapsulates zlib, snappy, lz4 and other compression algorithms into a unified interface. + +License: MulanPSL-2.0 +URL: https://gitee.com/openeuler/unizip +Source0: %{name}-v%{version}.zip +Source1: lzma2200_so.7z + +Patch0: add-lzma-sdk-and-uadk-include-file.patch + +BuildRequires: gmock-devel gmp-devel cmake make dos2unix p7zip gcc-c++ libgpg-error-devel +BuildRequires: zlib-devel bzip2-devel zstd-devel snappy-devel brotli-devel lz4-devel xz-devel +Requires: zlib bzip2 zstd snappy brotli lz4 + +%ifarch aarch64 +BuildRequires: libwd +%endif + +%description +%{summary} + +%package devel +Summary: Development files for %{name} +Requires: %{name} = %{version}-%{release} + +%description devel +This package contains the header files and libraries for developing +with %{name}. + +%prep +%setup -q -c -T -n %{name}-%{version} -a 0 +%patch0 -p1 -d %{name}-v%{version} +%setup -q -c -T -n lzma2200 -a 1 + +%build + +pushd %{_builddir}/lzma2200/lzma-sdk/C/Util/Lzma +make -f makefile.gcc clean +make -f makefile.gcc all +popd + +pushd %{_builddir}/%{name}-%{version}/%{name}-v%{version} +%cmake -DCMAKE_SKIP_RPATH:BOOL=ON -B build -DLIB7LZMA_LIBRARY=%{_builddir}/lzma2200/lzma-sdk/C/Util/Lzma/_o/lib7lzma.so +make VERBOSE=1 -C build +popd + +%install +pushd %{_builddir}/%{name}-%{version}/%{name}-v%{version} +%make_install -C build +install -m555 %{_builddir}/lzma2200/lzma-sdk/C/Util/Lzma/_o/lib7lzma.so %{buildroot}/%{_libdir}/ +popd + +%check +pushd %{_builddir}/%{name}-%{version}/%{name}-v%{version}/build/ +#ctest +popd + +%files +%{_libdir}/lib7lzma.so +%{_libdir}/libunizip.so +%{_libdir}/pkgconfig/unizip.pc + +%files devel +%{_includedir}/*.h +%{_libdir}/*.a + +%changelog +* Tue Mar 28 2023 huangduirong - 0.0.3-1 +- Package init diff --git a/unizip.yaml b/unizip.yaml new file mode 100644 index 0000000..029a57e --- /dev/null +++ b/unizip.yaml @@ -0,0 +1,5 @@ +version_control: gitee +src_repo: openeuler/unizip +tag_prefix: ^v +separator: . +git_url: https://gitee.com/openeuler/unizip.git