nikon/CANopenNode
1
0
Fork 0
Code Activity Actions
CANopenNode/socketCAN/CO_storageLinux.c

321 lines
9.5 KiB
C
Raw Blame History

/*
* CANopen Object Dictionary storage object for Linux SocketCAN.
*
* @file CO_storageLinux.c
* @author Janez Paternoster
* @copyright 2021 Janez Paternoster
*
* This file is part of CANopenNode, an opensource CANopen Stack.
* Project home page is <https://github.com/CANopenNode/CANopenNode>.
* For more information on CANopen see <http://www.can-cia.org/>.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "CO_storageLinux.h"
#include "301/crc16-ccitt.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#if (CO_CONFIG_STORAGE) & CO_CONFIG_STORAGE_ENABLE
/*
* Function for writing data on "Store parameters" command - OD object 1010
*
* For more information see file CO_storage.h, CO_storage_entry_t.
*/
static ODR_t storeLinux(void *object, void *addr, OD_size_t len) {
ODR_t ret = ODR_OK;
char *filename = object;
uint16_t crc_store;
/* Create names for temporary and old file */
size_t fn_len = strlen(filename) + 5;
char *filename_tmp = malloc(fn_len);
char *filename_old = malloc(fn_len);
if (filename_tmp == NULL || filename_old == NULL) {
ret = ODR_OUT_OF_MEM;
}
else {
strcpy(filename_tmp, filename);
strcpy(filename_old, filename);
strcat(filename_tmp, ".tmp");
strcat(filename_old, ".old");
}
/* Open a temporary file and write data to it */
if (ret == ODR_OK) {
FILE *fp = fopen(filename_tmp, "w");
if (fp == NULL) {
ret = ODR_HW;
}
else {
CO_LOCK_OD();
size_t cnt = fwrite(addr, 1, len, fp);
crc_store = crc16_ccitt(addr, len, 0);
CO_UNLOCK_OD();
cnt += fwrite(&crc_store, 1, sizeof(crc_store), fp);
fclose(fp);
if (cnt != (len + sizeof(crc_store))) {
ret = ODR_HW;
}
}
}
/* Verify data */
if (ret == ODR_OK) {
uint8_t *buf = NULL;
FILE *fp = NULL;
size_t cnt = 0;
uint16_t crc_verify, crc_read;
buf = malloc(len + 4);
if (buf != NULL) {
fp = fopen(filename_tmp, "r");
if (fp != NULL) {
cnt = fread(buf, 1, len + 4, fp);
crc_verify = crc16_ccitt(buf, len, 0);
fclose(fp);
memcpy(&crc_read, &buf[len], sizeof(crc_read));
}
free(buf);
}
/* If size or CRC differs, report error */
if (buf == NULL || fp == NULL || cnt != (len + sizeof(crc_verify))
|| crc_store != crc_verify || crc_store != crc_read
) {
ret = ODR_HW;
}
}
/* rename existing file to *.old and *.tmp to existing */
if (ret == ODR_OK) {
if (rename(filename, filename_old) != 0
|| rename(filename_tmp, filename) != 0
) {
ret = ODR_HW;
}
}
free(filename_tmp);
free(filename_old);
return ret;
}
/*
* Function for restoring data on "Restore default parameters" command - OD 1011
*
* For more information see file CO_storage.h, CO_storage_entry_t.
*/
static ODR_t restoreLinux(void *object, void *addr, OD_size_t len) {
(void) addr; (void) len;
char *filename = object;
ODR_t ret = ODR_OK;
/* Rename existing filename to *.old. */
char *filename_old = malloc(strlen(filename) + 5);
if (filename_old == NULL) {
ret = ODR_OUT_OF_MEM;
}
else {
strcpy(filename_old, filename);
strcat(filename_old, ".old");
rename(filename, filename_old);
free(filename_old);
}
/* create an empty file and write "-\n" to it. */
if (ret == ODR_OK) {
FILE *fp = fopen(filename, "w");
if (fp == NULL) {
ret = ODR_HW;
}
else {
fputs("-\n", fp);
fclose(fp);
}
}
return ret;
}
CO_ReturnError_t CO_storageLinux_entry_init(CO_storage_t *storage,
CO_storage_entry_t *newEntry,
void *addr,
OD_size_t len,
char *filename,
uint8_t subIndexOD)
{
/* verify arguments */
if (storage == NULL || newEntry == NULL || addr == NULL || len == 0
|| filename == NULL || subIndexOD < 1
) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}
/* configure newEntry and add it to the storage */
newEntry->addr = addr;
newEntry->len = len;
newEntry->object = filename;
newEntry->subIndexOD = subIndexOD;
newEntry->store = storeLinux;
newEntry->restore = restoreLinux;
CO_ReturnError_t ret;
FILE *fp = NULL;
uint8_t *buf = NULL;
/* Add newEntry to storage object */
ret = CO_storage_entry_init(storage, newEntry);
/* Open file, check existence and create temporary buffer */
if (ret == CO_ERROR_NO) {
fp = fopen(filename, "r");
if (fp == NULL) {
ret = CO_ERROR_DATA_CORRUPT;
}
else {
buf = malloc(len + 4);
if (buf == NULL) {
ret = CO_ERROR_OUT_OF_MEMORY;
}
}
}
/* Read data into temporary buffer first. Then verify and copy to addr */
if (ret == CO_ERROR_NO) {
size_t cnt = fread(buf, 1, len + 4, fp);
uint16_t crc1, crc2;
crc1 = crc16_ccitt(buf, len, 0);
memcpy(&crc2, &buf[len], sizeof(crc2));
if (cnt == 2 && buf[0] == '-') {
/* File is empty, default values will be used, no error */
}
else if (cnt != (len + sizeof(crc2)) || crc1 != crc2) {
/* Data length does not match */
ret = CO_ERROR_DATA_CORRUPT;
}
else {
/* no errors, copy data into Object dictionary */
memcpy(addr, buf, len);
}
}
if (buf != NULL) free(buf);
if (fp != NULL) fclose(fp);
return ret;
}
CO_ReturnError_t CO_storageLinux_auto_init(CO_storageLinux_auto_t *storageAuto,
void *addr,
OD_size_t len,
char *filename)
{
/* verify arguments */
if (storageAuto == NULL || addr == NULL || len == 0 || filename == NULL) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}
/* configure variables */
storageAuto->addr = addr;
storageAuto->len = len;
storageAuto->crc = 0;
bool_t readOK = false;
char *writeFileAccess = "w";
/* Open the file, read data into temporary buffer, verify them and copy them
* into addr. If file does not exist or data is corrupt, just skip reading
* and keep the default values. */
FILE *fp = fopen(filename, "r");
if (fp != NULL) {
uint8_t *buf = malloc(len + 4);
if (buf != NULL) {
size_t cnt = fread(buf, 1, len + 4, fp);
if (cnt == 2 && buf[0] == '-') {
/* File is empty, default values will be used, no error */
readOK = true;
}
else {
uint16_t crc1, crc2;
crc1 = crc16_ccitt(buf, len, 0);
memcpy(&crc2, &buf[len], sizeof(crc2));
if (crc1 == crc2 && cnt == (len + sizeof(crc2))) {
memcpy(addr, buf, len);
storageAuto->crc = crc1;
readOK = true;
writeFileAccess = "r+";
}
}
free(buf);
}
fclose(fp);
}
storageAuto->fp = fopen(filename, writeFileAccess);
if (storageAuto->fp == NULL) return CO_ERROR_ILLEGAL_ARGUMENT;
return readOK ? CO_ERROR_NO : CO_ERROR_DATA_CORRUPT;
}
bool_t CO_storageLinux_auto_process(CO_storageLinux_auto_t *storageAuto,
bool_t closeFile)
{
bool_t ret = false;
/* verify arguments */
if (storageAuto == NULL || storageAuto->fp == NULL) {
return ret;
}
/* If CRC of the current data differs, save the file */
uint16_t crc = crc16_ccitt(storageAuto->addr, storageAuto->len, 0);
if (crc == storageAuto->crc) {
ret = true;
}
else {
size_t cnt;
rewind(storageAuto->fp);
CO_LOCK_OD();
cnt = fwrite(storageAuto->addr, 1, storageAuto->len, storageAuto->fp);
CO_UNLOCK_OD();
cnt += fwrite(&crc, 1, sizeof(crc), storageAuto->fp);
fflush(storageAuto->fp);
if (cnt == (storageAuto->len + sizeof(crc))) {
storageAuto->crc = crc;
ret = true;
}
}
if (closeFile) {
fclose(storageAuto->fp);
storageAuto->fp = NULL;
}
return ret;
}
#endif /* (CO_CONFIG_STORAGE) & CO_CONFIG_STORAGE_ENABLE */
View git blame Copy permalink