1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
/*
* Copyright (c) 2018-2021, ARM Limited and Contributors. All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#include <assert.h>
#include <errno.h>
#include <string.h>
#include <common/debug.h>
#include <common/tf_crc32.h>
#include <lib/utils.h>
#include <tf_gunzip.h>
#include "zutil.h"
/*
* memory allocated by malloc() is supposed to be aligned for any built-in type
*/
#define ZALLOC_ALIGNMENT sizeof(void *)
static uintptr_t zalloc_start;
static uintptr_t zalloc_end;
static uintptr_t zalloc_current;
static void * ZLIB_INTERNAL zcalloc(void *opaque, unsigned int items,
unsigned int size)
{
uintptr_t p, p_end;
size *= items;
p = round_up(zalloc_current, ZALLOC_ALIGNMENT);
p_end = p + size;
if (p_end > zalloc_end)
return NULL;
memset((void *)p, 0, size);
zalloc_current = p_end;
return (void *)p;
}
static void ZLIB_INTERNAL zfree(void *opaque, void *ptr)
{
}
/*
* gunzip - decompress gzip data
* @in_buf: source of compressed input. Upon exit, the end of input.
* @in_len: length of in_buf
* @out_buf: destination of decompressed output. Upon exit, the end of output.
* @out_len: length of out_buf
* @work_buf: workspace
* @work_len: length of workspace
*/
int gunzip(uintptr_t *in_buf, size_t in_len, uintptr_t *out_buf,
size_t out_len, uintptr_t work_buf, size_t work_len)
{
z_stream stream;
int zret, ret;
zalloc_start = work_buf;
zalloc_end = work_buf + work_len;
zalloc_current = zalloc_start;
stream.next_in = (typeof(stream.next_in))*in_buf;
stream.avail_in = in_len;
stream.next_out = (typeof(stream.next_out))*out_buf;
stream.avail_out = out_len;
stream.zalloc = zcalloc;
stream.zfree = zfree;
stream.opaque = (voidpf)0;
zret = inflateInit(&stream);
if (zret != Z_OK) {
ERROR("zlib: inflate init failed (ret = %d)\n", zret);
return (zret == Z_MEM_ERROR) ? -ENOMEM : -EIO;
}
zret = inflate(&stream, Z_NO_FLUSH);
if (zret == Z_STREAM_END) {
ret = 0;
} else {
if (stream.msg)
ERROR("%s\n", stream.msg);
ERROR("zlib: inflate failed (ret = %d)\n", zret);
ret = (zret == Z_MEM_ERROR) ? -ENOMEM : -EIO;
}
VERBOSE("zlib: %lu byte input\n", stream.total_in);
VERBOSE("zlib: %lu byte output\n", stream.total_out);
*in_buf = (uintptr_t)stream.next_in;
*out_buf = (uintptr_t)stream.next_out;
inflateEnd(&stream);
return ret;
}
/* Wrapper function to calculate CRC
* @crc: previous accumulated CRC
* @buf: buffer base address
* @size: size of the buffer
*
* Return calculated CRC32 value
*/
uint32_t tf_crc32(uint32_t crc, const unsigned char *buf, size_t size)
{
return (uint32_t)crc32((unsigned long)crc, buf, size);
}
|
