potatosalad
commented
6 years ago So, to make this work, my initial idea was to have a few structs like these to fit the different CRC models (code is incomplete, but should show the path I was thinking of):
typedef struct crc_params_s {
ERL_NIF_TERM key;
void *table;
uint8_t width;
uint64_t poly;
uint64_t init;
bool refin;
bool refout;
uint64_t xorout;
uint64_t check;
uint64_t residue;
char name[256];
} crc_params_t;
typedef struct crc_function_s {
int init(const void *params, void **context);
int fastupdate(void *context, const unsigned char *buf, size_t len);
int update(const void *old_context, void **new_context, const unsigned char *buf, size_t len);
int final(const void *context, ErlNifEnv *env, ERL_NIF_TERM *out_term);
} crc_function_t;
typedef struct crc_context_s {
const crc_params_t *params;
uint64_t value;
} crc_context_t;
int
crc_init(const void *params, void **context)
{
crc_context_t *c = (void *)enif_alloc_resource(crc_resource_type, sizeof(*c));
if (c == NULL) {
return -1;
}
c->params = (const crc_params_t *)params;
c->value = c->params->init;
*context = (void *)c;
return 0;
}
int
crc_fastupdate(void *context, const unsigned char *buf, size_t len)
{
crc_context_t *c = (void *)context;
uint64_t val = c->value;
if (c->params->table != NULL) {
while (len--) {
val = (val >> 8) ^ c->params->table[(val ^ (uint8_t)*buf++) & 0xFF];
}
c->value = val;
} else {
// the slower calculation here
}
return 0;
}
int
crc_update(const void *old_context, void **new_context, const unsigned char *buf, size_t len)
{
const crc_context_t *old_c = (const void *)old_context;
crc_context_t *new_c = (void *)enif_alloc_resource(crc_resource_type, sizeof(*new_c));
if (new_c == NULL) {
return -1;
}
(void)memcpy(new_c, old_c, sizeof(*new_c));
int retval = crc_fastupdate(new_c, buf, len);
if (retval != 0) {
(void)enif_release_resource((void *)new_c);
return retval;
}
*new_context = (void *)new_c;
return 0;
}
int
crc_final(const void *context, ErlNifEnv *env, ERL_NIF_TERM *out_term)
{
const crc_context_t *c = (const void *)context;
// reflect out or xorout if necessary
*out_term = enif_make_uint(env, c->value);
return 0;
}The reason I kept the context as void * is due to "not really CRC" functions like CRC-16/SICK.
Also, the difference between update and fastupdate is for immutable versus mutable operations on a context. To mirror how crypto works, crc_update/2 should return a new reference and leave the old one untouched. However, if we're slicing the input into multiple yields, we can get away with modifying the context in-place until it has been returned to the caller. In other words: once a reference has been returned to the caller, it probably should be considered immutable.
What do you think of that direction?
TattdCodeMonkey
Initially discussed in #11 under
Possible Improvementsimplementingcrc/2,crc_init/1,crc_update/2, andcrc_final/1will allow implementing new algorithms by just passing the required params tocrc_init/1and using the context provided with the other functions. This would allow reduction of C code to a single implementation, instead of separate files for different widths etc.