Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision
Loading items

Target

Select target project
  • anders_blomdell/labcomm
  • klaren/labcomm
  • tommyo/labcomm
  • erikj/labcomm
  • sven/labcomm
5 results
Select Git revision
Loading items
Show changes
Show whitespace changes
Inline Side-by-side
Showing
with 0 additions and 2402 deletions
lib/c/2014/labcomm2014.c deleted 100644 → 0
View file @ 1f17be8a
/*
labcomm2014.c -- runtime for handling encoding and decoding of
labcomm2014 samples.
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef LABCOMM_COMPAT
#include LABCOMM_COMPAT
#else
#include <stdio.h>
#include <strings.h>
#endif
#include <errno.h>
#include <string.h>
#include <stdarg.h>
#include <stddef.h>
#include "labcomm2014.h"
#include "labcomm2014_private.h"
#include "labcomm2014_ioctl.h"
#include "labcomm2014_dynamic_buffer_writer.h"
/* Unwrapping reader/writer functions */
#define UNWRAP_ac(rw, ac, ...) ac
#define UNWRAP(func, ...) \
while (1) { \
if (UNWRAP_ac(__VA_ARGS__)->action->func) { \
return UNWRAP_ac(__VA_ARGS__)->action->func(__VA_ARGS__); } \
if (UNWRAP_ac(__VA_ARGS__)->next == NULL) { return -ENOSYS; } \
UNWRAP_ac( __VA_ARGS__) = UNWRAP_ac(__VA_ARGS__)->next; \
}
int labcomm2014_reader_alloc(struct labcomm2014_reader *r,
struct labcomm2014_reader_action_context *action_context)
{
UNWRAP(alloc, r, action_context);
}
int labcomm2014_reader_free(struct labcomm2014_reader *r,
struct labcomm2014_reader_action_context *action_context)
{
UNWRAP(free, r, action_context);
}
int labcomm2014_reader_start(struct labcomm2014_reader *r,
struct labcomm2014_reader_action_context *action_context,
int local_index, int remote_index,
const struct labcomm2014_signature *signature,
void *value)
{
UNWRAP(start, r, action_context, local_index, remote_index, signature, value);
}
int labcomm2014_reader_end(struct labcomm2014_reader *r,
struct labcomm2014_reader_action_context *action_context)
{
UNWRAP(end, r, action_context);
}
int labcomm2014_reader_fill(struct labcomm2014_reader *r,
struct labcomm2014_reader_action_context *action_context)
{
UNWRAP(fill, r, action_context);
}
int labcomm2014_reader_ioctl(struct labcomm2014_reader *r,
struct labcomm2014_reader_action_context *action_context,
int local_index, int remote_index,
const struct labcomm2014_signature *signature,
uint32_t ioctl_action, va_list args)
{
UNWRAP(ioctl, r, action_context,
local_index, remote_index, signature, ioctl_action, args);
}
int labcomm2014_writer_alloc(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
UNWRAP(alloc, w, action_context);
}
int labcomm2014_writer_free(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
UNWRAP(free, w, action_context);
}
int labcomm2014_writer_start(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context,
int index, const struct labcomm2014_signature *signature,
void *value)
{
UNWRAP(start, w, action_context, index, signature, value);
}
int labcomm2014_writer_end(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
UNWRAP(end, w, action_context);
}
int labcomm2014_writer_flush(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
UNWRAP(flush, w, action_context);
}
int labcomm2014_writer_ioctl(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context,
int index,
const struct labcomm2014_signature *signature,
uint32_t ioctl_action, va_list args)
{
UNWRAP(ioctl, w, action_context, index, signature, ioctl_action, args);
}
#undef UNWRAP
#undef UNWRAP_ac
static const char *labcomm2014_error_string[] = {
#define LABCOMM2014_ERROR(name, description) description ,
#include "labcomm2014_error.h"
#undef LABCOMM2014_ERROR
};
static const int labcomm2014_error_string_count = (sizeof(labcomm2014_error_string) /
sizeof(labcomm2014_error_string[0]));
const char *labcomm2014_error_get_str(enum labcomm2014_error error_id)
{
const char *error_str = NULL;
// Check if this is a known error ID.
if (error_id < labcomm2014_error_string_count) {
error_str = labcomm2014_error_string[error_id];
}
return error_str;
}
void labcomm20142014_on_error_fprintf(enum labcomm2014_error error_id, size_t nbr_va_args, ...)
{
#ifndef LABCOMM_NO_STDIO
const char *err_msg = labcomm2014_error_get_str(error_id); // The final string to print.
if (err_msg == NULL) {
err_msg = "Error with an unknown error ID occured.";
}
fprintf(stderr, "%s\n", err_msg);
if (nbr_va_args > 0) {
va_list arg_pointer;
va_start(arg_pointer, nbr_va_args);
fprintf(stderr, "%s\n", "Extra info {");
char *print_format = va_arg(arg_pointer, char *);
vfprintf(stderr, print_format, arg_pointer);
fprintf(stderr, "}\n");
va_end(arg_pointer);
}
#else
; // If labcomm2014 can't be compiled with stdio the user will have to make an own error callback functionif he/she needs error reporting.
#endif
}
#if 0
static void dump(void *p, int size, int first, int last)
{
int i, j;
printf("%d %d (%p): ", first, last, p);
for (i = first ; i < last ; i++) {
for (j = 0 ; j < size ; j++) {
printf("%2.2d", ((char*)p)[(i-first)*size + j]);
}
printf(" ");
}
printf("\n");
}
#endif
void *labcomm2014_signature_array_ref(struct labcomm2014_memory *memory,
int *first, int *last, void **data,
int size, int index)
{
if (*first == 0 && *last == 0) {
*first = index;
*last = index + 1;
*data = labcomm2014_memory_alloc(memory, 0, size);
if (*data) {
memset(*data, 0, size);
}
} else if (index < *first || *last <= index) {
void *old_data = *data;
int old_first = *first;
int old_last = *last;
int n;
*first = (index<old_first)?index:old_first;
*last = (old_last<=index)?index+1:old_last;
n = (*last - *first);
*data = labcomm2014_memory_alloc(memory, 0, n * size);
if (*data) {
memset(*data, 0, n * size);
memcpy(*data + (old_first - *first) * size,
old_data,
(old_last - old_first) * size);
}
// dump(old_data, size, old_first, old_last);
labcomm2014_memory_free(memory, 0, old_data);
}
if (*data) {
// dump(*data, size, *first, *last);
return *data + (index - *first) * size;
} else {
return NULL;
}
}
static int local_index = LABCOMM_USER;
void labcomm2014_set_local_index(struct labcomm2014_signature *signature)
{
if (signature->index != 0) {
labcomm2014_error_fatal_global(LABCOMM2014_ERROR_SIGNATURE_ALREADY_SET,
"Signature already set: %s\n", signature->name);
}
signature->index = local_index;
local_index++;
}
int labcomm2014_get_local_index(const struct labcomm2014_signature *signature)
{
if (signature->index == 0) {
labcomm2014_error_fatal_global(LABCOMM2014_ERROR_SIGNATURE_NOT_SET,
"Signature not set: %s\n", signature->name);
}
return signature->index;
}
int labcomm2014_get_local_type_index(const struct labcomm2014_signature *signature)
{
return labcomm2014_get_local_index(signature);
}
int labcomm2014_internal_sizeof(const struct labcomm2014_signature *signature,
void *v)
{
int length = signature->encoded_size(v);
return (labcomm2014_size_packed32(signature->index) +
labcomm2014_size_packed32(length) +
length);
}
lib/c/2014/labcomm2014.h deleted 100644 → 0
View file @ 1f17be8a
/*
labcomm2014.h -- user interface for handling encoding and decoding of
labcomm2014 samples.
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __LABCOMM_H__
#define __LABCOMM_H__
#include <stdarg.h>
#ifdef LABCOMM_COMPAT
#include LABCOMM_COMPAT
#else
#include <stdint.h>
#include <unistd.h>
#endif
#include "labcomm2014_error.h"
#include "labcomm2014_scheduler.h"
/* Forward declaration */
struct labcomm2014_encoder;
struct labcomm2014_decoder;
#include "labcomm2014_type_signature.h"
/*
* Error handling.
*/
/* The callback prototype for error handling.
* First parameter is the error ID.
* The second paramters is the number of va_args that comes after this
* one. If none it should be 0.
* Optionaly other paramters can be supplied depending on what is needed
* for this error ID.
*/
typedef void (*labcomm2014_error_handler_callback)(enum labcomm2014_error error_id,
size_t nbr_va_args, ...);
/* Default error handler, prints message to stderr.
* Extra info about the error can be supplied as char* as VA-args. Especially user defined errors should supply a describing string. if nbr_va_args > 1 the first variable argument must be a printf format string and the possibly following arguments are passed as va_args to vprintf.
*/
void labcomm20142014_on_error_fprintf(enum labcomm2014_error error_id, size_t nbr_va_args, ...);
/* Register a callback for the error handler for this encoder. */
void labcomm2014_register_error_handler_encoder(struct labcomm2014_encoder *encoder, labcomm2014_error_handler_callback callback);
/* Register a callback for the error handler for this decoder. */
void labcomm2014_register_error_handler_decoder(struct labcomm2014_decoder *decoder, labcomm2014_error_handler_callback callback);
/* Get a string describing the supplied standrad labcomm2014 error. */
const char *labcomm2014_error_get_str(enum labcomm2014_error error_id);
typedef int (*labcomm2014_handle_new_datatype_callback)(
struct labcomm2014_decoder *decoder,
struct labcomm2014_signature *sig);
/*
* Dynamic memory handling
* lifetime == 0 memory that will live for as long as the
* encoder/decoder or that are allocated/deallocated
* during the communication setup phase
* otherwise memory will live for approximately this number of
* sent/received samples
*/
struct labcomm2014_memory;
void *labcomm2014_memory_alloc(struct labcomm2014_memory *m, int lifetime, size_t size);
void *labcomm2014_memory_realloc(struct labcomm2014_memory *m, int lifetime,
void *ptr, size_t size);
void labcomm2014_memory_free(struct labcomm2014_memory *m, int lifetime, void *ptr);
/*
* Decoder
*/
struct labcomm2014_reader;
struct labcomm2014_decoder *labcomm2014_decoder_new(
struct labcomm2014_reader *reader,
struct labcomm2014_error_handler *error,
struct labcomm2014_memory *memory,
struct labcomm2014_scheduler *scheduler);
void labcomm2014_decoder_free(
struct labcomm2014_decoder *decoder);
int labcomm2014_decoder_decode_one(
struct labcomm2014_decoder *decoder);
void labcomm2014_decoder_run(
struct labcomm2014_decoder *decoder);
int labcomm2014_decoder_sample_ref_register(
struct labcomm2014_decoder *decoder,
const struct labcomm2014_signature *signature);
/* See labcomm2014_ioctl.h for predefined ioctl_action values */
int labcomm2014_decoder_ioctl(struct labcomm2014_decoder *decoder,
uint32_t ioctl_action,
...);
/*
* Encoder
*/
struct labcomm2014_writer;
struct labcomm2014_encoder *labcomm2014_encoder_new(
struct labcomm2014_writer *writer,
struct labcomm2014_error_handler *error,
struct labcomm2014_memory *memory,
struct labcomm2014_scheduler *scheduler);
void labcomm2014_encoder_free(
struct labcomm2014_encoder *encoder);
int labcomm2014_encoder_sample_ref_register(
struct labcomm2014_encoder *encoder,
const struct labcomm2014_signature *signature);
/* See labcomm2014_ioctl.h for predefined ioctl_action values */
int labcomm2014_encoder_ioctl(struct labcomm2014_encoder *encoder,
uint32_t ioctl_action,
...);
#define LABCOMM_VOID ((void*)1)
#endif
lib/c/2014/labcomm2014_compat_arm_cortexm3.h deleted 100644 → 0
View file @ 1f17be8a
#ifndef ARM_CORTEXM3_CODESOURCERY
#error "ARM_CORTEXM3_CODESOURCERY" not defined
#endif
#include <machine/endian.h>
lib/c/2014/labcomm2014_compat_osx.h deleted 100644 → 0
View file @ 1f17be8a
#ifndef __APPLE__
#error "__APPLE__" not defined
#endif
#ifndef LABCOMM_COMPAT_OSX
#define LABCOMM_COMPAT_OSX
#include <machine/endian.h>
#include <stdio.h>
#include <time.h>
#include <mach/clock.h>
#include <mach/mach.h>
#define CLOCK_REALTIME 0
static inline void clock_gettime(int garbage, struct timespec *ts)
{
(void) garbage;
clock_serv_t cclock;
mach_timespec_t mts;
host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
clock_get_time(cclock, &mts);
mach_port_deallocate(mach_task_self(), cclock);
ts->tv_sec = mts.tv_sec;
ts->tv_nsec = mts.tv_nsec;
}
#endif
lib/c/2014/labcomm2014_compat_vxworks.h deleted 100644 → 0
View file @ 1f17be8a
#ifndef _LABCOMM_COMPAT_VXWORKS_H_
#define _LABCOMM_COMPAT_VXWORKS_H_
#ifndef __VXWORKS__
#error "__VXWORKS__" not defined
#endif
#include <types/vxTypes.h>
#include <selectLib.h>
#include <types.h>
#include <timers.h>
#include <stdio.h>
#include <private/stdioP.h>
#ifdef __INT64_MAX__
#undef INT64_MAX
#define INT64_MAX __INT64_MAX__
#endif
#if (CPU == PPC603)
#undef _LITTLE_ENDIAN
#endif
#if (CPU == PENTIUM4)
#undef _BIG_ENDIAN
#endif
extern unsigned int cpuFrequency;
#endif
lib/c/2014/labcomm2014_decoder.c deleted 100644 → 0
View file @ 1f17be8a
/*
labcomm2014_decoder.c -- runtime for handling decoding of labcomm2014 samples.
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define CURRENT_VERSION "LabComm2014"
#include <errno.h>
#include "labcomm2014.h"
#include "labcomm2014_private.h"
#include "labcomm2014_ioctl.h"
#include "labcomm2014_dynamic_buffer_writer.h"
#ifdef DEBUG
#define DEBUG_FPRINTF(str, ...) fprintf(str, ##__VA_ARGS__)
#else
#define DEBUG_FPRINTF(str, ...)
#endif
#ifdef DECODER_DEBUG
#define DECODER_DEBUG_FPRINTF(str, ...) fprintf(str, ##__VA_ARGS__)
#else
#define DECODER_DEBUG_FPRINTF(str, ...)
#endif
struct sample_entry {
int remote_index;
const struct labcomm2014_signature *signature;
labcomm2014_decoder_function decode;
labcomm2014_handler_function handler;
void *context;
};
struct labcomm2014_decoder {
struct labcomm2014_reader *reader;
int reader_allocated;
int version_ok;
struct labcomm2014_error_handler *error;
struct labcomm2014_memory *memory;
struct labcomm2014_scheduler *scheduler;
labcomm2014_error_handler_callback on_error;
labcomm2014_handle_new_datatype_callback on_new_datatype;
LABCOMM_SIGNATURE_ARRAY_DEF(local, struct sample_entry);
LABCOMM_SIGNATURE_ARRAY_DEF(remote_to_local, int);
LABCOMM_SIGNATURE_ARRAY_DEF(local_ref, const struct labcomm2014_signature *);
LABCOMM_SIGNATURE_ARRAY_DEF(remote_to_local_ref, int);
};
struct labcomm2014_decoder *labcomm2014_decoder_new(
struct labcomm2014_reader *reader,
struct labcomm2014_error_handler *error,
struct labcomm2014_memory *memory,
struct labcomm2014_scheduler *scheduler)
{
struct labcomm2014_decoder *result;
result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
if (result) {
result->reader = reader;
result->reader->decoder = result;
result->reader->data = 0;
result->reader->data_size = 0;
result->reader->count = 0;
result->reader->pos = 0;
result->reader->error = 0;
result->reader_allocated = 0;
result->version_ok = 0;
result->error = error;
result->memory = memory;
result->scheduler = scheduler;
result->on_error = labcomm20142014_on_error_fprintf;
LABCOMM_SIGNATURE_ARRAY_INIT(result->local, struct sample_entry);
LABCOMM_SIGNATURE_ARRAY_INIT(result->remote_to_local, int);
LABCOMM_SIGNATURE_ARRAY_INIT(result->local_ref,
const struct labcomm2014_signature*);
LABCOMM_SIGNATURE_ARRAY_INIT(result->remote_to_local_ref, int);
}
return result;
}
void labcomm2014_decoder_free(struct labcomm2014_decoder* d)
{
struct labcomm2014_memory *memory = d->memory;
labcomm2014_reader_free(d->reader, d->reader->action_context);
LABCOMM_SIGNATURE_ARRAY_FREE(memory, d->local, struct sample_entry);
LABCOMM_SIGNATURE_ARRAY_FREE(memory, d->remote_to_local, int);
LABCOMM_SIGNATURE_ARRAY_FREE(memory, d->local_ref,
const struct labcomm2014_signature*);
LABCOMM_SIGNATURE_ARRAY_FREE(memory, d->remote_to_local_ref, int);
labcomm2014_memory_free(memory, 0, d);
}
static int handle_sample_def(struct labcomm2014_decoder *d, int remote_index,
const struct labcomm2014_signature *signature)
{
int result;
int i;
const struct labcomm2014_signature *local_signature = NULL;
int local_index = 0;
labcomm2014_scheduler_data_lock(d->scheduler);
LABCOMM_SIGNATURE_ARRAY_FOREACH(d->local, struct sample_entry, i) {
struct sample_entry *s;
int *remote_to_local;
result = -ENOENT;
s = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
d->local, struct sample_entry, i);
if (s->signature &&
s->signature->size == signature->size &&
strcmp(s->signature->name, signature->name) == 0 &&
memcmp((void*)s->signature->signature, (void*)signature->signature,
signature->size) == 0) {
s->remote_index = remote_index;
local_signature = s->signature;
local_index = i;
remote_to_local = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
d->remote_to_local, int,
remote_index);
*remote_to_local = i;
result = remote_index;
break;
}
}
labcomm2014_scheduler_data_unlock(d->scheduler);
if (local_signature) {
labcomm2014_reader_start(d->reader, d->reader->action_context,
local_index, remote_index, local_signature,
NULL);
labcomm2014_reader_end(d->reader, d->reader->action_context);
}
return result;
}
static int handle_sample_ref(struct labcomm2014_decoder *d, int remote_index,
const struct labcomm2014_signature *signature)
{
int result;
int i;
labcomm2014_scheduler_data_lock(d->scheduler);
LABCOMM_SIGNATURE_ARRAY_FOREACH(d->local_ref, const struct labcomm2014_signature *, i) {
const struct labcomm2014_signature *s;
int *remote_to_local_ref;
result = -ENOENT;
s = LABCOMM_SIGNATURE_ARRAY_GET(d->local_ref, const struct labcomm2014_signature *, i, 0);
if (s &&
s->signature &&
s->size == signature->size &&
strcmp(s->name, signature->name) == 0 &&
memcmp((void*)s->signature, (void*)signature->signature, signature->size) == 0) {
remote_to_local_ref = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
d->remote_to_local_ref, int,
remote_index);
*remote_to_local_ref = i;
result = remote_index;
break;
}
}
labcomm2014_scheduler_data_unlock(d->scheduler);
return result;
}
static int decoder_skip(struct labcomm2014_decoder *d, int len, int tag)
{
int i;
DECODER_DEBUG_FPRINTF(stdout, "got tag 0x%x, skipping %d bytes\n", tag, len);
for(i = 0; i <len; i++){
DECODER_DEBUG_FPRINTF(stderr, ".");
labcomm2014_read_byte(d->reader);
if (d->reader->error < 0) {
DECODER_DEBUG_FPRINTF(stderr, "\nerror while skipping: %d\n", d->reader->error);
return d->reader->error;
}
}
DECODER_DEBUG_FPRINTF(stderr, "\n");
return tag;
}
static int decode_sample_def_or_ref(struct labcomm2014_decoder *d, int kind)
{
int result;
struct labcomm2014_signature signature;
int i, remote_index;
remote_index = labcomm2014_read_packed32(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto out;
}
signature.name = labcomm2014_read_string(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto out;
}
signature.size = labcomm2014_read_packed32(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto free_signature_name;
}
signature.signature = labcomm2014_memory_alloc(d->memory, 1, signature.size);
if (d->reader->error < 0) {
result = d->reader->error;
goto free_signature_name;
}
for (i = 0 ; i < signature.size ; i++) {
signature.signature[i] = labcomm2014_read_byte(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto free_signature_signature;
}
}
switch (kind) {
case LABCOMM_SAMPLE_DEF: {
result = handle_sample_def(d, remote_index, &signature);
break;
}
case LABCOMM_SAMPLE_REF: {
result = handle_sample_ref(d, remote_index, &signature);
if (result == -ENOENT) {
/* Dummy value to silently continue */
result = LABCOMM_SAMPLE_REF;
}
break;
}
default:
result = -EINVAL;
}
free_signature_signature:
labcomm2014_memory_free(d->memory, 1, signature.signature);
free_signature_name:
labcomm2014_memory_free(d->memory, 0, signature.name);
out:
return result;
}
struct call_handler_context {
struct labcomm2014_reader *reader;
int local_index;
int remote_index;
const struct labcomm2014_signature *signature;
labcomm2014_handler_function handler;
void *context;
};
static void call_handler(void *value, void *context)
{
struct call_handler_context *wrap = context;
if (wrap->reader->error >= 0) {
labcomm2014_reader_start(wrap->reader, wrap->reader->action_context,
wrap->local_index, wrap->remote_index, wrap->signature,
value);
wrap->handler(value, wrap->context);
labcomm2014_reader_end(wrap->reader, wrap->reader->action_context);
}
}
static void reader_alloc(struct labcomm2014_decoder *d)
{
if (!d->reader_allocated) {
d->reader_allocated = 1;
labcomm2014_reader_alloc(d->reader, d->reader->action_context);
}
}
/* d - decoder to read from
registry - decoder to lookup signatures (registry != d only if
nesting decoders, e.g., when decoding pragma)
len - length of the labcomm2014 packet )
*/
static int decode_pragma(struct labcomm2014_decoder *d,
struct labcomm2014_decoder *registry,
int len)
{
char *pragma_type;
int result;
pragma_type = labcomm2014_read_string(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto out;
}
int bytes = labcomm2014_size_string(pragma_type);
int psize = len-bytes;
result = decoder_skip(d, psize, LABCOMM_PRAGMA);
out:
return result;
}
static labcomm2014_decoder_function lookup_h(struct labcomm2014_decoder *d,
struct call_handler_context *wrap,
int remote_index,
int **local_index)
{
labcomm2014_decoder_function do_decode = NULL;
labcomm2014_scheduler_data_lock(d->scheduler);
*local_index = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
d->remote_to_local, int,
remote_index);
if (**local_index != 0) {
struct sample_entry *entry;
entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
d->local, struct sample_entry,
**local_index);
wrap->local_index = **local_index;
wrap->signature = entry->signature;
wrap->handler = entry->handler;
wrap->context = entry->context;
do_decode = entry->decode;
}
labcomm2014_scheduler_data_unlock(d->scheduler);
return do_decode;
}
/* d - decoder to read from
registry - decoder to lookup signatures (registry != d only if
nesting decoders, e.g., when decoding pragma)
remote_index - received type index )
*/
static int decode_and_handle(struct labcomm2014_decoder *d,
struct labcomm2014_decoder *registry,
int remote_index)
{
int result;
int *local_index;
struct call_handler_context wrap = {
.reader = d->reader,
.remote_index = remote_index,
.signature = NULL,
.handler = NULL,
.context = NULL,
};
labcomm2014_decoder_function do_decode = lookup_h(registry, &wrap, remote_index, &local_index);
result = *local_index;
if (do_decode) {
do_decode(d->reader, call_handler, &wrap);
if (d->reader->error < 0) {
result = d->reader->error;
}
} else {
result = -ENOENT;
}
return result;
}
int labcomm2014_decoder_decode_one(struct labcomm2014_decoder *d)
{
int result, remote_index, length;
reader_alloc(d);
remote_index = labcomm2014_read_packed32(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto out;
}
length = labcomm2014_read_packed32(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto out;
}
if (remote_index == LABCOMM_VERSION) {
char *version = labcomm2014_read_string(d->reader);
if (d->reader->error < 0) {
result = d->reader->error;
goto out;
}
if (strcmp(version, CURRENT_VERSION) == 0) {
result = LABCOMM_VERSION;
d->version_ok = 1;
} else {
result = -ECONNRESET;
}
labcomm2014_memory_free(d->memory, 1, version);
} else if (! d->version_ok) {
DEBUG_FPRINTF(stderr, "No VERSION %d %d\n", remote_index, length);
result = -ECONNRESET;
} else if (remote_index == LABCOMM_SAMPLE_DEF) {
result = decode_sample_def_or_ref(d, LABCOMM_SAMPLE_DEF);
} else if (remote_index == LABCOMM_SAMPLE_REF) {
result = decode_sample_def_or_ref(d, LABCOMM_SAMPLE_REF);
} else if (remote_index == LABCOMM_TYPE_DEF) {
result = decode_and_handle(d, d, remote_index);
if(result == -ENOENT) {
//No handler for type_defs, skip
result = decoder_skip(d, length, remote_index);
}
} else if (remote_index == LABCOMM_TYPE_BINDING) {
result = decode_and_handle(d, d, remote_index);
if(result == -ENOENT) {
//No handler for type_bindings, skip
result = decoder_skip(d, length, remote_index);
}
} else if (remote_index == LABCOMM_PRAGMA) {
result = decode_pragma(d, d, length);
} else if (remote_index < LABCOMM_USER) {
DECODER_DEBUG_FPRINTF(stderr, "SKIP %d %d\n", remote_index, length);
result = decoder_skip(d, length, remote_index);
} else {
result = decode_and_handle(d, d, remote_index);
}
out:
return result;
}
void labcomm2014_decoder_run(struct labcomm2014_decoder *d)
{
while (labcomm2014_decoder_decode_one(d) > 0) {
}
}
int labcomm2014_decoder_ioctl(struct labcomm2014_decoder *d,
uint32_t action,
...)
{
int result;
va_list va;
va_start(va, action);
result = labcomm2014_reader_ioctl(d->reader,
d->reader->action_context,
0, 0, NULL, action, va);
va_end(va);
return result;
}
int labcomm2014_decoder_sample_ref_register(
struct labcomm2014_decoder *d,
const struct labcomm2014_signature *signature)
{
int local_index, *remote_to_local_ref;
const struct labcomm2014_signature **s;
local_index = labcomm2014_get_local_index(signature);
if (local_index <= 0) { goto out; }
labcomm2014_scheduler_data_lock(d->scheduler);
s = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
d->local_ref,
const struct labcomm2014_signature*, local_index);
if (s == NULL) { local_index = -ENOMEM; goto unlock; };
if (*s) { goto unlock; }
*s = signature;
remote_to_local_ref = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
d->remote_to_local_ref,
int, local_index);
*remote_to_local_ref = 0;
unlock:
labcomm2014_scheduler_data_unlock(d->scheduler);
out:
return local_index;
}
int labcomm2014_internal_decoder_ioctl(struct labcomm2014_decoder *d,
const struct labcomm2014_signature *signature,
uint32_t action, va_list va)
{
int result;
int local_index, remote_index;
local_index = labcomm2014_get_local_index(signature);
labcomm2014_scheduler_data_lock(d->scheduler);
remote_index = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
d->local,
struct sample_entry,
local_index)->remote_index;
labcomm2014_scheduler_data_unlock(d->scheduler);
result = labcomm2014_reader_ioctl(d->reader, d->reader->action_context,
local_index, remote_index,
signature, action, va);
return result;
}
#ifndef LABCOMM_NO_TYPEDECL
//// Code for allowing user code to handle type_defs
//// (should perhaps be moved to another file)
static void decode_raw_type_def(
struct labcomm2014_reader *r,
void (*handle)(
struct labcomm2014_raw_type_def *v,
void *context
),
void *context
)
{
struct labcomm2014_raw_type_def v;
v.index = labcomm2014_read_packed32(r);
if (r->error < 0) { goto out; }
v.name = labcomm2014_read_string(r);
if (r->error < 0) { goto free_name; }
v.length = labcomm2014_read_packed32(r);
if (r->error < 0) { goto free_name; }
int i;
v.signature_data = labcomm2014_memory_alloc(r->memory, 1, v.length);
if(v.signature_data) {
for(i=0; i<v.length; i++) {
v.signature_data[i] = labcomm2014_read_byte(r);
if (r->error < 0) { goto free_sig; }
}
handle(&v, context);
}
free_sig:
labcomm2014_memory_free(r->memory, 1, v.signature_data);
free_name:
labcomm2014_memory_free(r->memory, 1, v.name);
out:
return;
}
int labcomm2014_decoder_register_labcomm2014_type_def(
struct labcomm2014_decoder *d,
void (*handler)(
struct labcomm2014_raw_type_def *v,
void *context
),
void *context
)
{
int tag = LABCOMM_TYPE_DEF;
struct sample_entry *entry;
int *remote_to_local;
labcomm2014_scheduler_data_lock(d->scheduler);
entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
d->local, struct sample_entry,
tag);
if (entry == NULL) { tag = -ENOMEM; goto unlock; }
entry->remote_index = tag;
entry->signature = NULL;
entry->decode = (labcomm2014_decoder_function) decode_raw_type_def;
entry->handler =(labcomm2014_handler_function) handler;
entry->context = context;
remote_to_local = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
d->remote_to_local, int,
tag);
*remote_to_local = tag;
unlock:
labcomm2014_scheduler_data_unlock(d->scheduler);
return tag;
}
static void decode_type_binding(
struct labcomm2014_reader *r,
void (*handle)(
struct labcomm2014_type_binding *v,
void *context
),
void *context
)
{
struct labcomm2014_type_binding v;
v.sample_index = labcomm2014_read_packed32(r);
if (r->error < 0) { goto out; }
v.type_index = labcomm2014_read_packed32(r);
if (r->error < 0) { goto out; }
handle(&v, context);
out:
return;
}
int labcomm2014_decoder_register_labcomm2014_type_binding(
struct labcomm2014_decoder *d,
void (*handler)(
struct labcomm2014_type_binding *v,
void *context
),
void *context
)
{
int tag = LABCOMM_TYPE_BINDING;
struct sample_entry *entry;
int *remote_to_local;
labcomm2014_scheduler_data_lock(d->scheduler);
entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
d->local, struct sample_entry,
tag);
if (entry == NULL) { tag = -ENOMEM; goto unlock; }
entry->remote_index = tag;
entry->signature = NULL;
entry->decode = (labcomm2014_decoder_function) decode_type_binding;
entry->handler =(labcomm2014_handler_function) handler;
entry->context = context;
remote_to_local = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
d->remote_to_local, int,
tag);
*remote_to_local = tag;
unlock:
labcomm2014_scheduler_data_unlock(d->scheduler);
return tag;
}
//// End type_def handling
#endif
int labcomm2014_internal_decoder_register(
struct labcomm2014_decoder *d,
const struct labcomm2014_signature *signature,
labcomm2014_decoder_function decode,
labcomm2014_handler_function handler,
void *context)
{
int local_index;
struct sample_entry *entry;
reader_alloc(d);
local_index = labcomm2014_get_local_index(signature);
if (local_index <= 0) { goto out; }
labcomm2014_reader_start(d->reader, d->reader->action_context,
local_index, 0, signature,
NULL);
labcomm2014_reader_end(d->reader, d->reader->action_context);
labcomm2014_scheduler_data_lock(d->scheduler);
entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
d->local, struct sample_entry,
local_index);
if (entry == NULL) { local_index = -ENOMEM; goto unlock; }
entry->remote_index = 0;
entry->signature = signature;
entry->decode = decode;
entry->handler = handler;
entry->context = context;
unlock:
labcomm2014_scheduler_data_unlock(d->scheduler);
out:
return local_index;
}
const struct labcomm2014_signature *labcomm2014_internal_decoder_index_to_signature(
struct labcomm2014_decoder *d, int index)
{
const struct labcomm2014_signature *result = 0;
int local_index;
labcomm2014_scheduler_data_lock(d->scheduler);
local_index = LABCOMM_SIGNATURE_ARRAY_GET(d->remote_to_local_ref,
int, index, 0);
if (local_index) {
result = LABCOMM_SIGNATURE_ARRAY_GET(d->local_ref,
const struct labcomm2014_signature*,
local_index, 0);
}
labcomm2014_scheduler_data_unlock(d->scheduler);
return result;
}
lib/c/2014/labcomm2014_default_error_handler.c deleted 100644 → 0
View file @ 1f17be8a
/*
test_default_error_handler.c -- LabComm default error handler
Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "labcomm2014.h"
struct labcomm2014_error_handler *labcomm2014_default_error_handler = NULL;
lib/c/2014/labcomm2014_default_error_handler.h deleted 100644 → 0
View file @ 1f17be8a
/*
test_default_error_handler.h -- LabComm default error handler
Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __LABCOMM2014_DEFAULT_ERROR_HANDLER_H__
#define __LABCOMM2014_DEFAULT_ERROR_HANDLER_H__
#include "labcomm2014.h"
extern struct labcomm2014_error_handler *labcomm2014_default_error_handler;
#endif
lib/c/2014/labcomm2014_default_memory.c deleted 100644 → 0
View file @ 1f17be8a
/*
test_default_memory.c -- LabComm default memory allocator
Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include "labcomm2014.h"
#include "labcomm2014_private.h"
void *default_alloc(struct labcomm2014_memory *m, int lifetime, size_t size)
{
return malloc(size);
}
void *default_realloc(struct labcomm2014_memory *m, int lifetime,
void *ptr, size_t size)
{
return realloc(ptr, size);
}
void default_free(struct labcomm2014_memory *m, int lifetime, void *ptr)
{
free(ptr);
}
struct labcomm2014_memory memory = {
.alloc = default_alloc,
.realloc = default_realloc,
.free = default_free,
.context = NULL
};
struct labcomm2014_memory *labcomm2014_default_memory = &memory;
lib/c/2014/labcomm2014_default_memory.h deleted 100644 → 0
View file @ 1f17be8a
/*
test_default_memory.h -- LabComm default memory allocator
Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __LABCOMM2014_DEFAULT_MEMORY_H__
#define __LABCOMM2014_DEFAULT_MEMORY_H__
#include <stdlib.h>
#include "labcomm2014.h"
extern struct labcomm2014_memory *labcomm2014_default_memory;
#endif
lib/c/2014/labcomm2014_default_scheduler.c deleted 100644 → 0
View file @ 1f17be8a
/*
test_default_scheduler.c -- LabComm default scheduler
Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#include "labcomm2014_default_scheduler.h"
#include "labcomm2014_scheduler.h"
#include "labcomm2014_scheduler_private.h"
static int scheduler_free(struct labcomm2014_scheduler *s)
{
fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
"not implemented");
exit(1);
return 0;
}
static int scheduler_writer_lock(struct labcomm2014_scheduler *s)
{
return 0;
}
static int scheduler_writer_unlock(struct labcomm2014_scheduler *s)
{
return 0;
}
static int scheduler_data_lock(struct labcomm2014_scheduler *s)
{
return 0;
}
static int scheduler_data_unlock(struct labcomm2014_scheduler *s)
{
return 0;
}
static struct labcomm2014_time *scheduler_now(struct labcomm2014_scheduler *s)
{
fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
"not implemented");
exit(1);
return NULL;
}
static int scheduler_sleep(struct labcomm2014_scheduler *s,
struct labcomm2014_time *t)
{
fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
"not implemented");
exit(1);
return 0;
}
static int scheduler_wakeup(struct labcomm2014_scheduler *s)
{
fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
"not implemented");
exit(1);
return 0;
}
static int scheduler_enqueue(struct labcomm2014_scheduler *s,
uint32_t delay,
void (*deferred)(void *context),
void *context)
{
fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
"not implemented");
exit(1);
return 0;
}
static const struct labcomm2014_scheduler_action scheduler_action = {
.free = scheduler_free,
.writer_lock = scheduler_writer_lock,
.writer_unlock = scheduler_writer_unlock,
.data_lock = scheduler_data_lock,
.data_unlock = scheduler_data_unlock,
.now = scheduler_now,
.sleep = scheduler_sleep,
.wakeup = scheduler_wakeup,
.enqueue = scheduler_enqueue
};
static struct labcomm2014_scheduler scheduler = {
.action = &scheduler_action,
.context = NULL
};
struct labcomm2014_scheduler *labcomm2014_default_scheduler = &scheduler;
lib/c/2014/labcomm2014_default_scheduler.h deleted 100644 → 0
View file @ 1f17be8a
/*
test_default_scheduler.h -- LabComm default scheduler
Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __LABCOMM2014_DEFAULT_SCHEDULER_H__
#define __LABCOMM2014_DEFAULT_SCHEDULER_H__
#include "labcomm2014.h"
extern struct labcomm2014_scheduler *labcomm2014_default_scheduler;
#endif
lib/c/2014/labcomm2014_dynamic_buffer_writer.c deleted 100644 → 0
View file @ 1f17be8a
/*
labcomm2014_dynamic_buffer_writer.c -- LabComm dynamic memory writer.
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <errno.h>
#include <stdlib.h>
#include <stdarg.h>
#include "labcomm2014.h"
#include "labcomm2014_private.h"
#include "labcomm2014_ioctl.h"
#include "labcomm2014_dynamic_buffer_writer.h"
static int dyn_alloc(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
w->data_size = 1000;
w->count = w->data_size;
w->data = labcomm2014_memory_alloc(w->memory, 1, w->data_size);
if (w->data == NULL) {
w->error = -ENOMEM;
}
w->pos = 0;
return w->error;
}
static int dyn_free(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
labcomm2014_memory_free(w->memory, 1, w->data);
w->data = 0;
w->data_size = 0;
w->count = 0;
w->pos = 0;
labcomm2014_memory_free(w->memory, 0, action_context->context);
return 0;
}
static int dyn_start(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context,
int index,
const struct labcomm2014_signature *signature,
void *value)
{
void *tmp;
w->data_size = 1000;
w->count = w->data_size;
tmp = labcomm2014_memory_realloc(w->memory, 1, w->data, w->data_size);
if (tmp != NULL) {
w->data = tmp;
w->error = 0;
} else {
w->error = -ENOMEM;
}
w->pos = 0;
return w->error;
}
static int dyn_end(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
return 0;
}
static int dyn_flush(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
void *tmp;
w->data_size += 1000;
w->count = w->data_size;
tmp = labcomm2014_memory_realloc(w->memory, 1, w->data, w->data_size);
if (tmp != NULL) {
w->data = tmp;
w->error = 0;
} else {
/* Old pointer in w->data still valid */
w->error = -ENOMEM;
}
return w->error;
}
static int dyn_ioctl(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context,
int signature_index,
const struct labcomm2014_signature *signature,
uint32_t action, va_list arg)
{
int result = -ENOTSUP;
switch (action) {
case LABCOMM_IOCTL_WRITER_GET_BYTES_WRITTEN: {
int *value = va_arg(arg, int*);
*value = w->pos;
result = 0;
} break;
case LABCOMM_IOCTL_WRITER_GET_BYTE_POINTER: {
void **value = va_arg(arg, void**);
*value = w->data;
result = 0;
} break;
}
return result;
}
static const struct labcomm2014_writer_action action = {
.alloc = dyn_alloc,
.free = dyn_free,
.start = dyn_start,
.end = dyn_end,
.flush = dyn_flush,
.ioctl = dyn_ioctl
};
const struct labcomm2014_writer_action *labcomm2014_dynamic_buffer_writer_action =
&action;
struct labcomm2014_writer *labcomm2014_dynamic_buffer_writer_new(
struct labcomm2014_memory *memory)
{
struct result {
struct labcomm2014_writer writer;
struct labcomm2014_writer_action_context action_context;
} *result;
result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
if (result != NULL) {
result->action_context.next = NULL;
result->action_context.context = result;
result->action_context.action = &action;
result->writer.action_context = &result->action_context;
result->writer.memory = memory;
return &result->writer;
}
return NULL;
}
lib/c/2014/labcomm2014_dynamic_buffer_writer.h deleted 100644 → 0
View file @ 1f17be8a
/*
labcomm2014_dynamic_buffer_writer.h -- LabComm dynamic memory writer.
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __LABCOMM2014_DYNAMIC_BUFFER_READER_WRITER_H__
#define __LABCOMM2014_DYNAMIC_BUFFER_READER_WRITER_H__
#include "labcomm2014.h"
extern const struct labcomm2014_writer_action *labcomm2014_dynamic_buffer_writer_action;
struct labcomm2014_writer *labcomm2014_dynamic_buffer_writer_new(
struct labcomm2014_memory *memory);
#endif
lib/c/2014/labcomm2014_encoder.c deleted 100644 → 0
View file @ 1f17be8a
/*
labcomm2014_encoder.c -- handling encoding of labcomm2014 samples.
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define CURRENT_VERSION "LabComm2014"
#include <errno.h>
#include "labcomm2014.h"
#include "labcomm2014_private.h"
#include "labcomm2014_ioctl.h"
#include "labcomm2014_dynamic_buffer_writer.h"
//define the following to disable encoding of typedefs
#undef LABCOMM_WITHOUT_TYPE_DEFS
struct labcomm2014_encoder {
struct labcomm2014_writer *writer;
struct labcomm2014_error_handler *error;
struct labcomm2014_memory *memory;
struct labcomm2014_scheduler *scheduler;
LABCOMM_SIGNATURE_ARRAY_DEF(registered, int);
LABCOMM_SIGNATURE_ARRAY_DEF(sample_ref, int);
LABCOMM_SIGNATURE_ARRAY_DEF(typedefs, int);
};
static struct labcomm2014_encoder *internal_encoder_new(
struct labcomm2014_writer *writer,
struct labcomm2014_error_handler *error,
struct labcomm2014_memory *memory,
struct labcomm2014_scheduler *scheduler,
labcomm2014_bool outputVer)
{
struct labcomm2014_encoder *result;
result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
if (result) {
int length;
result->writer = writer;
result->writer->encoder = result;
result->writer->data = NULL;
result->writer->data_size = 0;
result->writer->count = 0;
result->writer->pos = 0;
result->writer->error = 0;
result->error = error;
result->memory = memory;
result->scheduler = scheduler;
LABCOMM_SIGNATURE_ARRAY_INIT(result->registered, int);
LABCOMM_SIGNATURE_ARRAY_INIT(result->sample_ref, int);
LABCOMM_SIGNATURE_ARRAY_INIT(result->typedefs, int);
labcomm2014_writer_alloc(result->writer,
result->writer->action_context);
if(outputVer) {
labcomm2014_writer_start(result->writer,
result->writer->action_context,
LABCOMM_VERSION, NULL, CURRENT_VERSION);
labcomm2014_write_packed32(result->writer, LABCOMM_VERSION);
length = labcomm2014_size_string(CURRENT_VERSION);
labcomm2014_write_packed32(result->writer, length);
labcomm2014_write_string(result->writer, CURRENT_VERSION);
labcomm2014_writer_end(result->writer, result->writer->action_context);
}
}
return result;
}
struct labcomm2014_encoder *labcomm2014_encoder_new(
struct labcomm2014_writer *writer,
struct labcomm2014_error_handler *error,
struct labcomm2014_memory *memory,
struct labcomm2014_scheduler *scheduler)
{
return internal_encoder_new(writer,error,memory,scheduler,LABCOMM2014_TRUE);
}
void labcomm2014_encoder_free(struct labcomm2014_encoder* e)
{
struct labcomm2014_memory *memory = e->memory;
labcomm2014_writer_free(e->writer, e->writer->action_context);
LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, e->registered, int);
LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, e->sample_ref, int);
LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, e->typedefs, int);
labcomm2014_memory_free(memory, 0, e);
}
int labcomm2014_internal_encoder_register(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature,
labcomm2014_encoder_function encode)
{
int result = -EINVAL;
int index, *done, err, i, length;
index = labcomm2014_get_local_index(signature);
labcomm2014_scheduler_writer_lock(e->scheduler);
if (index <= 0) { goto out; }
done = LABCOMM_SIGNATURE_ARRAY_REF(e->memory, e->registered, int, index);
if (*done) {
goto out; }
*done = 1;
err = labcomm2014_writer_start(e->writer, e->writer->action_context,
index, signature, NULL);
if (err == -EALREADY) { result = 0; goto out; }
if (err != 0) { result = err; goto out; }
labcomm2014_write_packed32(e->writer, LABCOMM_SAMPLE_DEF);
length = (labcomm2014_size_packed32(index) +
labcomm2014_size_string(signature->name) +
labcomm2014_size_packed32(signature->size) +
signature->size);
labcomm2014_write_packed32(e->writer, length);
labcomm2014_write_packed32(e->writer, index);
labcomm2014_write_string(e->writer, signature->name);
labcomm2014_write_packed32(e->writer, signature->size);
for (i = 0 ; i < signature->size ; i++) {
if (e->writer->pos >= e->writer->count) {
labcomm2014_writer_flush(e->writer, e->writer->action_context);
}
e->writer->data[e->writer->pos] = signature->signature[i];
e->writer->pos++;
}
labcomm2014_writer_end(e->writer, e->writer->action_context);
result = e->writer->error;
out:
labcomm2014_scheduler_writer_unlock(e->scheduler);
return result;
}
int labcomm2014_internal_encode(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature,
labcomm2014_encoder_function encode,
void *value)
{
int result, index, length;
index = labcomm2014_get_local_index(signature);
length = (signature->encoded_size(value));
labcomm2014_scheduler_writer_lock(e->scheduler);
if (! LABCOMM_SIGNATURE_ARRAY_GET(e->registered, int, index, 0)) {
result = -EINVAL;
goto no_end;
}
result = labcomm2014_writer_start(e->writer, e->writer->action_context,
index, signature, value);
if (result == -EALREADY) { result = 0; goto no_end; }
if (result != 0) { goto out; }
result = labcomm2014_write_packed32(e->writer, index);
result = labcomm2014_write_packed32(e->writer, length);
if (result != 0) { goto out; }
result = encode(e->writer, value);
out:
labcomm2014_writer_end(e->writer, e->writer->action_context);
no_end:
labcomm2014_scheduler_writer_unlock(e->scheduler);
return result;
}
int labcomm2014_encoder_sample_ref_register(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature)
{
int result = -EINVAL;
int index, *done, err, i, length;
index = labcomm2014_get_local_index(signature);
labcomm2014_scheduler_writer_lock(e->scheduler);
if (index <= 0) { goto out; }
done = LABCOMM_SIGNATURE_ARRAY_REF(e->memory, e->sample_ref, int, index);
if (*done) { goto out; }
*done = 1;
err = labcomm2014_writer_start(e->writer, e->writer->action_context,
index, signature, NULL);
if (err == -EALREADY) { result = 0; goto out; }
if (err != 0) { result = err; goto out; }
labcomm2014_write_packed32(e->writer, LABCOMM_SAMPLE_REF);
length = (labcomm2014_size_packed32(index) +
labcomm2014_size_string(signature->name) +
labcomm2014_size_packed32(signature->size) +
signature->size);
labcomm2014_write_packed32(e->writer, length);
labcomm2014_write_packed32(e->writer, index);
labcomm2014_write_string(e->writer, signature->name);
labcomm2014_write_packed32(e->writer, signature->size);
for (i = 0 ; i < signature->size ; i++) {
if (e->writer->pos >= e->writer->count) {
labcomm2014_writer_flush(e->writer, e->writer->action_context);
}
e->writer->data[e->writer->pos] = signature->signature[i];
e->writer->pos++;
}
labcomm2014_writer_end(e->writer, e->writer->action_context);
result = e->writer->error;
out:
labcomm2014_scheduler_writer_unlock(e->scheduler);
return result;
}
int labcomm2014_encoder_ioctl(struct labcomm2014_encoder *encoder,
uint32_t action,
...)
{
int result;
va_list va;
if (LABCOMM_IOC_SIG(action) != LABCOMM_IOC_NOSIG) {
result = -EINVAL;
goto out;
}
va_start(va, action);
result = labcomm2014_writer_ioctl(encoder->writer,
encoder->writer->action_context,
0, NULL, action, va);
va_end(va);
out:
return result;
}
int labcomm2014_internal_encoder_ioctl(struct labcomm2014_encoder *encoder,
const struct labcomm2014_signature *signature,
uint32_t action, va_list va)
{
int result = -ENOTSUP;
int index;
index = labcomm2014_get_local_index(signature);
result = labcomm2014_writer_ioctl(encoder->writer,
encoder->writer->action_context,
index, signature, action, va);
return result;
}
int labcomm2014_internal_encoder_signature_to_index(
struct labcomm2014_encoder *e, const struct labcomm2014_signature *signature)
{
/* writer_lock should be held at this point */
int index = 0;
if (signature != NULL) {
index = labcomm2014_get_local_index(signature);
if (! LABCOMM_SIGNATURE_ARRAY_GET(e->sample_ref, int, index, 0)) {
index = 0;
}
}
return index;
}
/**********************************************************
* Start of code related to sending (hierarchical)
* typedefs. Define LABCOMM_WITHOUT_TYPEDEFS to disable
**********************************************************/
#ifndef LABCOMM_WITHOUT_TYPE_DEFS
static void write_sig_tree_byte(char b, const struct labcomm2014_signature *signature,
void *context)
{
struct labcomm2014_encoder *e = context;
if(signature) {
labcomm2014_write_packed32(e->writer, labcomm2014_get_local_index(signature));
}else {
if (e->writer->pos >= e->writer->count) {
labcomm2014_writer_flush(e->writer, e->writer->action_context);
}
e->writer->data[e->writer->pos] = b;
e->writer->pos++;
}
}
static void do_write_signature(struct labcomm2014_encoder * e,
const struct labcomm2014_signature *signature,
unsigned char flatten)
{
map_signature(write_sig_tree_byte, e, signature, flatten);
}
static void sig_size(char b, const struct labcomm2014_signature *signature,
void *context)
{
int *result = context;
int diff;
if(signature) {
int idx = labcomm2014_get_local_index(signature);
diff = labcomm2014_size_packed32(idx);
}else {
diff = 1;
}
(*result)+=diff;
}
static int calc_sig_encoded_size(struct labcomm2014_encoder *e,
const struct labcomm2014_signature *sig)
{
int result=0;
map_signature(sig_size, &result, sig, LABCOMM2014_FALSE);
return result;
}
static int internal_reg_type(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature,
labcomm2014_bool flatten)
{
int result = -EINVAL;
int index, *done, err;
index = labcomm2014_get_local_index(signature);
labcomm2014_scheduler_writer_lock(e->scheduler);
if (index <= 0) { goto out; }
done = LABCOMM_SIGNATURE_ARRAY_REF(e->memory, e->typedefs, int, index);
if (*done) { goto out; }
*done = 1;
err = labcomm2014_writer_start(e->writer, e->writer->action_context,
index, signature, NULL);
if (err == -EALREADY) { result = 0; goto out; }
if (err != 0) { result = err; goto out; }
int sig_size = calc_sig_encoded_size(e, signature);
int len = labcomm2014_size_packed32(index) +
labcomm2014_size_string(signature->name) +
labcomm2014_size_packed32(sig_size) +
sig_size;
labcomm2014_write_packed32(e->writer, LABCOMM_TYPE_DEF);
labcomm2014_write_packed32(e->writer, len);
labcomm2014_write_packed32(e->writer, index);
labcomm2014_write_string(e->writer, signature->name);
labcomm2014_write_packed32(e->writer, sig_size);
do_write_signature(e, signature, LABCOMM2014_FALSE);
labcomm2014_writer_end(e->writer, e->writer->action_context);
result = e->writer->error;
out:
labcomm2014_scheduler_writer_unlock(e->scheduler);
return result;
}
#endif
int labcomm2014_internal_encoder_type_register(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature)
{
#ifndef LABCOMM_WITHOUT_TYPE_DEFS
return internal_reg_type(e, signature, LABCOMM2014_FALSE);
#else
return 0;
#endif
}
int labcomm2014_internal_encoder_type_bind(
struct labcomm2014_encoder *e,
const struct labcomm2014_signature *signature,
char has_deps)
{
#ifndef LABCOMM_WITHOUT_TYPE_DEFS
int result = -EINVAL;
int err;
int sindex = labcomm2014_get_local_index(signature);
int tindex = has_deps ? labcomm2014_get_local_type_index(signature) : LABCOMM_BIND_SELF;
labcomm2014_scheduler_writer_lock(e->scheduler);
if(sindex <= 0 || (has_deps && tindex <= 0)) {goto out;}
err = labcomm2014_writer_start(e->writer, e->writer->action_context,
LABCOMM_TYPE_BINDING, signature, NULL);
if (err == -EALREADY) { result = 0; goto out; }
if (err != 0) { result = err; goto out; }
int length = (labcomm2014_size_packed32(sindex) +
labcomm2014_size_packed32(tindex));
labcomm2014_write_packed32(e->writer, LABCOMM_TYPE_BINDING);
labcomm2014_write_packed32(e->writer, length);
labcomm2014_write_packed32(e->writer, sindex);
labcomm2014_write_packed32(e->writer, tindex);
labcomm2014_writer_end(e->writer, e->writer->action_context);
result = e->writer->error;
out:
labcomm2014_scheduler_writer_unlock(e->scheduler);
return result;
#else
return 0;
#endif
}
lib/c/2014/labcomm2014_error.c deleted 100644 → 0
View file @ 1f17be8a
/*
labcomm2014_error.c -- labcomm2014 error handling
Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include "labcomm2014_error.h"
void labcomm2014_error_fatal_global(enum labcomm2014_error error,
char *format,
...)
{
va_list args;
fprintf(stderr, "Fatal error %d\n", error);
va_start(args, format);
vprintf(format, args);
va_end(args);
exit(1);
}
lib/c/2014/labcomm2014_error.h deleted 100644 → 0
View file @ 1f17be8a
/*
labcomm2014_error.h -- labcomm2014 error declarations
Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __LABCOMM2014_ERROR_H___
#define __LABCOMM2014_ERROR_H___
enum labcomm2014_error {
#define LABCOMM2014_ERROR(name, description) name ,
#include "labcomm2014_error.h"
#undef LABCOMM2014_ERROR
};
struct labcomm2014_error_handler;
void labcomm2014_error_warning(struct labcomm2014_error_handler *e,
enum labcomm2014_error,
char *format,
...);
void labcomm2014_error_fatal_global(enum labcomm2014_error error,
char *format,
...);
#endif
#ifdef LABCOMM2014_ERROR
LABCOMM2014_ERROR(LABCOMM2014_ERROR_SIGNATURE_ALREADY_SET,
"Signature has already been set")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_SIGNATURE_NOT_SET,
"Signature has not been set")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_ENC_NO_REG_SIGNATURE,
"Encoder has no registration for this signature")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_ENC_BUF_FULL,
"The labcomm2014 buffer is full")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_DEC_UNKNOWN_DATATYPE,
"Decoder: Unknown datatype")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_DEC_INDEX_MISMATCH,
"Decoder: index mismatch")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_DEC_TYPE_NOT_FOUND,
"Decoder: type not found")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_UNIMPLEMENTED_FUNC,
"This function is not yet implemented")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_MEMORY,
"Could not allocate memory")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_USER_DEF,
"User defined error")
LABCOMM2014_ERROR(LABCOMM2014_ERROR_BAD_WRITER,
"Decoder: writer_ioctl() failed")
#endif
lib/c/2014/labcomm2014_fd_reader.c deleted 100644 → 0
View file @ 1f17be8a
/*
labcomm2014_fd_reader.c -- LabComm reader for Unix file descriptors.
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include "labcomm2014_private.h"
#include "labcomm2014_fd_reader.h"
#define BUFFER_SIZE 2048
struct labcomm2014_fd_reader {
struct labcomm2014_reader reader;
struct labcomm2014_reader_action_context action_context;
int fd;
int close_fd_on_free;
};
static int fd_alloc(struct labcomm2014_reader *r,
struct labcomm2014_reader_action_context *action_context)
{
int result = 0;
r->count = 0;
r->pos = 0;
r->data = labcomm2014_memory_alloc(r->memory, 0, BUFFER_SIZE);
if (! r->data) {
r->data_size = 0;
result = -ENOMEM;
} else {
r->data_size = BUFFER_SIZE;
result = r->data_size;
}
return result;
}
static int fd_free(struct labcomm2014_reader *r,
struct labcomm2014_reader_action_context *action_context)
{
struct labcomm2014_fd_reader *fd_reader = action_context->context;
struct labcomm2014_memory *memory = r->memory;
labcomm2014_memory_free(memory, 0, r->data);
r->data = 0;
r->data_size = 0;
r->count = 0;
r->pos = 0;
if (fd_reader->close_fd_on_free) {
close(fd_reader->fd);
}
labcomm2014_memory_free(memory, 0, fd_reader);
return 0;
}
static int fd_fill(struct labcomm2014_reader *r,
struct labcomm2014_reader_action_context *action_context)
{
int result = 0;
struct labcomm2014_fd_reader *fd_reader = action_context->context;
if (r->pos < r->count) {
result = r->count - r->pos;
} else {
int err;
r->pos = 0;
err = read(fd_reader->fd, (char *)r->data, r->data_size);
if (err <= 0) {
r->count = 0;
r->error = -EPIPE;
result = -EPIPE;
} else {
r->count = err;
result = r->count - r->pos;
}
}
return result;
}
static const struct labcomm2014_reader_action action = {
.alloc = fd_alloc,
.free = fd_free,
.start = NULL,
.fill = fd_fill,
.end = NULL,
.ioctl = NULL
};
struct labcomm2014_reader *labcomm2014_fd_reader_new(struct labcomm2014_memory *memory,
int fd, int close_fd_on_free)
{
struct labcomm2014_fd_reader *result;
result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
if (result == NULL) {
return NULL;
} else {
result->action_context.next = NULL;
result->action_context.action = &action;
result->action_context.context = result;
result->reader.action_context = &result->action_context;
result->reader.memory = memory;
result->fd = fd;
result->close_fd_on_free = close_fd_on_free;
return &result->reader;
}
}
lib/c/2014/labcomm2014_fd_reader.h deleted 100644 → 0
View file @ 1f17be8a
/*
labcomm2014_fd_reader.c -- a reader for unix style file-descriptors
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __LABCOMM2014_FD_READER_H__
#define __LABCOMM2014_FD_READER_H__
#include "labcomm2014.h"
struct labcomm2014_reader *labcomm2014_fd_reader_new(struct labcomm2014_memory *memory,
int fd, int close_fd_on_free);
#endif
lib/c/2014/labcomm2014_fd_writer.c deleted 100644 → 0
View file @ 1f17be8a
/*
labcomm2014_fd_writer.c -- LabComm writer for Unix file descriptors.
Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include "labcomm2014_private.h"
#include "labcomm2014_fd_writer.h"
#define BUFFER_SIZE 2048
struct labcomm2014_fd_writer {
struct labcomm2014_writer writer;
struct labcomm2014_writer_action_context action_context;
int fd;
int close_fd_on_free;
};
static int fd_flush(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context);
static int fd_alloc(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
w->data = labcomm2014_memory_alloc(w->memory, 0, BUFFER_SIZE);
if (! w->data) {
w->error = -ENOMEM;
w->data_size = 0;
w->count = 0;
w->pos = 0;
} else {
w->data_size = BUFFER_SIZE;
w->count = BUFFER_SIZE;
w->pos = 0;
}
return w->error;
}
static int fd_free(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
struct labcomm2014_fd_writer *fd_writer = action_context->context;
struct labcomm2014_memory *memory = w->memory;
labcomm2014_memory_free(memory, 0, w->data);
w->data = 0;
w->data_size = 0;
w->count = 0;
w->pos = 0;
if (fd_writer->close_fd_on_free) {
close(fd_writer->fd);
}
labcomm2014_memory_free(memory, 0, fd_writer);
return 0;
}
static int fd_start(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context,
int index,
const struct labcomm2014_signature *signature,
void *value)
{
w->pos = 0;
return w->error;
}
static int fd_flush(struct labcomm2014_writer *w,
struct labcomm2014_writer_action_context *action_context)
{
struct labcomm2014_fd_writer *fd_context = action_context->context;
int start, err;
start = 0;
err = 0;
while (start < w->pos) {
err = write(fd_context->fd, (char *)&w->data[start], w->pos - start);
if (err <= 0) {
break;
}
start = start + err;
}
if (err < 0) {
w->error = -errno;
} else if (err == 0) {
w->error = -EINVAL;
}
w->pos = 0;
return w->error;
}
static const struct labcomm2014_writer_action action = {
.alloc = fd_alloc,
.free = fd_free,
.start = fd_start,
.end = fd_flush,
.flush = fd_flush,
.ioctl = NULL
};
struct labcomm2014_writer *labcomm2014_fd_writer_new(struct labcomm2014_memory *memory,
int fd, int close_fd_on_free)
{
struct labcomm2014_fd_writer *result;
result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
if (result == NULL) {
return NULL;
} else {
result->action_context.next = NULL;
result->action_context.action = &action;
result->action_context.context = result;
result->writer.action_context = &result->action_context;
result->writer.memory = memory;
result->fd = fd;
result->close_fd_on_free = close_fd_on_free;
return &result->writer;
}
}