1 /* *********************************************************************

2 * This Original Work is copyright of 51 Degrees Mobile Experts Limited.

4 * Forbury Square, Reading, Berkshire, United Kingdom RG1 3EU.

5 *

6 * This Original Work is licensed under the European Union Public Licence

7 * (EUPL) v.1.2 and is subject to its terms as set out below.

8 *

9 * If a copy of the EUPL was not distributed with this file, You can obtain

10 * one at https://opensource.org/licenses/EUPL-1.2.

11 *

12 * The 'Compatible Licences' set out in the Appendix to the EUPL (as may be

13 * amended by the European Commission) shall be deemed incompatible for

14 * the purposes of the Work and the provisions of the compatibility

15 * clause in Article 5 of the EUPL shall not apply.

16 *

17 * If using the Work as, or as part of, a network application, by

18 * including the attribution notice(s) required under Article 5 of the EUPL

19 * in the end user terms of the application under an appropriate heading,

20 * such notice(s) shall fulfill the requirements of that article.

21 * ********************************************************************* */

22

23 #ifndef FIFTYONE_DEGREES_DATASET_H_INCLUDED

24 #define FIFTYONE_DEGREES_DATASET_H_INCLUDED

25

89 #include "exceptions.h"

90 #include "file.h"

91 #include "memory.h"

92 #include "resource.h"

93 #include "properties.h"

94 #include "headers.h"

95 #include "config.h"

96 #include "overrides.h"

97 #include "common.h"

98 #include "indices.h"

99

103 typedef struct fiftyone_degrees_dataset_base_t {

104 const char fileName[FIFTYONE_DEGREES_FILE_MAX_PATH];

111 const char masterFileName[FIFTYONE_DEGREES_FILE_MAX_PATH];

115 void *memoryToFree;

120 bool isInMemory;

122 fiftyoneDegreesFilePool filePool;

123 fiftyoneDegreesResourceHandle *handle;

125 fiftyoneDegreesPropertiesAvailable *available;

126 fiftyoneDegreesHeaders *uniqueHeaders;

127 fiftyoneDegreesOverridePropertyArray *overridable;

130 fiftyoneDegreesIndicesPropertyProfile* indexPropertyProfile;

134 const void *config;

135 } fiftyoneDegreesDataSetBase;

136

153 typedef fiftyoneDegreesStatusCode(*fiftyoneDegreesDataSetInitFromMemoryMethod)(

154 void *dataSet,

155 const void *config,

156 fiftyoneDegreesPropertiesRequired *properties,

157 void *memory,

158 fiftyoneDegreesFileOffset size,

159 fiftyoneDegreesException *exception);

160

180 typedef fiftyoneDegreesStatusCode(*fiftyoneDegreesDataSetInitFromFileMethod)(

181 void *dataSet,

182 const void *config,

183 fiftyoneDegreesPropertiesRequired *properties,

184 const char *fileName,

185 fiftyoneDegreesException *exception);

186

201 fiftyoneDegreesStatusCode fiftyoneDegreesDataSetInitProperties(

202 fiftyoneDegreesDataSetBase *dataSet,

203 fiftyoneDegreesPropertiesRequired *properties,

204 void *state,

205 fiftyoneDegreesPropertiesGetMethod getPropertyMethod,

206 fiftyoneDegreesEvidencePropertiesGetMethod getEvidencePropertiesMethod);

207

222 fiftyoneDegreesStatusCode fiftyoneDegreesDataSetInitHeaders(

223 fiftyoneDegreesDataSetBase *dataSet,

224 void *state,

225 fiftyoneDegreesHeadersGetMethod getHeaderMethod,

226 fiftyoneDegreesException* exception);

227

241 fiftyoneDegreesStatusCode fiftyoneDegreesDataSetInitFromFile(

242 fiftyoneDegreesDataSetBase *dataSet,

243 const char *fileName,

244 fiftyoneDegreesFileOffset bytesToCompare);

245

254 fiftyoneDegreesStatusCode fiftyoneDegreesDataSetInitInMemory(

255 fiftyoneDegreesDataSetBase *dataSet,

256 fiftyoneDegreesMemoryReader *reader);

257

262 void fiftyoneDegreesDataSetReset(fiftyoneDegreesDataSetBase *dataSet);

263

271 EXTERNAL fiftyoneDegreesDataSetBase* fiftyoneDegreesDataSetGet(

272 fiftyoneDegreesResourceManager *manager);

273

279 EXTERNAL void fiftyoneDegreesDataSetRelease(fiftyoneDegreesDataSetBase *dataSet);

280

286 void fiftyoneDegreesDataSetFree(fiftyoneDegreesDataSetBase *dataSet);

287

310 fiftyoneDegreesStatusCode fiftyoneDegreesDataSetReloadManagerFromMemory(

311 fiftyoneDegreesResourceManager *manager,

312 void *source,

313 fiftyoneDegreesFileOffset length,

314 size_t dataSetSize,

315 fiftyoneDegreesDataSetInitFromMemoryMethod initDataSet,

316 fiftyoneDegreesException *exception);

317

338 fiftyoneDegreesStatusCode fiftyoneDegreesDataSetReloadManagerFromFile(

339 fiftyoneDegreesResourceManager* manager,

340 const char *fileName,

341 size_t dataSetSize,

342 fiftyoneDegreesDataSetInitFromFileMethod initDataSet,

343 fiftyoneDegreesException *exception);

344

352 #define FIFTYONE_DEGREES_DATASET_RELOAD(t) \

353 \

371 fiftyoneDegreesStatusCode fiftyoneDegrees##t##ReloadManagerFromMemory( \

372 fiftyoneDegreesResourceManager *manager, \

373 void *source, \

374 fiftyoneDegreesFileOffset length, \

375 fiftyoneDegreesException *exception) { \

376 return fiftyoneDegreesDataSetReloadManagerFromMemory( \

377 manager, \

378 source, \

379 length, \

380 sizeof(DataSet##t), \

381 initDataSetFromMemory, \

382 exception); \

383 } \

384 \

400 fiftyoneDegreesStatusCode fiftyoneDegrees##t##ReloadManagerFromFile( \

401 fiftyoneDegreesResourceManager* manager, \

402 const char *fileName, \

403 fiftyoneDegreesException *exception) { \

404 return fiftyoneDegreesDataSetReloadManagerFromFile( \

405 manager, \

406 fileName, \

407 sizeof(DataSet##t), \

408 initDataSetFromFile, \

409 exception); \

410 } \

411 \

426 fiftyoneDegreesStatusCode fiftyoneDegrees##t##ReloadManagerFromOriginalFile( \

427 fiftyoneDegreesResourceManager* manager, \

428 fiftyoneDegreesException *exception) { \

429 fiftyoneDegreesStatusCode status = FIFTYONE_DEGREES_STATUS_NOT_SET; \

430 DataSet##t* dataSet = fiftyoneDegreesDataSet##t##Get(manager); \

431 status = fiftyoneDegrees##t##ReloadManagerFromFile( \

432 manager, \

433 dataSet->b.b.masterFileName, \

434 exception); \

435 fiftyoneDegreesDataSet##t##Release(dataSet); \

436 return status; \

437 }

438

443 #endif

fiftyoneDegreesDataSetBase::isInMemory

bool isInMemory

True if the data file has been read into continuous memory.

Definition: dataset.h:120

fiftyoneDegreesDataSetBase::filePool

fiftyoneDegreesFilePool filePool

Linked list of file readers.

Definition: dataset.h:122

fiftyoneDegreesDataSetInitProperties

fiftyoneDegreesStatusCode fiftyoneDegreesDataSetInitProperties(fiftyoneDegreesDataSetBase *dataSet, fiftyoneDegreesPropertiesRequired *properties, void *state, fiftyoneDegreesPropertiesGetMethod getPropertyMethod, fiftyoneDegreesEvidencePropertiesGetMethod getEvidencePropertiesMethod)

Initialises the properties in the data set.

fiftyoneDegreesStatusCode

Status returned from the initialisation of a resource.

Definition: status.h:77

fiftyoneDegreesDataSetBase::handle

fiftyoneDegreesResourceHandle * handle

Pointer to the handle that tracks this data set instance.

Definition: dataset.h:123

fiftyoneDegreesDataSetInitInMemory

fiftyoneDegreesStatusCode fiftyoneDegreesDataSetInitInMemory(fiftyoneDegreesDataSetBase *dataSet, fiftyoneDegreesMemoryReader *reader)

Initialses the data set from data stored in continuous memory.

fiftyoneDegreesDataSetBase::memoryToFree

void * memoryToFree

A pointer to the memory where the data within the data set is held.

Definition: dataset.h:115

fiftyoneDegreesDataSetReloadManagerFromMemory

fiftyoneDegreesStatusCode fiftyoneDegreesDataSetReloadManagerFromMemory(fiftyoneDegreesResourceManager *manager, void *source, fiftyoneDegreesFileOffset length, size_t dataSetSize, fiftyoneDegreesDataSetInitFromMemoryMethod initDataSet, fiftyoneDegreesException *exception)

Reload the data set being used by the resource manager using a data file loaded into contiguous memor...

fiftyoneDegreesDataSetInitHeaders

fiftyoneDegreesStatusCode fiftyoneDegreesDataSetInitHeaders(fiftyoneDegreesDataSetBase *dataSet, void *state, fiftyoneDegreesHeadersGetMethod getHeaderMethod, fiftyoneDegreesException *exception)

Initialises the HTTP headers in the data set.

fiftyoneDegreesDataSetFree

void fiftyoneDegreesDataSetFree(fiftyoneDegreesDataSetBase *dataSet)

Closes the data set by freeing anything which has been initialised at creation.

fiftyoneDegreesMemoryReader

Used to read data from memory in a similar manner to a file handle.

Definition: memory.h:54

fiftyoneDegreesEvidencePropertiesGetMethod

uint32_t(* fiftyoneDegreesEvidencePropertiesGetMethod)(void *state, fiftyoneDegreesPropertyAvailable *property, fiftyoneDegreesEvidenceProperties *evidenceProperties)

Populates the evidence properties structure with the indexes of the properties required by the proper...

Definition: properties.h:213

fiftyoneDegreesDataSetBase::indexPropertyProfile

fiftyoneDegreesIndicesPropertyProfile * indexPropertyProfile

Index to look up profile values by property.

Definition: dataset.h:130

fiftyoneDegreesDataSetBase::available

fiftyoneDegreesPropertiesAvailable * available

Available properties.

Definition: dataset.h:125

fiftyoneDegreesPropertiesGetMethod

const fiftyoneDegreesString *(* fiftyoneDegreesPropertiesGetMethod)(void *state, uint32_t index, fiftyoneDegreesCollectionItem *item)

Returns a string for the property at the index provided or NULL if there is no property available at ...

Definition: properties.h:195

fiftyoneDegreesDataSetReloadManagerFromFile

fiftyoneDegreesStatusCode fiftyoneDegreesDataSetReloadManagerFromFile(fiftyoneDegreesResourceManager *manager, const char *fileName, size_t dataSetSize, fiftyoneDegreesDataSetInitFromFileMethod initDataSet, fiftyoneDegreesException *exception)

Reload the data set being used by the resource manager using the data file location specified.

fiftyoneDegreesDataSetInitFromMemoryMethod

fiftyoneDegreesStatusCode(* fiftyoneDegreesDataSetInitFromMemoryMethod)(void *dataSet, const void *config, fiftyoneDegreesPropertiesRequired *properties, void *memory, fiftyoneDegreesFileOffset size, fiftyoneDegreesException *exception)

Initialses the data set from data stored in continuous memory.

Definition: dataset.h:153

fiftyoneDegreesHeaderArray

Array of Headers which should always be ordered in ascending order of fullHeaderId.

Definition: headers.h:167

fiftyoneDegreesPropertyAvailableArray

Array of items of type fiftyoneDegreesPropertyAvailable used to easily access and track the size of t...

Definition: properties.h:165

fiftyoneDegreesResourceHandle

Handle for a shared resource.

Definition: resource.h:157

fiftyoneDegreesDataSetBase::config

const void * config

Pointer to the config used to create the dataset.

Definition: dataset.h:134

fiftyoneDegreesDataSetBase::overridable

fiftyoneDegreesOverridePropertyArray * overridable

Array of properties that can be overridden.

Definition: dataset.h:127

fiftyoneDegreesDataSetInitFromFileMethod

fiftyoneDegreesStatusCode(* fiftyoneDegreesDataSetInitFromFileMethod)(void *dataSet, const void *config, fiftyoneDegreesPropertiesRequired *properties, const char *fileName, fiftyoneDegreesException *exception)

Initialses the data set from data stored on file.

Definition: dataset.h:180

fiftyoneDegreesIndicesPropertyProfile

Maps the profile index and the property index to the first value index of the profile for the propert...

Definition: indices.h:109

fiftyoneDegreesFileOffset

long fiftyoneDegreesFileOffset

Type for file offset in API.

Definition: fileOffset.h:69

fiftyoneDegreesPropertiesRequired

Defines a set of properties which are required by a caller.

Definition: properties.h:175

fiftyoneDegreesResourceManager

Manager structure used to provide access to a shared and changing resource.

Definition: resource.h:173

fiftyoneDegreesDataSetBase

Base data set structure which contains the 'must have's for all data sets.

Definition: dataset.h:103

fiftyoneDegreesDataSetReset

void fiftyoneDegreesDataSetReset(fiftyoneDegreesDataSetBase *dataSet)

Resets a newly allocated data set structure ready for initialisation.

fiftyoneDegreesDataSetGet

fiftyoneDegreesDataSetBase * fiftyoneDegreesDataSetGet(fiftyoneDegreesResourceManager *manager)

Gets a pointer to the active data set from a resource manager.

fiftyoneDegreesDataSetBase::uniqueHeaders

fiftyoneDegreesHeaders * uniqueHeaders

Related HTTP headers.

Definition: dataset.h:126

fiftyoneDegreesDataSetInitFromFile

fiftyoneDegreesStatusCode fiftyoneDegreesDataSetInitFromFile(fiftyoneDegreesDataSetBase *dataSet, const char *fileName, fiftyoneDegreesFileOffset bytesToCompare)

Initialses the data set from data stored on file.

fiftyoneDegreesException

Structure used to represent a 51Degrees exception and passed into methods that might generate excepti...

Definition: exceptions.h:111

fiftyoneDegreesFilePool

Stack of handles used to read data from a single source file.

Definition: file.h:229

fiftyoneDegreesDataSetRelease

void fiftyoneDegreesDataSetRelease(fiftyoneDegreesDataSetBase *dataSet)

Releases a reference to a data set which has been fetched via the DataSetGet method.

FIFTYONE_DEGREES_FILE_MAX_PATH

#define FIFTYONE_DEGREES_FILE_MAX_PATH

Define the max path length on the target system.

Definition: file.h:214

fiftyoneDegreesHeadersGetMethod

long(* fiftyoneDegreesHeadersGetMethod)(void *state, uint32_t index, fiftyoneDegreesCollectionItem *nameItem)

Gets the unique id and name of the header at the requested index.

Definition: headers.h:183

fiftyoneDegreesOverridePropertyArray

Array of items of type fiftyoneDegreesOverrideProperty used to easily access and track the size of th...

Definition: overrides.h:103

51Degrees Device Detection C/C++ 4.5

dataset.h