Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 286 insertions, 0 deletions

diff --git a/other-licenses/7zstub/src/C/7zFile.c b/other-licenses/7zstub/src/C/7zFile.c
new file mode 100644
index 0000000000..e486901e30
--- /dev/null
+++ b/other-licenses/7zstub/src/C/7zFile.c
@@ -0,0 +1,286 @@
+/* 7zFile.c -- File IO

+2017-04-03 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

+

+#include "7zFile.h"

+

+#ifndef USE_WINDOWS_FILE

+

+#ifndef UNDER_CE

+#include <errno.h>

+#endif

+

+#else

+

+/*

+   ReadFile and WriteFile functions in Windows have BUG:

+   If you Read or Write 64MB or more (probably min_failure_size = 64MB - 32KB + 1)

+   from/to Network file, it returns ERROR_NO_SYSTEM_RESOURCES

+   (Insufficient system resources exist to complete the requested service).

+   Probably in some version of Windows there are problems with other sizes:

+   for 32 MB (maybe also for 16 MB).

+   And message can be "Network connection was lost"

+*/

+

+#define kChunkSizeMax (1 << 22)

+

+#endif

+

+void File_Construct(CSzFile *p)

+{

+  #ifdef USE_WINDOWS_FILE

+  p->handle = INVALID_HANDLE_VALUE;

+  #else

+  p->file = NULL;

+  #endif

+}

+

+#if !defined(UNDER_CE) || !defined(USE_WINDOWS_FILE)

+static WRes File_Open(CSzFile *p, const char *name, int writeMode)

+{

+  #ifdef USE_WINDOWS_FILE

+  p->handle = CreateFileA(name,

+      writeMode ? GENERIC_WRITE : GENERIC_READ,

+      FILE_SHARE_READ, NULL,

+      writeMode ? CREATE_ALWAYS : OPEN_EXISTING,

+      FILE_ATTRIBUTE_NORMAL, NULL);

+  return (p->handle != INVALID_HANDLE_VALUE) ? 0 : GetLastError();

+  #else

+  p->file = fopen(name, writeMode ? "wb+" : "rb");

+  return (p->file != 0) ? 0 :

+    #ifdef UNDER_CE

+    2; /* ENOENT */

+    #else

+    errno;

+    #endif

+  #endif

+}

+

+WRes InFile_Open(CSzFile *p, const char *name) { return File_Open(p, name, 0); }

+WRes OutFile_Open(CSzFile *p, const char *name) { return File_Open(p, name, 1); }

+#endif

+

+#ifdef USE_WINDOWS_FILE

+static WRes File_OpenW(CSzFile *p, const WCHAR *name, int writeMode)

+{

+  p->handle = CreateFileW(name,

+      writeMode ? GENERIC_WRITE : GENERIC_READ,

+      FILE_SHARE_READ, NULL,

+      writeMode ? CREATE_ALWAYS : OPEN_EXISTING,

+      FILE_ATTRIBUTE_NORMAL, NULL);

+  return (p->handle != INVALID_HANDLE_VALUE) ? 0 : GetLastError();

+}

+WRes InFile_OpenW(CSzFile *p, const WCHAR *name) { return File_OpenW(p, name, 0); }

+WRes OutFile_OpenW(CSzFile *p, const WCHAR *name) { return File_OpenW(p, name, 1); }

+#endif

+

+WRes File_Close(CSzFile *p)

+{

+  #ifdef USE_WINDOWS_FILE

+  if (p->handle != INVALID_HANDLE_VALUE)

+  {

+    if (!CloseHandle(p->handle))

+      return GetLastError();

+    p->handle = INVALID_HANDLE_VALUE;

+  }

+  #else

+  if (p->file != NULL)

+  {

+    int res = fclose(p->file);

+    if (res != 0)

+      return res;

+    p->file = NULL;

+  }

+  #endif

+  return 0;

+}

+

+WRes File_Read(CSzFile *p, void *data, size_t *size)

+{

+  size_t originalSize = *size;

+  if (originalSize == 0)

+    return 0;

+

+  #ifdef USE_WINDOWS_FILE

+

+  *size = 0;

+  do

+  {

+    DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;

+    DWORD processed = 0;

+    BOOL res = ReadFile(p->handle, data, curSize, &processed, NULL);

+    data = (void *)((Byte *)data + processed);

+    originalSize -= processed;

+    *size += processed;

+    if (!res)

+      return GetLastError();

+    if (processed == 0)

+      break;

+  }

+  while (originalSize > 0);

+  return 0;

+

+  #else

+  

+  *size = fread(data, 1, originalSize, p->file);

+  if (*size == originalSize)

+    return 0;

+  return ferror(p->file);

+  

+  #endif

+}

+

+WRes File_Write(CSzFile *p, const void *data, size_t *size)

+{

+  size_t originalSize = *size;

+  if (originalSize == 0)

+    return 0;

+  

+  #ifdef USE_WINDOWS_FILE

+

+  *size = 0;

+  do

+  {

+    DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;

+    DWORD processed = 0;

+    BOOL res = WriteFile(p->handle, data, curSize, &processed, NULL);

+    data = (void *)((Byte *)data + processed);

+    originalSize -= processed;

+    *size += processed;

+    if (!res)

+      return GetLastError();

+    if (processed == 0)

+      break;

+  }

+  while (originalSize > 0);

+  return 0;

+

+  #else

+

+  *size = fwrite(data, 1, originalSize, p->file);

+  if (*size == originalSize)

+    return 0;

+  return ferror(p->file);

+  

+  #endif

+}

+

+WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)

+{

+  #ifdef USE_WINDOWS_FILE

+

+  LARGE_INTEGER value;

+  DWORD moveMethod;

+  value.LowPart = (DWORD)*pos;

+  value.HighPart = (LONG)((UInt64)*pos >> 16 >> 16); /* for case when UInt64 is 32-bit only */

+  switch (origin)

+  {

+    case SZ_SEEK_SET: moveMethod = FILE_BEGIN; break;

+    case SZ_SEEK_CUR: moveMethod = FILE_CURRENT; break;

+    case SZ_SEEK_END: moveMethod = FILE_END; break;

+    default: return ERROR_INVALID_PARAMETER;

+  }

+  value.LowPart = SetFilePointer(p->handle, value.LowPart, &value.HighPart, moveMethod);

+  if (value.LowPart == 0xFFFFFFFF)

+  {

+    WRes res = GetLastError();

+    if (res != NO_ERROR)

+      return res;

+  }

+  *pos = ((Int64)value.HighPart << 32) | value.LowPart;

+  return 0;

+

+  #else

+  

+  int moveMethod;

+  int res;

+  switch (origin)

+  {

+    case SZ_SEEK_SET: moveMethod = SEEK_SET; break;

+    case SZ_SEEK_CUR: moveMethod = SEEK_CUR; break;

+    case SZ_SEEK_END: moveMethod = SEEK_END; break;

+    default: return 1;

+  }

+  res = fseek(p->file, (long)*pos, moveMethod);

+  *pos = ftell(p->file);

+  return res;

+  

+  #endif

+}

+

+WRes File_GetLength(CSzFile *p, UInt64 *length)

+{

+  #ifdef USE_WINDOWS_FILE

+  

+  DWORD sizeHigh;

+  DWORD sizeLow = GetFileSize(p->handle, &sizeHigh);

+  if (sizeLow == 0xFFFFFFFF)

+  {

+    DWORD res = GetLastError();

+    if (res != NO_ERROR)

+      return res;

+  }

+  *length = (((UInt64)sizeHigh) << 32) + sizeLow;

+  return 0;

+  

+  #else

+  

+  long pos = ftell(p->file);

+  int res = fseek(p->file, 0, SEEK_END);

+  *length = ftell(p->file);

+  fseek(p->file, pos, SEEK_SET);

+  return res;

+  

+  #endif

+}

+

+

+/* ---------- FileSeqInStream ---------- */

+

+static SRes FileSeqInStream_Read(const ISeqInStream *pp, void *buf, size_t *size)

+{

+  CFileSeqInStream *p = CONTAINER_FROM_VTBL(pp, CFileSeqInStream, vt);

+  return File_Read(&p->file, buf, size) == 0 ? SZ_OK : SZ_ERROR_READ;

+}

+

+void FileSeqInStream_CreateVTable(CFileSeqInStream *p)

+{

+  p->vt.Read = FileSeqInStream_Read;

+}

+

+

+/* ---------- FileInStream ---------- */

+

+static SRes FileInStream_Read(const ISeekInStream *pp, void *buf, size_t *size)

+{

+  CFileInStream *p = CONTAINER_FROM_VTBL(pp, CFileInStream, vt);

+  return (File_Read(&p->file, buf, size) == 0) ? SZ_OK : SZ_ERROR_READ;

+}

+

+static SRes FileInStream_Seek(const ISeekInStream *pp, Int64 *pos, ESzSeek origin)

+{

+  CFileInStream *p = CONTAINER_FROM_VTBL(pp, CFileInStream, vt);

+  return File_Seek(&p->file, pos, origin);

+}

+

+void FileInStream_CreateVTable(CFileInStream *p)

+{

+  p->vt.Read = FileInStream_Read;

+  p->vt.Seek = FileInStream_Seek;

+}

+

+

+/* ---------- FileOutStream ---------- */

+

+static size_t FileOutStream_Write(const ISeqOutStream *pp, const void *data, size_t size)

+{

+  CFileOutStream *p = CONTAINER_FROM_VTBL(pp, CFileOutStream, vt);

+  File_Write(&p->file, data, &size);

+  return size;

+}

+

+void FileOutStream_CreateVTable(CFileOutStream *p)

+{

+  p->vt.Write = FileOutStream_Write;

+}