1 files changed, 43 insertions, 54 deletions
diff --git a/src/Common/libzip/zip_buffer.c b/src/Common/libzip/zip_buffer.c
index 7addc4b6..e2103f04 100644
--- a/src/Common/libzip/zip_buffer.c
+++ b/src/Common/libzip/zip_buffer.c
@@ -1,9 +1,9 @@
 /*
  zip_buffer.c -- bounds checked access to memory buffer
- Copyright (C) 2014-2016 Dieter Baron and Thomas Klausner
+ Copyright (C) 2014-2021 Dieter Baron and Thomas Klausner
 
  This file is part of libzip, a library to manipulate ZIP archives.
- The authors can be contacted at <libzip@nih.at>
+ The authors can be contacted at <info@libzip.org>
 
  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions
@@ -37,15 +37,13 @@
 #include "zipint.h"
 
 zip_uint8_t *
-_zip_buffer_data(zip_buffer_t *buffer)
-{
+_zip_buffer_data(zip_buffer_t *buffer) {
     return buffer->data;
 }
 
 
 void
-_zip_buffer_free(zip_buffer_t *buffer)
-{
+_zip_buffer_free(zip_buffer_t *buffer) {
     if (buffer == NULL) {
         return;
     }
@@ -59,21 +57,19 @@ _zip_buffer_free(zip_buffer_t *buffer)
 
 
 bool
-_zip_buffer_eof(zip_buffer_t *buffer)
-{
+_zip_buffer_eof(zip_buffer_t *buffer) {
     return buffer->ok && buffer->offset == buffer->size;
 }
 
 
 zip_uint8_t *
-_zip_buffer_get(zip_buffer_t *buffer, zip_uint64_t length)
-{
+_zip_buffer_get(zip_buffer_t *buffer, zip_uint64_t length) {
     zip_uint8_t *data;
 
     data = _zip_buffer_peek(buffer, length);
 
     if (data != NULL) {
-	buffer->offset += length;
+        buffer->offset += length;
     }
 
     return data;
@@ -81,8 +77,7 @@ _zip_buffer_get(zip_buffer_t *buffer, zip_uint64_t length)
 
 
 zip_uint16_t
-_zip_buffer_get_16(zip_buffer_t *buffer)
-{
+_zip_buffer_get_16(zip_buffer_t *buffer) {
     zip_uint8_t *data = _zip_buffer_get(buffer, 2);
 
     if (data == NULL) {
@@ -94,8 +89,7 @@ _zip_buffer_get_16(zip_buffer_t *buffer)
 
 
 zip_uint32_t
-_zip_buffer_get_32(zip_buffer_t *buffer)
-{
+_zip_buffer_get_32(zip_buffer_t *buffer) {
     zip_uint8_t *data = _zip_buffer_get(buffer, 4);
 
     if (data == NULL) {
@@ -107,8 +101,7 @@ _zip_buffer_get_32(zip_buffer_t *buffer)
 
 
 zip_uint64_t
-_zip_buffer_get_64(zip_buffer_t *buffer)
-{
+_zip_buffer_get_64(zip_buffer_t *buffer) {
     zip_uint8_t *data = _zip_buffer_get(buffer, 8);
 
     if (data == NULL) {
@@ -119,10 +112,8 @@ _zip_buffer_get_64(zip_buffer_t *buffer)
 }
 
 
-
 zip_uint8_t
-_zip_buffer_get_8(zip_buffer_t *buffer)
-{
+_zip_buffer_get_8(zip_buffer_t *buffer) {
     zip_uint8_t *data = _zip_buffer_get(buffer, 1);
 
     if (data == NULL) {
@@ -134,33 +125,43 @@ _zip_buffer_get_8(zip_buffer_t *buffer)
 
 
 zip_uint64_t
-_zip_buffer_left(zip_buffer_t *buffer)
-{
+_zip_buffer_left(zip_buffer_t *buffer) {
     return buffer->ok ? buffer->size - buffer->offset : 0;
 }
 
 
 zip_uint64_t
-_zip_buffer_read(zip_buffer_t *buffer, zip_uint8_t *data, zip_uint64_t length)
-{
+_zip_buffer_read(zip_buffer_t *buffer, zip_uint8_t *data, zip_uint64_t length) {
+    zip_uint64_t copied;
+
     if (_zip_buffer_left(buffer) < length) {
-	length = _zip_buffer_left(buffer);
+        length = _zip_buffer_left(buffer);
     }
 
-    memcpy(data, _zip_buffer_get(buffer, length), length);
+    copied = 0;
+    while (copied < length) {
+        size_t n = ZIP_MIN(length - copied, SIZE_MAX);
+        (void)memcpy_s(data + copied, n, _zip_buffer_get(buffer, n), n);
+        copied += n;
+    }
 
-    return length;
+    return copied;
 }
 
 
 zip_buffer_t *
-_zip_buffer_new(zip_uint8_t *data, zip_uint64_t size)
-{
+_zip_buffer_new(zip_uint8_t *data, zip_uint64_t size) {
     bool free_data = (data == NULL);
     zip_buffer_t *buffer;
 
+#if ZIP_UINT64_MAX > SIZE_MAX
+    if (size > SIZE_MAX) {
+        return NULL;
+    }
+#endif
+
     if (data == NULL) {
-        if ((data = (zip_uint8_t *)malloc(size)) == NULL) {
+        if ((data = (zip_uint8_t *)malloc((size_t)size)) == NULL) {
             return NULL;
         }
     }
@@ -183,8 +184,7 @@ _zip_buffer_new(zip_uint8_t *data, zip_uint64_t size)
 
 
 zip_buffer_t *
-_zip_buffer_new_from_source(zip_source_t *src, zip_uint64_t size, zip_uint8_t *buf, zip_error_t *error)
-{
+_zip_buffer_new_from_source(zip_source_t *src, zip_uint64_t size, zip_uint8_t *buf, zip_error_t *error) {
     zip_buffer_t *buffer;
 
     if ((buffer = _zip_buffer_new(buf, size)) == NULL) {
@@ -202,23 +202,19 @@ _zip_buffer_new_from_source(zip_source_t *src, zip_uint64_t size, zip_uint8_t *b
 
 
 zip_uint64_t
-_zip_buffer_offset(zip_buffer_t *buffer)
-{
+_zip_buffer_offset(zip_buffer_t *buffer) {
     return buffer->ok ? buffer->offset : 0;
 }
 
 
 bool
-_zip_buffer_ok(zip_buffer_t *buffer)
-{
+_zip_buffer_ok(zip_buffer_t *buffer) {
     return buffer->ok;
 }
 
 
-
 zip_uint8_t *
-_zip_buffer_peek(zip_buffer_t *buffer, zip_uint64_t length)
-{
+_zip_buffer_peek(zip_buffer_t *buffer, zip_uint64_t length) {
     zip_uint8_t *data;
 
     if (!buffer->ok || buffer->offset + length < length || buffer->offset + length > buffer->size) {
@@ -231,22 +227,20 @@ _zip_buffer_peek(zip_buffer_t *buffer, zip_uint64_t length)
 }
 
 int
-_zip_buffer_put(zip_buffer_t *buffer, const void *src, size_t length)
-{
+_zip_buffer_put(zip_buffer_t *buffer, const void *src, size_t length) {
     zip_uint8_t *dst = _zip_buffer_get(buffer, length);
 
     if (dst == NULL) {
         return -1;
     }
 
-    memcpy(dst, src, length);
+    (void)memcpy_s(dst, length, src, length);
     return 0;
 }
 
 
 int
-_zip_buffer_put_16(zip_buffer_t *buffer, zip_uint16_t i)
-{
+_zip_buffer_put_16(zip_buffer_t *buffer, zip_uint16_t i) {
     zip_uint8_t *data = _zip_buffer_get(buffer, 2);
 
     if (data == NULL) {
@@ -261,8 +255,7 @@ _zip_buffer_put_16(zip_buffer_t *buffer, zip_uint16_t i)
 
 
 int
-_zip_buffer_put_32(zip_buffer_t *buffer, zip_uint32_t i)
-{
+_zip_buffer_put_32(zip_buffer_t *buffer, zip_uint32_t i) {
     zip_uint8_t *data = _zip_buffer_get(buffer, 4);
 
     if (data == NULL) {
@@ -279,8 +272,7 @@ _zip_buffer_put_32(zip_buffer_t *buffer, zip_uint32_t i)
 
 
 int
-_zip_buffer_put_64(zip_buffer_t *buffer, zip_uint64_t i)
-{
+_zip_buffer_put_64(zip_buffer_t *buffer, zip_uint64_t i) {
     zip_uint8_t *data = _zip_buffer_get(buffer, 8);
 
     if (data == NULL) {
@@ -301,8 +293,7 @@ _zip_buffer_put_64(zip_buffer_t *buffer, zip_uint64_t i)
 
 
 int
-_zip_buffer_put_8(zip_buffer_t *buffer, zip_uint8_t i)
-{
+_zip_buffer_put_8(zip_buffer_t *buffer, zip_uint8_t i) {
     zip_uint8_t *data = _zip_buffer_get(buffer, 1);
 
     if (data == NULL) {
@@ -316,8 +307,7 @@ _zip_buffer_put_8(zip_buffer_t *buffer, zip_uint8_t i)
 
 
 int
-_zip_buffer_set_offset(zip_buffer_t *buffer, zip_uint64_t offset)
-{
+_zip_buffer_set_offset(zip_buffer_t *buffer, zip_uint64_t offset) {
     if (offset > buffer->size) {
         buffer->ok = false;
         return -1;
@@ -342,7 +332,6 @@ _zip_buffer_skip(zip_buffer_t *buffer, zip_uint64_t length) {
 }
 
 zip_uint64_t
-_zip_buffer_size(zip_buffer_t *buffer)
-{
+_zip_buffer_size(zip_buffer_t *buffer) {
     return buffer->size;
 }