1

/*

     2

  This file is part of Beremiz, a Integrated Development Environment for

     3

  programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     4

     5

  See COPYING.runtime

     6

     7

  Copyright (C) 2018: Sergey Surkov <surkov.sv@summatechnology.ru>

     8

  Copyright (C) 2018: Andrey Skvortsov <andrej.skvortzov@gmail.com>

     9

    10

*/

    11

    12

#ifndef HAVE_RETAIN

    13

#include <stdio.h>

    14

#include <stdint.h>

    15

#include <unistd.h>

    16

#include "iec_types.h"

    17

    18

int GetRetainSize(void);

    19

    20

/* Retain buffer.  */

    21

FILE *retain_buffer;

    22

const char rb_file[]      = "retain_buffer_file";

    23

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

    24

    25

    26

/* Retain header struct.  */

    27

struct retain_info_t {

    28

	uint32_t retain_size;

    29

	uint32_t hash_size;

    30

	uint8_t* hash;

    31

	uint32_t header_offset;

    32

	uint32_t header_crc;

    33

};

    34

    35

/* Init retain info structure.  */

    36

struct retain_info_t retain_info;

    37

    38

/* CRC lookup table and initial state.  */

    39

uint32_t crc32_table[256];

    40

uint32_t retain_crc;

    41

    42

    43

/* Generate CRC32 lookup table.  */

    44

void GenerateCRC32Table(void)

    45

{

    46

	unsigned int i, j;

    47

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

    48

	uint32_t poly = 0xEDB88320;

    49

    50

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

    51

	{

    52

		uint32_t c = i;

    53

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

    54

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

    55

		crc32_table[i] = c;

    56

	}

    57

}

    58

    59

    60

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

    61

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

    62

{

    63

	uint32_t crc = ~init;

    64

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

    65

	while (len--)

    66

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

    67

	return ~crc;

    68

}

    69

    70

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

    71

int CheckFileCRC(FILE* file_buffer)

    72

{

    73

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

    74

	const uint32_t magic_number = 0x2144df1c;

    75

    76

	/* CRC initial state.  */

    77

	uint32_t calc_crc32 = 0;

    78

	char data_block = 0;

    79

    80

	while(!feof(file_buffer)){

    81

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

    82

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

    83

	}

    84

    85

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

    86

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

    87

}

    88

    89

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

    90

int CheckFilehash(void)

    91

{

    92

	int k;

    93

	int offset = sizeof(retain_info.retain_size);

    94

    95

	rewind(retain_buffer);

    96

	fseek(retain_buffer, offset , SEEK_SET);

    97

    98

	uint32_t size;

    99

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

   100

	if (size != retain_info.hash_size)

   101

		return 0;

   102

   103

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

   104

		uint8_t file_digit;

   105

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

   106

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

   107

			return 0;

   108

	}

   109

   110

	return 1;

   111

}

   112

   113

void InitRetain(void)

   114

{

   115

	int i;

   116

   117

	/* Generate CRC32 lookup table.  */

   118

	GenerateCRC32Table();

   119

   120

	/* Get retain size in bytes */

   121

	retain_info.retain_size = GetRetainSize();

   122

   123

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

   124

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

   125

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

   126

	//retain_info.hash_size = 0;

   127

	retain_info.hash = malloc(retain_info.hash_size);

   128

   129

	/* Transform hash string into byte sequence.  */

   130

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

   131

		int byte = 0;

   132

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

   133

		retain_info.hash[i] = byte;

   134

	}

   135

   136

	/* Calc header offset.  */

   137

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

   138

		sizeof(retain_info.hash_size) + \

   139

		retain_info.hash_size;

   140

   141

	/*  Set header CRC initial state.  */

   142

	retain_info.header_crc = 0;

   143

   144

	/* Calc crc for header.  */

   145

	retain_info.header_crc = GenerateCRC32Sum(

   146

		&retain_info.retain_size,

   147

		sizeof(retain_info.retain_size),

   148

		retain_info.header_crc);

   149

   150

	retain_info.header_crc = GenerateCRC32Sum(

   151

		&retain_info.hash_size,

   152

		sizeof(retain_info.hash_size),

   153

		retain_info.header_crc);

   154

   155

	retain_info.header_crc = GenerateCRC32Sum(

   156

		retain_info.hash,

   157

		retain_info.hash_size,

   158

		retain_info.header_crc);

   159

}

   160

   161

void CleanupRetain(void)

   162

{

   163

	/* Free hash memory.  */

   164

	free(retain_info.hash);

   165

}

   166

   167

int CheckRetainFile(const char * file)

   168

{

   169

	retain_buffer = fopen(file, "rb");

   170

	if (retain_buffer) {

   171

		/* Check CRC32 and hash.  */

   172

		if (CheckFileCRC(retain_buffer))

   173

			if (CheckFilehash())

   174

				return 1;

   175

		fclose(retain_buffer);

   176

		retain_buffer = NULL;

   177

	}

   178

	return 0;

   179

}

   180

   181

int CheckRetainBuffer(void)

   182

{

   183

	retain_buffer = NULL;

   184

	if (!retain_info.retain_size)

   185

		return 1;

   186

   187

	/* Check latest retain file.  */

   188

	if (CheckRetainFile(rb_file))

   189

		return 1;

   190

   191

	/* Check if we have backup.  */

   192

	if (CheckRetainFile(rb_file_bckp))

   193

		return 1;

   194

   195

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

   196

	return 0;

   197

}

   198

   199

#ifndef FILE_RETAIN_SAVE_PERIOD_S

   200

#define FILE_RETAIN_SAVE_PERIOD_S 1.0

   201

#endif

   202

   203

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

   204

{

   205

	IEC_TIME dt ={

   206

		t1->tv_sec  - t2->tv_sec,

   207

		t1->tv_nsec - t2->tv_nsec

   208

	};

   209

   210

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

   211

		dt.tv_sec--;

   212

		dt.tv_nsec += 1000000000;

   213

	}

   214

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

   215

		dt.tv_sec++;

   216

		dt.tv_nsec -= 1000000000;

   217

	}

   218

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

   219

}

   220

   221

   222

int RetainSaveNeeded(void)

   223

{

   224

	int ret = 0;

   225

	static IEC_TIME last_save;

   226

	IEC_TIME now;

   227

	double diff_s;

   228

   229

	/* no retain */

   230

	if (!retain_info.retain_size)

   231

		return 0;

   232

   233

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

   234

	PLC_GetTime(&now);

   235

   236

	diff_s = CalcDiffSeconds(&now, &last_save);

   237

   238

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

   239

		ret = 1;

   240

		last_save = now;

   241

	}

   242

	return ret;

   243

}

   244

   245

void ValidateRetainBuffer(void)

   246

{

   247

	if (!retain_buffer)

   248

		return;

   249

   250

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

   251

	fseek(retain_buffer, 0, SEEK_END);

   252

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

   253

   254

	/* Sync file buffer and close file.  */

   255

#ifdef __WIN32

   256

	fflush(retain_buffer);

   257

#else

   258

	fsync(fileno(retain_buffer));

   259

#endif

   260

   261

	fclose(retain_buffer);

   262

	retain_buffer = NULL;

   263

}

   264

   265

void InValidateRetainBuffer(void)

   266

{

   267

	if (!RetainSaveNeeded())

   268

		return;

   269

   270

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

   271

	rename(rb_file, rb_file_bckp);

   272

   273

	/* Set file CRC initial value.  */

   274

	retain_crc = retain_info.header_crc;

   275

   276

	/* Create new retain file.  */

   277

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

   278

	if (!retain_buffer) {

   279

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

   280

		return;

   281

	}

   282

   283

	/* Write header to the new file.  */

   284

	fwrite(&retain_info.retain_size,

   285

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

   286

	fwrite(&retain_info.hash_size,

   287

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

   288

	fwrite(retain_info.hash ,

   289

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

   290

}

   291

   292

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

   293

{

   294

	if (!retain_buffer)

   295

		return;

   296

   297

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

   298

	retain_crc = GenerateCRC32Sum(p, count, retain_crc);

   299

   300

	/* Save current var in file.  */

   301

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

   302

	fwrite(p, count, 1, retain_buffer);

   303

}

   304

   305

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

   306

{

   307

	/* Remind variable from file.  */

   308

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

   309

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

   310

}

   311

#endif // !HAVE_RETAIN