Compare revisions

Discussion 141023

TODO:

*** new labcomm packet types:

    TYPE_DEF = 0x03     // for (possibly) hierarchical type definitions

    TYPE_BINDING = 0x04 // binding a sample def to a type def

*** rewrite malloc of received samples to utilize the packet length field

    to allocate a single object before parsing the sample byte stream

*** labcomm language: add type for type_ref to facilitate references to

    labcomm sample_defs (and type_defs) in (primarily) pragmas

    E.g.,  sample ... foo;

         sample ... bar;

         sample struct {

             ...

             type[2] some_refs;

         } some_pragma;

	my_lc_some_pragma sp;

	sp.some_refs = {&labcomm_signature_my_lc_foo, 

                        &labcomm_signature_my_lc_bar}; 

 	labcomm_encode_my_lc_some_pragma(enc, &sp);

    This is to avoid exposing local_to_remote and remote_to_local

*** refactor {encoder,decoder}registry to separate the actual encoder

    from the registry

    - currently, the assignment of local indices is done in the "constructor"

      which means that the registries will be very thin

*** labcomm_pragma_builder(struct labcomm_encoder *enc);

    - looks like an encoder to enable reuse of the generated encode functions

    - allocates memory in the enclosing encoder, enc.

    - deallocates memory when packet is sent

*** Pragma handler

    - is a decoder, to which the user registers handlers for pragma samples

    - has/gets a byte_array_reader in the context

    - the "surrounding" decoder will deallocate the pragma packet when the

      pragma handler returns

______________________________________________________________

______________preliminary sketch of pragma____________________

A pragma "packet" is a sequence of fields, where each field is

a labcomm sample (in order to keep labcomm in-band self-describing).

A pragma packet has a type, which is a globally unique string

(e.g., java package-like name, URI, or UUID)

One predefined pragma sample type is labcomm_type_ref, which is used to refer

to labcomm sample types in a way that is unique on a given encoder/channel.

Sending:

/* create a pragma packet for pragma type type

   allocated in e->memory */

// (or, if that is visible to user code, should

// the parameter be a struct labcomm_memory*?)

struct labcom_pragma_packet * = labcomm_pragma_new(struct labcomm_encoder e*,

                                                   char *type);

/* add type reference field*/

void labcomm_pragma_add_ref(struct labcomm_signature sig);

// the semantics if more than one type reference field is undefined

// (as far as labcomm is concerned).

// One possible (pragma-type defined) semantic is that the latest type

// reference applies to the fields following it.

A pragma packet is (under the hood) a struct labcomm_encoder, so that we

can reuse the sample_type_encode() function for adding pragma fields.

// an example session

struct labcom_pragma_packet pp = labcomm_pragma_new(enc, some_type));

labcomm_pragma_add_ref(some_sig);

some_pragma_type_encode(pp, some_pragma_instance);

another_pragma_type_encode(pp, another_pragma_instance);

labcomm_pragma_send(pp, enc);

#define labcomm_pragma_add_field(some_pragma_sample_type, value) \

	labcomm_encode_#some_pragma_sample_type, value)

int labcomm_encode_test_twoLines( struct labcomm_encoder *e,

                                  test_twoLines *v)

{

return labcomm_internal_encode(e,

                               &labcomm_signature_test_twoLines,

                               (labcomm_enc oder_function) encode_test_twoLines,

                                v);

}

receiving:

alt 1. standard handlers, parameter pragma_type to handle function

	-- this means adding a parameter to all handlers

           (where null means not pragma)

void handle_some_pragma(some_pragma *v, void *context, char * pragma_type);

alt 2. standard handlers, but separate register_pragma_handler function

       use the handler context to store and communicate pragma-specific data.

	-- this means that the decoder interface needs to be extended,

           and that the handler context for pragmas need to be specified

           (by labcomm)

alt 3  have a single handler for pragma packets as the interface upwards

       from the labcomm lib. That handler is then responsible for managing

       and multiplexing pragma types based on the type field in the pragma

       packet.

       The labcomm libraries can provide a default implementation of a

       pragma_handler, to facilitate the common cases and reduce the

       amount of boilerplate code.

struct pragma_packet {

	char *pragma_type;

	char *packed_data;

}

void handle_pragma(struct pragma_packet *p, void *context);

			  uint32_t ioctl_action,

			  uint32_t ioctl_action,

			  ...);

			  ...);

/* pragma */

struct labcomm_pragma_handler {

  //struct labcomm_decoder_registry *registry;

  //TODO: implement  map (char * pragma_type) --> decoder_registry *

  //to allow having different sets of handlers for different pragma types

  int foo;

};

typedef int (*labcomm_handle_pragma_callback)(

  struct labcomm_decoder *decoder,

  char *pragma_type);

void labcomm_decoder_register_pragma_handler(struct labcomm_decoder *d,

		labcomm_handle_pragma_callback pragma_dispatcher);

/*

/*

 * Encoder

 * Encoder

 */

 */

/*

  labcomm_bytearray_reader.c -- a reader for data in a byte array

  Copyright 2014 Sen Gestegård Robertz <sven.robertz@cs.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 "labcomm_private.h"

#include "labcomm_bytearray_reader.h"

struct labcomm_bytearray_reader {

  struct labcomm_reader reader;

  struct labcomm_reader_action_context action_context;

  unsigned char *bytearray;

  int bytearray_size;

};

static int bytearray_alloc(struct labcomm_reader *r,

		    struct labcomm_reader_action_context *action_context, 

		    char *version)

{

  int result = 0;

  r->data = ((struct labcomm_bytearray_reader *)action_context->context)->bytearray;

  r->count =((struct labcomm_bytearray_reader *)action_context->context)->bytearray_size;

  r->pos = 0;

  return result;

}

static int bytearray_free(struct labcomm_reader *r, 

		   struct labcomm_reader_action_context *action_context)

{

  struct labcomm_bytearray_reader *bytearray_reader = action_context->context;

  struct labcomm_memory *memory = r->memory;

  //HERE BE DRAGONS labcomm_memory_free(memory, 0, r->data);

  r->data = 0;

  r->data_size = 0;

  r->count = 0;

  r->pos = 0;

  labcomm_memory_free(memory, 0, bytearray_reader);

  return 0;

}

static int bytearray_fill(struct labcomm_reader *r, 

		   struct labcomm_reader_action_context *action_context)

{

  int result = 0;

  if (r->pos < r->count) {

    //printf("BAreader.fill: pos %d count: %d\n", r->pos, r->count);

    result = r->count - r->pos;

  } else {

    r->pos = 0;

    r->error = -EPIPE;

    result = -EPIPE;

  }

  return result;

}

static const struct labcomm_reader_action action = {

  .alloc = bytearray_alloc,

  .free = bytearray_free,

  .start = NULL,

  .fill = bytearray_fill,

  .end = NULL,

  .ioctl = NULL

};

struct labcomm_reader *labcomm_bytearray_reader_new(struct labcomm_memory *memory,

					     unsigned char *data, int size)

{

  struct labcomm_bytearray_reader *result;

  result = labcomm_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->bytearray = data;

    result->bytearray_size = size;

    struct labcomm_reader *   res = &result->reader;

   // printf("reader: %p, size: %d\n", res, res->data_size);

    return res;

  }

}

/*

  labcomm_bytearray_reader.h -- a reader for data in a byte array

  Copyright 2014 Sen Gestegård Robertz <sven.robertz@cs.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_BYTEARRAY_READER_H_

#define _LABCOMM_BYTEARRAY_READER_H_

#include "labcomm.h"

struct labcomm_reader *labcomm_bytearray_reader_new(struct labcomm_memory *memory,

					     unsigned char *data, int size);

#endif

#include "labcomm_private.h"

#include "labcomm_private.h"

#include "labcomm_ioctl.h"

#include "labcomm_ioctl.h"

#include "labcomm_dynamic_buffer_writer.h"

#include "labcomm_dynamic_buffer_writer.h"

#include "labcomm_bytearray_reader.h"

struct sample_entry {

struct sample_entry {

  int remote_index;

  int remote_index;

  }

  }

  return result;

  return result;

}

}

#ifndef WITHOUT_PRAGMA

/* Internal aux function to allow temporary internal decoders

 * to share the same memory.

 * This function only frees the decoder, not the memory

 */

static void internal_labcomm_decoder_free(struct labcomm_decoder* d)

{

  struct labcomm_memory *memory = d->memory;

  labcomm_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);

}

void labcomm_decoder_free(struct labcomm_decoder* d)

{

  struct labcomm_memory *memory = d->memory;

  internal_labcomm_decoder_free(d);

  labcomm_memory_free(memory, 0, d);

}

#else

void labcomm_decoder_free(struct labcomm_decoder* d)

void labcomm_decoder_free(struct labcomm_decoder* d)

{

{

  struct labcomm_memory *memory = d->memory;

  struct labcomm_memory *memory = d->memory;

  LABCOMM_SIGNATURE_ARRAY_FREE(memory, d->remote_to_local, int);

  LABCOMM_SIGNATURE_ARRAY_FREE(memory, d->remote_to_local, int);

  labcomm_memory_free(memory, 0, d);

  labcomm_memory_free(memory, 0, d);

}

}

#endif

static int decode_sample(struct labcomm_decoder *d, int kind)

static int decode_sample_def(struct labcomm_decoder *d, int kind)

{

{

  int result;

  int result;

  struct labcomm_signature signature, *local_signature;

  struct labcomm_signature signature, *local_signature;

    labcomm_reader_alloc(d->reader, d->reader->action_context);

    labcomm_reader_alloc(d->reader, d->reader->action_context);

  }

  }

}

}

static int decode_version(struct labcomm_decoder *d, int remote_index)

{

    int result;

    char *version = labcomm_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;

    }  

    labcomm_memory_free(d->memory, 1,  version);

out:   

  return result;

}

static int decoder_skip(struct labcomm_decoder *d, int len)

{

  int i;

  for(i = 0; i <len; i++){

    labcomm_read_byte(d->reader);

    if (d->reader->error < 0) {

      return d->reader->error;

    }

  }

  return 0;

}

static int decode_pragma(struct labcomm_decoder *d, int len)

{

  char *pragma_type;

  int result;

  pragma_type = labcomm_read_string(d->reader);

  if (d->reader->error < 0) {

    result = d->reader->error;

    goto out;

  }

  int bytes = labcomm_size_string(pragma_type);

  int psize = len-bytes;

  if(0 /*d->pragma_handler*/) {

  //read the entire packet to a buffer and then run

  // decode on that through a bytearray_reader.

  // (to easily handle multiple labcomm packets in one metadata packet)

    int i;

    unsigned char pragma_data[psize] ;

    for(i=0; i<psize; i++) {

       pragma_data[i] = labcomm_read_byte(d->reader);

       if (d->reader->error < 0) {

         result = d->reader->error;

         goto out;

       }

     }

     struct labcomm_reader *pr = labcomm_bytearray_reader_new(

                                     d->reader->memory, pragma_data, psize);

     struct labcomm_decoder *pd = labcomm_decoder_new(

                                     pr, d->error, d->memory, d->scheduler);

    /* d->prama_handler(pd, ptype, plen); */

     internal_labcomm_decoder_free(pd);

     result = 0;

   } else {

     result = decoder_skip(d, psize);

   }

out:

  return result;

}

int labcomm_decoder_decode_one(struct labcomm_decoder *d)

int labcomm_decoder_decode_one(struct labcomm_decoder *d)

{

{

    goto out;

    goto out;

  }

  }

  if (remote_index == LABCOMM_VERSION) {

  if (remote_index == LABCOMM_VERSION) {

    char *version = labcomm_read_string(d->reader);

    result = decode_version(d, remote_index);

    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;

    }  

    labcomm_memory_free(d->memory, 1,  version);

  } else if (! d->version_ok) {

  } else if (! d->version_ok) {

    fprintf(stderr, "No VERSION %d %d\n", remote_index, length);

    fprintf(stderr, "No VERSION %d %d\n", remote_index, length);

    result = -ECONNRESET;

    result = -ECONNRESET;

  } else if (remote_index == LABCOMM_SAMPLE) {

  } else if (remote_index == LABCOMM_SAMPLE_DEF) {

    result = decode_sample(d, remote_index); 

    result = decode_sample_def(d, remote_index); 

  } else if (remote_index == LABCOMM_PRAGMA && 0 /* d->pragma_handler*/) {

  } else if (remote_index == LABCOMM_PRAGMA ){

    /* d->prama_handler(...); */

    result = decode_pragma(d, length);

  } else if (remote_index < LABCOMM_USER) {

  } else if (remote_index < LABCOMM_USER) {

    fprintf(stderr, "SKIP %d %d\n", remote_index, length);

    fprintf(stderr, "SKIP %d %d\n", remote_index, length);

    result = remote_index;

    result = remote_index;

#include "labcomm_private.h"

#include "labcomm_private.h"

#include "labcomm_ioctl.h"

#include "labcomm_ioctl.h"

#ifndef WITHOUT_PRAGMA

#include "labcomm_dynamic_buffer_writer.h"

#include "labcomm_bytearray_reader.h"

#endif

struct labcomm_encoder {

struct labcomm_encoder {

  struct labcomm_writer *writer;

  struct labcomm_writer *writer;

  struct labcomm_error_handler *error;

  struct labcomm_error_handler *error;

  struct labcomm_memory *memory;

  struct labcomm_memory *memory;

  struct labcomm_scheduler *scheduler;

  struct labcomm_scheduler *scheduler;

  LABCOMM_SIGNATURE_ARRAY_DEF(registered, int);

  LABCOMM_SIGNATURE_ARRAY_DEF(registered, int);

  int context_type; //type tag for context. Currently only LABCOMM_PRAGMA

  void *context; // for, e.g. parent of pragma packet builder 

};

};

struct labcomm_encoder *labcomm_encoder_new(

struct labcomm_encoder *labcomm_encoder_new(

  labcomm_memory_free(memory, 0, e);

  labcomm_memory_free(memory, 0, e);

}

}

#undef WITHOUT_PRAGMA

#ifndef WITHOUT_PRAGMA

struct pragma_packet_builder {

	char * pragma_type;

	struct labcomm_encoder* parent;

};

struct labcomm_encoder *labcomm_pragma_builder_new(

                                   struct labcomm_encoder *e,

				   char * pragma_type) {

        struct labcomm_writer *dyn_writer = labcomm_dynamic_buffer_writer_new(

                                                 e->memory);

	struct labcomm_encoder *pb = labcomm_encoder_new(dyn_writer,

                                                          e->error,

                                                          e->memory,

                                                          e->scheduler);

	size_t tlen = 1+strlen(pragma_type);

	char* ptype = labcomm_memory_alloc(

					e->memory,

					1,

					tlen);

	if(ptype) {

          strncpy(ptype, pragma_type, tlen);		

	} //XXX TODO: and else?

	struct pragma_packet_builder* ctxt = labcomm_memory_alloc(

					e->memory,

					1,

					sizeof(struct pragma_packet_builder));

	if(ctxt){

		ctxt->pragma_type=ptype;

		ctxt->parent=e;

	}

	pb->context_type = LABCOMM_PRAGMA;

	pb->context = ctxt;

	return pb;

}

//HERE BE DRAGONS! Copied from decoder.c

//Should this be moved to private_h?

static int writer_ioctl(struct labcomm_writer *writer,

			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 = labcomm_writer_ioctl(writer, writer->action_context,

				0, NULL, action, va);

  va_end(va);

out:

  return result;

}

int labcomm_pragma_send(struct labcomm_encoder* e)

{

//HERE BE DRAGONS!

//We assume that the writer is a dynamic_buffer_writer

  if(e->context_type != LABCOMM_PRAGMA) {

	  printf("context type != PRAGMA, bailing out\n");

	  return 1;

  }

  if(!e->context) {

	  printf("context == NULL, bailing out\n");

	  return 2;

  }

  struct pragma_packet_builder* ctx = e->context;	

  struct labcomm_encoder *p = ctx->parent;

  char * pragma_type = ctx->pragma_type;

  char*  pragma_data;

  int err,len;

  labcomm_writer_end(e->writer, e->writer->action_context);

  err = writer_ioctl(e->writer,

		     LABCOMM_IOCTL_WRITER_GET_BYTES_WRITTEN,

		     &len);

  if (err < 0) {

// HERE BE DRAGONS! 

// What is the difference between error_handler (where is it defined?)

// and error_handler_callback. And why is the latter only in 

// the decoder struct?

//

//    e->on_error(LABCOMM_ERROR_BAD_WRITER, 2,

//		"Failed to get size: %s\n", strerror(-err));

    fprintf(stderr, "BAD WRITER, Failed to get size> %s\n", strerror(-err));

    err = -ENOENT;

    goto free_encoder;

  }

  err = writer_ioctl(e->writer,

        	     LABCOMM_IOCTL_WRITER_GET_BYTE_POINTER,

        	     &pragma_data);

  if (err < 0) {

//    e->on_error(LABCOMM_ERROR_BAD_WRITER, 2,

//        	"Failed to get pointer: %s\n", strerror(-err));

    fprintf(stderr, "BAD WRITER, Failed to get pointer> %s\n", strerror(-err));

    err = -ENOENT;

    goto free_encoder;

  }

  { 

	  int data_len =  labcomm_size_string(pragma_type) + len;

	  int i;

	  labcomm_write_packed32(p->writer, LABCOMM_PRAGMA);

	  labcomm_write_packed32(p->writer, data_len);

	  labcomm_write_string(p->writer, pragma_type);

	  for(i=0; i<len;i++){

		  labcomm_write_byte(p->writer, pragma_data[i]);

	  }

	  labcomm_writer_end(p->writer, p->writer->action_context);

	  err = p->writer->error;

  }

free_encoder:

  //XXX are these needed, or is that done in encoder_free?

  labcomm_memory_free(e->memory, 1, ctx->pragma_type);  

  labcomm_memory_free(e->memory, 1, ctx);  

  labcomm_encoder_free(e);

  return err;

}

#endif

int labcomm_internal_encoder_register(