1/*
2 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
3 * Copyright 2011, Oliver Tappe <zooey@hirschkaefer.de>
4 * Distributed under the terms of the MIT License.
5 */
6#ifndef _PACKAGE__HPKG__PRIVATE__READER_IMPL_BASE_H_
7#define _PACKAGE__HPKG__PRIVATE__READER_IMPL_BASE_H_
8
9
10#include <SupportDefs.h>
11
12#include <util/SinglyLinkedList.h>
13
14#include <package/hpkg/PackageAttributeValue.h>
15#include <package/hpkg/PackageContentHandler.h>
16#include <package/hpkg/PackageInfoAttributeValue.h>
17
18
19namespace BPackageKit {
20
21namespace BHPKG {
22
23
24class BErrorOutput;
25
26
27namespace BPrivate {
28
29
30class ReaderImplBase {
31protected:
32								ReaderImplBase(
33									BErrorOutput* errorOutput);
34	virtual						~ReaderImplBase();
35
36	virtual	status_t			Init(int fd, bool keepFD);
37
38			int					FD() const;
39
40			BErrorOutput*		ErrorOutput() const;
41
42protected:
43			struct AttributeHandlerContext {
44				BErrorOutput*	errorOutput;
45				union {
46					BPackageContentHandler*			packageContentHandler;
47					BLowLevelPackageContentHandler*	lowLevelHandler;
48				};
49				bool			hasLowLevelHandler;
50
51				uint64			heapOffset;
52				uint64			heapSize;
53
54				BHPKGPackageSectionID	section;
55
56				AttributeHandlerContext(BErrorOutput* errorOutput,
57					BPackageContentHandler* packageContentHandler,
58					BHPKGPackageSectionID section);
59
60				AttributeHandlerContext(BErrorOutput* errorOutput,
61					BLowLevelPackageContentHandler* lowLevelHandler,
62					BHPKGPackageSectionID section);
63
64				void ErrorOccurred();
65			};
66
67
68			typedef BPackageAttributeValue AttributeValue;
69
70			struct AttributeHandler
71				: SinglyLinkedListLinkImpl<AttributeHandler> {
72				virtual ~AttributeHandler();
73
74				void SetLevel(int level);
75				virtual status_t HandleAttribute(
76					AttributeHandlerContext* context, uint8 id,
77					const AttributeValue& value, AttributeHandler** _handler);
78
79				virtual status_t Delete(AttributeHandlerContext* context);
80
81			protected:
82				int	fLevel;
83			};
84
85
86			struct IgnoreAttributeHandler : AttributeHandler {
87			};
88
89
90			struct PackageVersionAttributeHandler : AttributeHandler {
91				PackageVersionAttributeHandler(
92					BPackageInfoAttributeValue& packageInfoValue,
93					BPackageVersionData& versionData, bool notify);
94
95				virtual status_t HandleAttribute(
96					AttributeHandlerContext* context, uint8 id,
97					const AttributeValue& value, AttributeHandler** _handler);
98
99				virtual status_t Delete(AttributeHandlerContext* context);
100
101			private:
102				BPackageInfoAttributeValue&	fPackageInfoValue;
103				BPackageVersionData&		fPackageVersionData;
104				bool						fNotify;
105			};
106
107
108			struct PackageResolvableAttributeHandler : AttributeHandler {
109				PackageResolvableAttributeHandler(
110					BPackageInfoAttributeValue& packageInfoValue);
111
112				virtual status_t HandleAttribute(
113					AttributeHandlerContext* context, uint8 id,
114					const AttributeValue& value, AttributeHandler** _handler);
115
116				virtual status_t Delete(AttributeHandlerContext* context);
117
118			private:
119				BPackageInfoAttributeValue&	fPackageInfoValue;
120			};
121
122
123			struct PackageResolvableExpressionAttributeHandler
124				: AttributeHandler {
125				PackageResolvableExpressionAttributeHandler(
126					BPackageInfoAttributeValue& packageInfoValue);
127
128				virtual status_t HandleAttribute(
129					AttributeHandlerContext* context, uint8 id,
130					const AttributeValue& value, AttributeHandler** _handler);
131
132				virtual status_t Delete(AttributeHandlerContext* context);
133
134			private:
135				BPackageInfoAttributeValue&	fPackageInfoValue;
136			};
137
138
139			struct PackageAttributeHandler : AttributeHandler {
140				virtual status_t HandleAttribute(
141					AttributeHandlerContext* context, uint8 id,
142					const AttributeValue& value, AttributeHandler** _handler);
143
144			private:
145				BPackageInfoAttributeValue	fPackageInfoValue;
146			};
147
148
149			struct LowLevelAttributeHandler : AttributeHandler {
150				LowLevelAttributeHandler();
151				LowLevelAttributeHandler(uint8 id,
152					const BPackageAttributeValue& value, void* parentToken,
153					void* token);
154
155				virtual status_t HandleAttribute(
156					AttributeHandlerContext* context, uint8 id,
157					const AttributeValue& value, AttributeHandler** _handler);
158				virtual status_t Delete(AttributeHandlerContext* context);
159
160			private:
161				void*			fParentToken;
162				void*			fToken;
163				uint8			fID;
164				AttributeValue	fValue;
165			};
166
167
168			struct SectionInfo {
169				uint32			compression;
170				uint32			compressedLength;
171				uint32			uncompressedLength;
172				uint8*			data;
173				uint64			offset;
174				uint64			currentOffset;
175				uint64			stringsLength;
176				uint64			stringsCount;
177				char**			strings;
178				const char*		name;
179
180				SectionInfo(const char* _name)
181					:
182					data(NULL),
183					strings(NULL),
184					name(_name)
185				{
186				}
187
188				~SectionInfo()
189				{
190					delete[] strings;
191					delete[] data;
192				}
193			};
194
195			typedef SinglyLinkedList<AttributeHandler> AttributeHandlerList;
196
197protected:
198			const char*			CheckCompression(
199									const SectionInfo& section) const;
200
201			status_t			ParseStrings();
202
203			status_t			ParsePackageAttributesSection(
204									AttributeHandlerContext* context,
205									AttributeHandler* rootAttributeHandler);
206			status_t			ParseAttributeTree(
207									AttributeHandlerContext* context,
208									bool& _sectionHandled);
209
210	virtual	status_t			ReadAttributeValue(uint8 type, uint8 encoding,
211									AttributeValue& _value);
212
213			status_t			ReadUnsignedLEB128(uint64& _value);
214
215			status_t			ReadBuffer(off_t offset, void* buffer,
216									size_t size);
217			status_t			ReadCompressedBuffer(
218									const SectionInfo& section);
219
220	inline	AttributeHandler*	CurrentAttributeHandler() const;
221	inline	void				PushAttributeHandler(
222									AttributeHandler* handler);
223	inline	AttributeHandler*	PopAttributeHandler();
224	inline	void				ClearAttributeHandlerStack();
225
226	inline	SectionInfo*		CurrentSection();
227	inline	void				SetCurrentSection(SectionInfo* section);
228
229protected:
230			SectionInfo			fPackageAttributesSection;
231
232private:
233			status_t			_ParseAttributeTree(
234									AttributeHandlerContext* context);
235
236	template<typename Type>
237	inline	status_t			_Read(Type& _value);
238
239			status_t			_ReadSectionBuffer(void* buffer, size_t size);
240
241			status_t			_ReadAttribute(uint8& _id,
242									AttributeValue& _value,
243									bool* _hasChildren = NULL,
244									uint64* _tag = NULL);
245
246			status_t			_ReadString(const char*& _string,
247									size_t* _stringLength = NULL);
248
249private:
250			BErrorOutput*		fErrorOutput;
251			int					fFD;
252			bool				fOwnsFD;
253
254			SectionInfo*		fCurrentSection;
255
256			AttributeHandlerList fAttributeHandlerStack;
257
258			uint8*				fScratchBuffer;
259			size_t				fScratchBufferSize;
260};
261
262
263inline int
264ReaderImplBase::FD() const
265{
266	return fFD;
267}
268
269
270inline BErrorOutput*
271ReaderImplBase::ErrorOutput() const
272{
273	return fErrorOutput;
274}
275
276
277ReaderImplBase::SectionInfo*
278ReaderImplBase::CurrentSection()
279{
280	return fCurrentSection;
281}
282
283
284void
285ReaderImplBase::SetCurrentSection(SectionInfo* section)
286{
287	fCurrentSection = section;
288}
289
290
291template<typename Type>
292status_t
293ReaderImplBase::_Read(Type& _value)
294{
295	return _ReadSectionBuffer(&_value, sizeof(Type));
296}
297
298
299inline ReaderImplBase::AttributeHandler*
300ReaderImplBase::CurrentAttributeHandler() const
301{
302	return fAttributeHandlerStack.Head();
303}
304
305
306inline void
307ReaderImplBase::PushAttributeHandler(AttributeHandler* handler)
308{
309	fAttributeHandlerStack.Add(handler);
310}
311
312
313inline ReaderImplBase::AttributeHandler*
314ReaderImplBase::PopAttributeHandler()
315{
316	return fAttributeHandlerStack.RemoveHead();
317}
318
319
320inline void
321ReaderImplBase::ClearAttributeHandlerStack()
322{
323	fAttributeHandlerStack.MakeEmpty();
324}
325
326
327}	// namespace BPrivate
328
329}	// namespace BHPKG
330
331}	// namespace BPackageKit
332
333
334#endif	// _PACKAGE__HPKG__PRIVATE__READER_IMPL_BASE_H_
335