1

#ifndef HAVE_RETAIN

     2

#include <stdio.h>

     3

#include <stdint.h>

     4

#include <unistd.h>

     5

#include "iec_types.h"

     6

     7

int GetRetainSize();

     8

     9

/* Retain buffer.  */

    10

FILE *retain_buffer;

    11

const char rb_file[]      = "retain_buffer_file";

    12

const char rb_file_bckp[] = "retain_buffer_file.bak";

    13

    14

    15

/* Retain header struct.  */

    16

struct retain_info_t {

    17

	uint32_t retain_size;

    18

	uint32_t hash_size;

    19

	uint8_t* hash;

    20

	uint32_t header_offset;

    21

	uint32_t header_crc;

    22

};

    23

    24

/* Init retain info structure.  */

    25

struct retain_info_t retain_info;

    26

    27

/* CRC lookup table and initial state.  */

    28

uint32_t crc32_table[256];

    29

uint32_t retain_crc;

    30

    31

    32

/* Generate CRC32 lookup table.  */

    33

void GenerateCRC32Table(void)

    34

{

    35

	unsigned int i, j;

    36

	/* Use CRC-32-IEEE 802.3 polynomial 0x04C11DB7 (bit reflected).  */

    37

	uint32_t poly = 0xEDB88320;

    38

    39

	for (i = 0; i <= 0xFF; i++)

    40

	{

    41

		uint32_t c = i;

    42

		for (j = 0 ; j < 8 ; j++)

    43

			c = (c & 1) ? (c >> 1 ) ^ poly : (c >> 1);

    44

		crc32_table[i] = c;

    45

	}

    46

}

    47

    48

    49

/* Calculate CRC32 for len bytes from pointer buf with init starting value.  */

    50

uint32_t GenerateCRC32Sum(const void* buf, unsigned int len, uint32_t init)

    51

{

    52

	uint32_t crc = ~init;

    53

	unsigned char* current = (unsigned char*) buf;

    54

	while (len--)

    55

		crc = crc32_table[(crc ^ *current++) & 0xFF] ^ (crc >> 8);

    56

	return ~crc;

    57

}

    58

    59

/* Calc CRC32 for retain file byte by byte.  */

    60

int CheckFileCRC(FILE* file_buffer)

    61

{

    62

	/* Set the magic constant for one-pass CRC calc according to ZIP CRC32.  */

    63

	const uint32_t magic_number = 0x2144df1c;

    64

    65

	/* CRC initial state.  */

    66

	uint32_t calc_crc32 = 0;

    67

	char data_block = 0;

    68

    69

	while(!feof(file_buffer)){

    70

		if (fread(&data_block, sizeof(data_block), 1, file_buffer))

    71

			calc_crc32 = GenerateCRC32Sum(&data_block, sizeof(char), calc_crc32);

    72

	}

    73

    74

	/* Compare crc result with a magic number.  */

    75

	return (calc_crc32 == magic_number) ? 1 : 0;

    76

}

    77

    78

/* Compare current hash with hash from file byte by byte.  */

    79

int CheckFilehash(void)

    80

{

    81

	int k;

    82

	int offset = sizeof(retain_info.retain_size);

    83

    84

	rewind(retain_buffer);

    85

	fseek(retain_buffer, offset , SEEK_SET);

    86

    87

	uint32_t size;

    88

	fread(&size, sizeof(size), 1, retain_buffer);

    89

	if (size != retain_info.hash_size)

    90

		return 0;

    91

    92

	for(k = 0; k < retain_info.hash_size; k++){

    93

		uint8_t file_digit;

    94

		fread(&file_digit, sizeof(char), 1, retain_buffer);

    95

		if (file_digit != *(retain_info.hash+k))

    96

			return 0;

    97

	}

    98

    99

	return 1;

   100

}

   101

   102

void InitRetain(void)

   103

{

   104

	int i;

   105

   106

	/* Generate CRC32 lookup table.  */

   107

	GenerateCRC32Table();

   108

   109

	/* Get retain size in bytes */

   110

	retain_info.retain_size = GetRetainSize();

   111

   112

	/* Hash stored in retain file as array of char in hex digits

   113

	   (that's why we divide strlen in two).  */

   114

	retain_info.hash_size = PLC_ID ? strlen(PLC_ID)/2 : 0;

   115

	//retain_info.hash_size = 0;

   116

	retain_info.hash = malloc(retain_info.hash_size);

   117

   118

	/* Transform hash string into byte sequence.  */

   119

	for (i = 0; i < retain_info.hash_size; i++) {

   120

		int byte = 0;

   121

		sscanf((PLC_ID + i*2), "%02X", &byte);

   122

		retain_info.hash[i] = byte;

   123

	}

   124

   125

	/* Calc header offset.  */

   126

	retain_info.header_offset = sizeof(retain_info.retain_size) + \

   127

		sizeof(retain_info.hash_size) + \

   128

		retain_info.hash_size;

   129

   130

	/*  Set header CRC initial state.  */

   131

	retain_info.header_crc = 0;

   132

   133

	/* Calc crc for header.  */

   134

	retain_info.header_crc = GenerateCRC32Sum(

   135

		&retain_info.retain_size,

   136

		sizeof(retain_info.retain_size),

   137

		retain_info.header_crc);

   138

   139

	retain_info.header_crc = GenerateCRC32Sum(

   140

		&retain_info.hash_size,

   141

		sizeof(retain_info.hash_size),

   142

		retain_info.header_crc);

   143

   144

	retain_info.header_crc = GenerateCRC32Sum(

   145

		retain_info.hash,

   146

		retain_info.hash_size,

   147

		retain_info.header_crc);

   148

}

   149

   150

void CleanupRetain(void)

   151

{

   152

	/* Free hash memory.  */

   153

	free(retain_info.hash);

   154

}

   155

   156

int CheckRetainFile(const char * file)

   157

{

   158

	retain_buffer = fopen(file, "rb");

   159

	if (retain_buffer) {

   160

		/* Check CRC32 and hash.  */

   161

		if (CheckFileCRC(retain_buffer))

   162

			if (CheckFilehash())

   163

				return 1;

   164

		fclose(retain_buffer);

   165

		retain_buffer = NULL;

   166

	}

   167

	return 0;

   168

}

   169

   170

int CheckRetainBuffer(void)

   171

{

   172

	retain_buffer = NULL;

   173

	if (!retain_info.retain_size)

   174

		return 1;

   175

   176

	/* Check latest retain file.  */

   177

	if (CheckRetainFile(rb_file))

   178

		return 1;

   179

   180

	/* Check if we have backup.  */

   181

	if (CheckRetainFile(rb_file_bckp))

   182

		return 1;

   183

   184

	/* We don't have any valid retain buffer - nothing to remind.  */

   185

	return 0;

   186

}

   187

   188

#ifndef FILE_RETAIN_SAVE_PERIOD_S

   189

#define FILE_RETAIN_SAVE_PERIOD_S 1.0

   190

#endif

   191

   192

static double CalcDiffSeconds(IEC_TIME* t1, IEC_TIME *t2)

   193

{

   194

	IEC_TIME dt ={

   195

		t1->tv_sec  - t2->tv_sec,

   196

		t1->tv_nsec - t2->tv_nsec

   197

	};

   198

   199

	if ((dt.tv_nsec < -1000000000) || ((dt.tv_sec > 0) && (dt.tv_nsec < 0))){

   200

		dt.tv_sec--;

   201

		dt.tv_nsec += 1000000000;

   202

	}

   203

	if ((dt.tv_nsec > +1000000000) || ((dt.tv_sec < 0) && (dt.tv_nsec > 0))){

   204

		dt.tv_sec++;

   205

		dt.tv_nsec -= 1000000000;

   206

	}

   207

	return dt.tv_sec + 1e-9*dt.tv_nsec;

   208

}

   209

   210

   211

int RetainSaveNeeded(void)

   212

{

   213

	int ret = 0;

   214

	static IEC_TIME last_save;

   215

	IEC_TIME now;

   216

	double diff_s;

   217

   218

	/* no retain */

   219

	if (!retain_info.retain_size)

   220

		return 0;

   221

   222

	/* periodic retain flush to avoid high I/O load */

   223

	PLC_GetTime(&now);

   224

   225

	diff_s = CalcDiffSeconds(&now, &last_save);

   226

   227

	if ((diff_s > FILE_RETAIN_SAVE_PERIOD_S) || ForceSaveRetainReq()) {

   228

		ret = 1;

   229

		last_save = now;

   230

	}

   231

	return ret;

   232

}

   233

   234

void ValidateRetainBuffer(void)

   235

{

   236

	if (!retain_buffer)

   237

		return;

   238

   239

	/* Add retain data CRC to the end of buffer file.  */

   240

	fseek(retain_buffer, 0, SEEK_END);

   241

	fwrite(&retain_crc, sizeof(uint32_t), 1, retain_buffer);

   242

   243

	/* Sync file buffer and close file.  */

   244

#ifdef __WIN32

   245

	fflush(retain_buffer);

   246

#else

   247

	fsync(fileno(retain_buffer));

   248

#endif

   249

   250

	fclose(retain_buffer);

   251

	retain_buffer = NULL;

   252

}

   253

   254

void InValidateRetainBuffer(void)

   255

{

   256

	if (!RetainSaveNeeded())

   257

		return;

   258

   259

	/* Rename old retain file into *.bak if it exists.  */

   260

	rename(rb_file, rb_file_bckp);

   261

   262

	/* Set file CRC initial value.  */

   263

	retain_crc = retain_info.header_crc;

   264

   265

	/* Create new retain file.  */

   266

	retain_buffer = fopen(rb_file, "wb+");

   267

	if (!retain_buffer) {

   268

		fprintf(stderr, "Failed to create retain file : %s\n", rb_file);

   269

		return;

   270

	}

   271

   272

	/* Write header to the new file.  */

   273

	fwrite(&retain_info.retain_size,

   274

		sizeof(retain_info.retain_size), 1, retain_buffer);

   275

	fwrite(&retain_info.hash_size,

   276

		sizeof(retain_info.hash_size),   1, retain_buffer);

   277

	fwrite(retain_info.hash ,

   278

		sizeof(char), retain_info.hash_size, retain_buffer);

   279

}

   280

   281

void Retain(unsigned int offset, unsigned int count, void *p)

   282

{

   283

	if (!retain_buffer)

   284

		return;

   285

   286

	/* Generate CRC 32 for each data block.  */

   287

	retain_crc = GenerateCRC32Sum(p, count, retain_crc);

   288

   289

	/* Save current var in file.  */

   290

	fseek(retain_buffer, retain_info.header_offset+offset, SEEK_SET);

   291

	fwrite(p, count, 1, retain_buffer);

   292

}

   293

   294

void Remind(unsigned int offset, unsigned int count, void *p)

   295

{

   296

	/* Remind variable from file.  */

   297

	fseek(retain_buffer, retain_info.header_offset+offset, SEEK_SET);

   298

	fread((void *)p, count, 1, retain_buffer);

   299

}

   300

#endif // !HAVE_RETAIN