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

Target

Select target project
  • anders_blomdell/labcomm
  • klaren/labcomm
  • tommyo/labcomm
  • erikj/labcomm
  • sven/labcomm
5 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 1786 additions and 156 deletions
examples/wiki_example/example.encoded deleted 100644 → 0
View file @ 8c8b4a81
File deleted
examples/wiki_example/example.h deleted 100644 → 0
View file @ 8c8b4a81
/* LabComm declarations:
sample struct {
int sequence;
struct {
boolean last;
string data;
} line[_];
} log_message;
sample float data;
*/
#ifndef __LABCOMM_example_H__
#define __LABCOMM_example_H__
#include "labcomm.h"
#ifndef PREDEFINED_example_log_message
typedef struct {
int sequence;
struct {
int n_0;
struct {
unsigned char last;
char* data;
} *a;
} line;
} example_log_message;
#endif
void labcomm_decoder_register_example_log_message(
struct labcomm_decoder *d,
void (*handler)(
example_log_message *v,
void *context
),
void *context
);
void labcomm_encoder_register_example_log_message(
struct labcomm_encoder *e);
void labcomm_encode_example_log_message(
struct labcomm_encoder *e,
example_log_message *v
);
extern int labcomm_sizeof_example_log_message(example_log_message *v);
#ifndef PREDEFINED_example_data
typedef float example_data;
#endif
void labcomm_decoder_register_example_data(
struct labcomm_decoder *d,
void (*handler)(
example_data *v,
void *context
),
void *context
);
void labcomm_encoder_register_example_data(
struct labcomm_encoder *e);
void labcomm_encode_example_data(
struct labcomm_encoder *e,
example_data *v
);
extern int labcomm_sizeof_example_data(example_data *v);
#define LABCOMM_FORALL_SAMPLES_example(func, sep) \
func(log_message, example_log_message) sep \
func(data, example_data)
#endif
examples/wiki_example/example.py deleted 100644 → 0
View file @ 8c8b4a81
#!/usr/bin/python
# Auto generated example
import labcomm
class log_message(object):
signature = labcomm.sample('log_message',
labcomm.struct([
('sequence', labcomm.INTEGER()),
('line', labcomm.array([0],
labcomm.struct([
('last', labcomm.BOOLEAN()),
('data', labcomm.STRING())])))]))
class data(object):
signature = labcomm.sample('data',
labcomm.FLOAT())
examples/wiki_example/example_decoder.py
View file @ d3921882
#!/usr/bin/python
import labcomm
import labcomm2014
import sys
class FileReader:
def __init__(self, name):
self.f = open(name)
def read(self, count):
s = self.f.read(count)
if len(s) == 0:
raise Exception("EOF")
return s
def mark(self, value, decl):
pass
if __name__ == "__main__":
d = labcomm.Decoder(FileReader(sys.argv[1]))
version = sys.argv[2] if len(sys.argv) == 3 else "LabComm2014"
d = labcomm2014.Decoder(labcomm2014.StreamReader(open(sys.argv[1])), version)
while True:
try:
data,decl = d.decode()
if data:
print data
except:
except Exception, e:
print e
break
examples/wiki_example/example_decoder_encoder.java
View file @ d3921882
......@@ -4,24 +4,24 @@ import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import se.lth.control.labcomm.LabCommDecoderChannel;
import se.lth.control.labcomm.LabCommEncoderChannel;
import se.lth.control.labcomm2014.DecoderChannel;
import se.lth.control.labcomm2014.EncoderChannel;
public class example_decoder_encoder
implements data.Handler, log_message.Handler
{
LabCommDecoderChannel decoder;
LabCommEncoderChannel encoder;
DecoderChannel decoder;
EncoderChannel encoder;
public example_decoder_encoder(InputStream in, OutputStream out)
throws Exception
{
decoder = new LabCommDecoderChannel(in);
decoder = new DecoderChannel(in);
log_message.register(decoder, this);
data.register(decoder, this);
encoder = new LabCommEncoderChannel(out);
encoder = new EncoderChannel(out);
log_message.register(encoder);
data.register(encoder);
......
examples/wiki_example/example_encoder.c
View file @ d3921882
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <labcomm_fd_reader_writer.h>
#include <labcomm2014.h>
#include <labcomm2014_default_memory.h>
#include <labcomm2014_fd_reader.h>
#include <labcomm2014_fd_writer.h>
#include "example.h"
int main(int argc, char *argv[]) {
int fd;
struct labcomm_encoder *encoder;
struct labcomm2014_encoder *encoder;
struct labcomm2014_writer *labcomm2014_fd_writer;
int i, j;
fd = open("example.encoded", O_WRONLY|O_CREAT|O_TRUNC, 0644);
encoder = labcomm_encoder_new(labcomm_fd_writer, &fd);
labcomm_encoder_register_example_log_message(encoder);
labcomm_encoder_register_example_data(encoder);
labcomm2014_fd_writer = labcomm2014_fd_writer_new(labcomm2014_default_memory, fd, 1);
encoder = labcomm2014_encoder_new(labcomm2014_fd_writer, NULL,
labcomm2014_default_memory, NULL);
labcomm2014_encoder_register_example_log_message(encoder);
labcomm2014_encoder_register_example_data(encoder);
for (i = 0 ; i < argc ; i++) {
example_log_message message;
......@@ -23,11 +29,12 @@ int main(int argc, char *argv[]) {
message.line.a[j].last = (j == message.line.n_0 - 1);
message.line.a[j].data = argv[j + 1];
}
labcomm_encode_example_log_message(encoder, &message);
labcomm2014_encode_example_log_message(encoder, &message);
free(message.line.a);
}
for (i = 0 ; i < argc ; i++) {
float f = i;
labcomm_encode_example_data(encoder, &f);
labcomm2014_encode_example_data(encoder, &f);
}
return 0;
}
examples/wiki_example/run
View file @ d3921882
#!/bin/sh
# Auto generate code from .lc file
java -jar ../../compiler/labComm.jar \
java -jar ../../compiler/labcomm2014_compiler.jar \
--c=example.c --h=example.h \
--java=. \
--cs=example.cs \
--python=example.py \
example.lc
example.lc || exit 1
# Compile executables
gcc -o example_encoder -I ../../lib/c/ \
example_encoder.c \
example.c \
../../lib/c/labcomm.c \
../../lib/c//labcomm_fd_reader_writer.c
javac -cp ../../lib/java:. *.java
(cd ../../lib/c; make all || exit 1)
gcc -Wall -Werror -o example_encoder -I../../lib/c/2014 \
example_encoder.c \
example.c \
../../lib/c/liblabcomm2014.a || exit 1
javac -cp ../../lib/java/labcomm2014.jar:. *.java || exit 1
# Run through all executables (c->java->Python)
./example_encoder one two
java -cp ../../lib/java:. example_decoder_encoder example.encoded example.javaencoded
PYTHONPATH=../../lib/python ./example_decoder.py example.javaencoded
./example_encoder one two || exit 1
java -cp ../../lib/java/labcomm2014.jar:. example_decoder_encoder example.encoded example.javaencoded || exit 1
PYTHONPATH=../../lib/python ./example_decoder.py example.javaencoded || exit 1
lib/Makefile 0 → 100644
View file @ d3921882
SUBDIRS=c csharp java python
.PHONY: all
all: $(SUBDIRS:%=make-%)
.PHONY: make-%
make-%:
$(MAKE) -C $*
.PHONY: test
test: $(SUBDIRS:%=test-%)
.PHONY: test-%
test-%:
$(MAKE) -C $* test
.PHONY: clean
clean: $(SUBDIRS:%=clean-%)
.PHONY: clean-%
clean-%:
$(MAKE) -C $* clean
.PHONY: distclean
distclean: clean $(SUBDIRS:%=distclean-%)
.PHONY: distclean-%
distclean-%:
$(MAKE) -C $* distclean
lib/RAPID/LabComm.sys 0 → 100644
View file @ d3921882
MODULE LabComm(SYSMODULE)
RECORD LabComm_Stream
socketdev soc;
ENDRECORD
RECORD LabComm_Decoder_Sample
string prefix;
string name;
num user_id;
string handler;
ENDRECORD
RECORD LabComm_Encoder_Sample
string prefix;
string name;
num user_id;
ENDRECORD
RECORD Decoder
num user_id;
ENDRECORD
RECORD Encoder
num next_user_id;
ENDRECORD
! LabComm constants
CONST string LabCommVersion := "LabComm2013";
CONST num SAMPLE_DECL:=2;
CONST num SAMPLE_DATA:=64;
CONST num STRUCT_TYPE := 17;
CONST num ARRAY_TYPE := 16;
CONST num BYTE_TYPE := 37;
CONST num BOOL_TYPE := 37;
CONST num SHORT_TYPE := 34;
CONST num INT_TYPE := 37;
CONST num LONG_TYPE := 37;
CONST num FLOAT_TYPE := 37;
! Error declarations
CONST errnum INCORRECT_LABCOMM_VERSION := 50;
CONST errnum UNKNOWN_PACKET_TYPE := 51;
CONST errnum UNKNOWN_SAMPLE_TYPE := 52;
CONST errnum INCORRECT_SAMPLE_SIGNATURE := 53;
CONST errnum SAMPLE_TYPE_NOT_REGISTERED := 54;
CONST errnum IMPLEMENTATION_LIMIT_REACHED := 55;
PROC Decode_Packed(VAR LabComm_Stream s, VAR num v, \ VAR rawbytes collect)
VAR rawbytes buffer;
SocketReceive s.soc,\RawData:=buffer,\ReadNoOfBytes:=1;
UnpackRawBytes buffer,\Network,1,v,\IntX:=USINT;
IF Present(collect) THEN
CopyRawBytes buffer, 1, collect, (RawBytesLen(collect)+1);
ENDIF
ERROR
RAISE ;
ENDPROC
PROC Encode_Packed(VAR LabComm_Stream s, num v)
VAR rawbytes buffer;
PackRawBytes v,buffer,\Network,1,\IntX:=USINT;
SocketSend s.soc,\RawData:=buffer,\NoOfBytes:=1;
ERROR
RAISE ;
ENDPROC
PROC Decode_Boolean(VAR LabComm_Stream s, VAR bool v, \ VAR rawbytes collect)
VAR rawbytes buffer;
VAR num tmp;
SocketReceive s.soc,\RawData:=buffer,\ReadNoOfBytes:=1;
UnpackRawBytes buffer,\Network,1,tmp,\IntX:=USINT;
IF tmp = 0 THEN
v := FALSE;
ELSE
v := TRUE;
ENDIF
IF Present(collect) THEN
CopyRawBytes buffer, 1, collect, (RawBytesLen(collect)+1);
ENDIF
ERROR
RAISE ;
ENDPROC
PROC Encode_Boolean(VAR LabComm_Stream s, bool v)
VAR rawbytes buffer;
VAR num tmp;
IF v THEN
tmp := 1;
ELSE
tmp := 0;
ENDIF
PackRawBytes tmp,buffer,\Network,1,\IntX:=USINT;
SocketSend s.soc,\RawData:=buffer,\NoOfBytes:=1;
ERROR
RAISE ;
ENDPROC
PROC Decode_Byte(VAR LabComm_Stream s, VAR byte v, \ VAR rawbytes collect)
VAR rawbytes buffer;
SocketReceive s.soc,\RawData:=buffer,\ReadNoOfBytes:=1;
UnpackRawBytes buffer,\Network,1,v,\Hex1;
IF Present(collect) THEN
CopyRawBytes buffer, 1, collect, (RawBytesLen(collect)+1);
ENDIF
ERROR
RAISE ;
ENDPROC
PROC Encode_Byte(VAR LabComm_Stream s, byte v)
VAR rawbytes buffer;
PackRawBytes v,buffer,\Network,1,\Hex1;
SocketSend s.soc,\RawData:=buffer,\NoOfBytes:=1;
ERROR
RAISE ;
ENDPROC
PROC Decode_Short(VAR LabComm_Stream s,VAR num v, \ VAR rawbytes collect)
VAR rawbytes buffer;
SocketReceive s.soc,\RawData:=buffer,\ReadNoOfBytes:=2;
UnpackRawBytes buffer,\Network,1,v,\IntX:=INT;
IF Present(collect) THEN
CopyRawBytes buffer, 1, collect, (RawBytesLen(collect)+1);
ENDIF
ERROR
RAISE ;
ENDPROC
PROC Encode_Short(VAR LabComm_Stream s, num v)
VAR rawbytes buffer;
PackRawBytes v, buffer, \Network, 1, \IntX:=INT;
SocketSend s.soc, \RawData:=buffer, \NoOfBytes:=2;
ERROR
RAISE ;
ENDPROC
PROC Decode_Integer(VAR LabComm_Stream s, VAR num v, \ VAR rawbytes collect)
VAR rawbytes buffer;
SocketReceive s.soc,\RawData:=buffer,\ReadNoOfBytes:=4;
UnpackRawBytes buffer,\Network,1,v,\IntX:=DINT;
IF Present(collect) THEN
CopyRawBytes buffer, 1, collect, (RawBytesLen(collect)+1);
ENDIF
ERROR
RAISE ;
ENDPROC
PROC Encode_Integer(VAR LabComm_Stream s, num v)
VAR rawbytes buffer;
PackRawBytes v,buffer,\Network,1,\IntX:=DINT;
SocketSend s.soc,\RawData:=buffer,\NoOfBytes:=4;
ERROR
RAISE ;
ENDPROC
PROC Decode_Long(VAR LabComm_Stream s, VAR dnum v, \ VAR rawbytes collect)
VAR rawbytes buffer;
SocketReceive s.soc,\RawData:=buffer,\ReadNoOfBytes:=8;
UnpackRawBytes buffer,\Network,1,v,\IntX:=LINT;
IF Present(collect) THEN
CopyRawBytes buffer, 1, collect, (RawBytesLen(collect)+1);
ENDIF
ERROR
RAISE ;
ENDPROC
PROC Encode_Long(VAR LabComm_Stream s, dnum v)
VAR rawbytes buffer;
PackRawBytes v,buffer,\Network,1,\IntX:=LINT;
SocketSend s.soc,\RawData:=buffer,\NoOfBytes:=8;
ERROR
RAISE ;
ENDPROC
PROC Decode_Float(VAR LabComm_Stream s,VAR num v, \ VAR rawbytes collect)
VAR rawbytes buffer;
SocketReceive s.soc,\RawData:=buffer,\ReadNoOfBytes:=4;
UnpackRawBytes buffer,\Network,1,v,\Float4;
IF Present(collect) THEN
CopyRawBytes buffer, 1, collect, (RawBytesLen(collect)+1);
ENDIF
ERROR
RAISE ;
ENDPROC
PROC Encode_Float(VAR LabComm_Stream s, num v)
VAR rawbytes buffer;
PackRawBytes v, buffer,\Network,1,\Float4;
SocketSend s.soc,\RawData:=buffer,\NoOfBytes:=4;
ERROR
RAISE ;
ENDPROC
PROC Decode_String(VAR LabComm_Stream st,VAR string s, \ VAR rawbytes collect)
VAR rawbytes buffer;
VAR num length;
IF Present(collect) THEN
Decode_Packed st, length, \collect:=collect;
ELSE
Decode_Packed st, length;
ENDIF
SocketReceive st.soc,\Str:=s,\ReadNoOfBytes:=length;
IF Present(collect) THEN
PackRawBytes s, collect, (RawBytesLen(collect)+1), \ASCII;
ENDIF
ERROR
RAISE ;
ENDPROC
PROC Encode_String(VAR LabComm_Stream st, string s)
VAR rawbytes buffer;
VAR num length;
length := StrLen(s);
Encode_Packed st, length;
SocketSend st.soc,\Str:=s,\NoOfBytes:=length;
ERROR
RAISE ;
ENDPROC
PROC Encoder_Register_Sample(VAR Encoder e, VAR LabComm_Stream st, VAR LabComm_Encoder_Sample s)
s.user_id := e.next_user_id;
e.next_user_id := e.next_user_id + 1;
Encode_Packed st, SAMPLE_DECL;
Encode_Packed st, s.user_id;
Encode_String st, s.name;
% s.prefix + ":Encode_Signature_" + s.name % e, st;
ERROR
RAISE ;
ENDPROC
PROC Collect_Array(VAR LabComm_Stream s, VAR rawbytes sig)
VAR num num_dim;
VAR num dims;
Decode_Packed s, num_dim, \collect:=sig;
FOR i FROM 1 TO num_dim DO
Decode_Packed s, dims, \collect:=sig;
ENDFOR
Collect_Signature s, sig;
ERROR
RAISE ;
ENDPROC
PROC Collect_Struct(VAR LabComm_Stream s, VAR rawbytes sig)
VAR num num_elements;
VAR string tmp;
Decode_Packed s, num_elements, \collect:=sig;
FOR i FROM 1 TO num_elements DO
Decode_String s, tmp, \collect:=sig;
Collect_Signature s, sig;
ENDFOR
ERROR
RAISE ;
ENDPROC
PROC Collect_Signature(VAR LabComm_Stream s, VAR rawbytes sig)
VAR num type_id;
Decode_Packed s, type_id, \collect:=sig;
TEST type_id
CASE STRUCT_TYPE:
Collect_Struct s, sig;
CASE ARRAY_TYPE:
Collect_Array s, sig;
CASE BYTE_TYPE, BOOL_TYPE, SHORT_TYPE, INT_TYPE, LONG_TYPE, SHORT_TYPE:
DEFAULT:
RAISE IMPLEMENTATION_LIMIT_REACHED;
ENDTEST
ERROR
RAISE ;
ENDPROC
PROC Decode_One(VAR Decoder d, VAR LabComm_Stream s, VAR LabComm_Decoder_Sample samples{*})
VAR rawbytes buffer;
VAR num packet_type;
VAR num user_id;
VAR string type_name;
Decode_Packed s, packet_type;
WHILE packet_type = SAMPLE_DECL DO
Decode_Packed s, user_id;
Decode_String s, type_name;
Collect_Signature s, buffer;
FOR i FROM 1 TO Dim(samples, 1) DO
% samples{i}.prefix + ":Reg_If_Signature_Of_" + samples{i}.name % samples{i}, buffer, user_id;
ENDFOR
Decode_Packed s, packet_type;
ENDWHILE
IF packet_type >= SAMPLE_DATA THEN
FOR i FROM 1 TO Dim(samples, 1) DO
IF samples{i}.user_id = packet_type THEN
% samples{i}.prefix + ":Decode_And_Handle_" + samples{i}.name % d, s, samples{i};
ENDIF
ENDFOR
RETURN ;
ENDIF
RAISE UNKNOWN_PACKET_TYPE;
ERROR
RAISE ;
ENDPROC
PROC Init_Decoder(VAR Decoder d, VAR LabComm_Stream s)
VAR string version;
Decode_String s,version;
IF version<>LabCommVersion THEN
RAISE INCORRECT_LABCOMM_VERSION;
ENDIF
ERROR
RAISE ;
ENDPROC
PROC Init_Encoder(VAR Encoder e, VAR LabComm_Stream s)
Encode_String s, LabCommVersion;
e.next_user_id := SAMPLE_DATA;
ERROR
RAISE ;
ENDPROC
ENDMODULE
lib/RAPID/README 0 → 100644
View file @ d3921882
The implementation of LabComm in RAPID
Limitations of this implementation:
- The type double is not available due to limitations in RAPID. There is a
non-integer type with 64 bits but there is not marshalling utilities for it.
- Variable sized arrays is not available. There is no dynamic allocation,
possible solution is a max-size array (1024) and a integervalue denoting the
size.
- A RECORD (struct) cannot contain an array, but fixed size arrays are
available both in structs and stand alone. The current implementation creates
a RECORD with one member for each index in the array. Not an omptimal
solution, the alternativ would be a seperate variable.
- Decoding and encoding is done directly from a TCP socket.
- Every generated procedure is namespaced by declaring them LOCAL to the
generated module. They must be called by using runtime binding of procedure
names ( % proc_name % arg1, arg2, ...;). The generated types are not
declared local.
Usage:
# Declare a stream, LabComm_Stream:
$ VAR LabComm_Stream st;
This contains a socketdev wich must be created and connected or instatiated
through an accept.
$ SocketCreate st.soc;
$ SocketConnect st.soc, "127.0.0.1", 55555;
or
$ SocketAccept server_socket, st.soc;
# Initiate Encoder and/or Decoder with the stream:
$ VAR Decoder d;
$ Init_Decoder d, st;
$ VAR Encoder e;
$ Init_Encoder e, st;
This will read/write the version of LabComm to ensure compatibility, current
version is "LabComm2014".
# Initiate the labcomm samples:
LabComm trusts the application to manage each sample. It requests the samples,
as a list, when performing decoding or encoding.
This is done through the generated code which implies the procedures are LOCAL
and must be called with runtime bindings.
When initiating a decoder sample the name of the callback procedure to receive
such samples is suplied as a string.
$ PROC handle_samplename(prefix_samplename val)
$ ...
$ ENDPROC
$ VAR LabComm_Decoder_Sample ds{1};
$ % prefix:Dec_Reg_samplename % ds{1}, "handle_samplename";
NOTE: The callback must be of type procedure and not function. Functions cannot
be called with runtime bindings.
When initiating an encoder sample the stream must be supplied to let the
encoder send the sample signature.
$ VAR LabComm_Encoder_Sample es{1};
$ % prefix:Enc_Reg_samplename % e, st, es{1};
# Encode and/or decode samples:
$ Decode_One d, st, ds;
It returns as soon as any sample is decoded. The decoded sample is supplied as
argument to the callback procedure registered with the corresponding sample.
$ VAR prefix_samplename val;
$ <init val>
$ % prefix:Encode_samplename % e, st, es{1}, val;
# Complete example:
## LabComm definition:
example.lc >>
sample struct {
short sum;
short terms[2];
} foo;
<< EOF
## RAPID CODE
PROC handle_foo(example_foo val)
IF val.sum = val.terms.e1 + val.terms.e2 THEN
TPWrite "Verification successfull!";
ELSE
TPWrite "Verification failed!";
ENDIF
ENDPROC
PROC main()
VAR Decoder d;
VAR Encoder e;
VAR LabComm_Stream st;
VAR LabComm_Encoder_Sample es{1};
VAR LabComm_Decoder_Sample ds{1};
VAR example_foo val := [2,[1,1]];
SocketCreate st.soc;
SocketConnect st.soc, "127.0.0.1", 55555;
Init_Decoder d, st;
Init_Encoder e, st;
% "example:Enc_Reg_foo" % e, st, es{1};
% "example:Dec_Reg_foo" % ds{1}, "handle_foo";
% "example:Encode_foo" % e, st, es{1}, val;
Decode_One d, st, ds;
SocketClose st.soc;
ENDPROC
lib/c/.gitignore 0 → 100644
View file @ d3921882
liblabcomm.a
liblabcomm.so
liblabcomm.so.1
liblabcomm2006.so.1
liblabcomm2006.so
liblabcomm2006.a
liblabcomm2014.so.1
liblabcomm2014.so
liblabcomm2014.a
lib/c/2014/Makefile 0 → 100644
View file @ d3921882
## Macros
VERSION=2014
LIBVERSION=2014
include ../os_compat.mk
ALL_DEPS=../liblabcomm$(LIBVERSION).a ../liblabcomm$(LIBVERSION).so
# TODO: Support for Codesourcery ARM toolchain.
OBJS=labcomm$(VERSION).o \
labcomm$(VERSION)_memory.o \
labcomm$(VERSION)_error.o \
labcomm$(VERSION)_default_error_handler.o \
labcomm$(VERSION)_default_memory.o \
labcomm$(VERSION)_default_scheduler.o \
labcomm$(VERSION)_time.o \
labcomm$(VERSION)_scheduler.o \
labcomm$(VERSION)_encoder.o \
labcomm$(VERSION)_decoder.o \
labcomm$(VERSION)_dynamic_buffer_writer.o \
labcomm$(VERSION)_fd_reader.o \
labcomm$(VERSION)_type_signature.o \
labcomm$(VERSION)_fd_writer.o \
labcomm$(VERSION)_pthread_scheduler.o \
labcomm$(VERSION)_renaming.o \
labcomm$(VERSION)_renaming_registry.o \
labcomm$(VERSION)_renaming_encoder.o \
labcomm$(VERSION)_renaming_decoder.o
# Enable experimental objects by `make LABCOMM_EXPERIMENTAL=true`
ifeq ($(LABCOMM_EXPERIMENTAL),true)
OBJS += experimental/udp_hack.o experimental/ethaddr.o \
experimental/labcomm_thr_reader_writer.o \
experimental/ThrottleDrv/ethernet_drv.o \
experimental/ThrottleDrv/throttle_drv.o \
experimental/labcomm_udp_reader_writer.o
endif
# Enable experimental objects by `make LABCOMM_SIG_PARSER=true`
ifeq ($(LABCOMM_SIG_PARSER),true)
OBJS += experimental/labcomm2014_sig_parser.o
endif
LABCOMM_JAR=../../../compiler/labcomm$(LIBVERSION)_compiler.jar
LABCOMM=java -jar $(LABCOMM_JAR)
TESTS=test_labcomm_basic_type_encoding \
test_labcomm_generated_encoding \
test_signature_numbers \
test_labcomm \
test_labcomm_pthread_scheduler \
test_labcomm_copy \
test_labcomm_renaming_registry \
test_labcomm_renaming_encoder \
test_labcomm_renaming_decoder
#FIXME: test_labcomm_errors
TEST_DIR=test
## Targets
.PHONY: all
all: $(ALL_DEPS)
.PHONY: test
test: all $(TESTS:%=run-test-%)
.PHONY: clean
clean:
$(RM) *.o
$(RM) experimental/*.o
$(RM) experimental/ThrottleDrv/*.o
$(RM) test/*.o
$(RM) test/*.gch
$(RM) test/test_labcomm_errors
$(RM) test/testdata/gen/*.[cho]
$(RM) test/gen/*.[cho]
$(RM) -rf test/gen
.PHONY: distclean
distclean: clean
$(RM) ../liblabcomm$(LIBVERSION).so.1
$(RM) ../liblabcomm$(LIBVERSION).a
# rules invoked by 'all'
../liblabcomm$(LIBVERSION).so: ../liblabcomm$(LIBVERSION).so.1
if [ -h $@ ] ; then rm $@ ; fi
ln -s $(<:../%=%) $@
../liblabcomm$(LIBVERSION).so.1: $(OBJS:%.o=%.pic.o)
$(call MAKESHARED,$@,$(@:../%=%),$^)
../liblabcomm$(LIBVERSION).a: $(OBJS)
ar -r $@ $^
# Enable sig parser objects by `make labcomm2014_sig_PARSER=true`
ifeq ($(LABCOMM_SIG_PARSER),true)
experimental/test_sig_parser : experimental/labcomm2014_sig_parser.o experimental/test_sig_parser.c
endif
# compilation rules
%.pic.o: %.c
$(CC) -fPIC $(CFLAGS) -c -o $@ $<
%.o: %.c %.h
$(CC) $(CFLAGS) -c -o $@ $<
# rules invoked by 'test'
.PHONY: run-test-%
run-test-%: $(TEST_DIR)/gen/% | $(TEST_DIR)/gen
$(VALGRIND) $<
.PRECIOUS: $(TEST_DIR)/gen/%
$(TEST_DIR)/gen/%: $(TEST_DIR)/gen/%.o | $(TEST_DIR)/gen
$(LD) $(LDFLAGS) -o $@ $^ $(LDLIBS)
$(TEST_DIR)/gen/%.o: $(TEST_DIR)/%.c | $(TEST_DIR)/gen
$(CC) $(CFLAGS_TEST) -o $@ -c $<
.PRECIOUS: $(TEST_DIR)/gen/%.c
.PRECIOUS: $(TEST_DIR)/gen/%.h
$(TEST_DIR)/gen/%.c $(TEST_DIR)/gen/%.h: $(TEST_DIR)/%.lc | $(TEST_DIR)/gen
$(LABCOMM) \
--c=$(TEST_DIR)/gen/$*.c \
--h=$(TEST_DIR)/gen/$*.h \
$<
$(LABCOMM_JAR):
@echo "======Building LabComm compiler======"
cd $(shell dirname $(LABCOMM_JAR)); ant jar
@echo "======End building LabComm compiler======"
$(TEST_DIR)/gen:
mkdir -p $@
# Extra compilation dependencies
labcomm$(VERSION).o: \
labcomm$(VERSION).c \
labcomm$(VERSION).h \
labcomm$(VERSION)_private.h
labcomm$(VERSION)_fd_reader.o: \
labcomm$(VERSION)_private.h
labcomm$(VERSION)_fd_writer.o: \
labcomm$(VERSION)_private.h
labcomm$(VERSION)_dynamic_buffer_writer.o: \
labcomm$(VERSION)_private.h
$(TEST_DIR)/gen/test_labcomm_basic_type_encoding.o: \
labcomm$(VERSION)_private.h
$(TEST_DIR)/gen/test_labcomm_generated_encoding.o: \
labcomm$(VERSION)_private.h \
$(TEST_DIR)/gen/generated_encoding.h
$(TEST_DIR)/gen/test_labcomm_generated_encoding: \
$(TEST_DIR)/gen/generated_encoding.o
$(TEST_DIR)/gen/test_signature_numbers.c: \
$(TEST_DIR)/gen/another_encoding.h \
$(TEST_DIR)/gen/generated_encoding.h
$(TEST_DIR)/gen/test_signature_numbers: \
$(TEST_DIR)/gen/another_encoding.o \
$(TEST_DIR)/gen/generated_encoding.o
$(TEST_DIR)/gen/test_labcomm: \
$(TEST_DIR)/gen/test_sample.o
$(TEST_DIR)/gen/test_labcomm_copy: \
$(TEST_DIR)/gen/generated_encoding.o \
$(TEST_DIR)/gen/test_sample.o \
$(TEST_DIR)/gen/more_types.o
$(TEST_DIR)/gen/test_labcomm_renaming_registry: \
$(TEST_DIR)/gen/generated_encoding.o
$(TEST_DIR)/gen/test_labcomm_renaming_encoder: \
$(TEST_DIR)/gen/generated_encoding.o
$(TEST_DIR)/gen/test_labcomm_renaming_decoder: \
$(TEST_DIR)/gen/generated_encoding.o
lib/c/experimental/ThrottleDrv/display.h → lib/c/2014/experimental/ThrottleDrv/display.h
View file @ d3921882
#define PC_MODE
#ifdef PC_MODE
#include <stdio.h>
#define DISPLAY_ERR(s) perror(s);
// Some projects can not use stdio.h.
#ifndef LABCOMM_NO_STDIO
#include <stdio.h>
#endif
#else
#define DISPLAY_ERR(s) ;
#endif
lib/c/experimental/ThrottleDrv/ethernet_drv.c → lib/c/2014/experimental/ThrottleDrv/ethernet_drv.c
View file @ d3921882
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <linux/if_ether.h>
#include <linux/if_packet.h>
#include <linux/if_arp.h>
#include <netinet/in.h>
//#include <linux/if_ether.h>
//#include <linux/if_packet.h>
//#include <linux/if_arp.h>
#include <net/if.h>
#include <netpacket/packet.h>
//#include <netinet/in.h>
#include "ethernet_drv.h"
#include "display.h"
// Some projects can not use stdio.h.
#ifndef LABCOMM_NO_STDIO
#include <stdio.h>
#endif
/** LOCAL FUNCTIONS **/
/* local type for the ethernet interface */
struct eth_int_t
{
unsigned char mac_adr[ETH_ALEN]; /* MAC address */
struct ether_addr mac_adr; /* MAC address */
int socket_id; /* socket file descriptor */
int index; /* index of the eth interface */
unsigned char validity;
......@@ -72,7 +77,7 @@ struct eth_int_t* eth_open(const char* eth_int_name)
else
{
/* copy the MAC address into the eth interface struct */
memcpy(tmp_eth->mac_adr, ifr.ifr_hwaddr.sa_data, ETH_ALEN);
memcpy(tmp_eth->mac_adr.ether_addr_octet, ifr.ifr_hwaddr.sa_data, ETH_ALEN);
/*retrieve the Ethernet interface index*/
if (ioctl(tmp_eth->socket_id, SIOCGIFINDEX, &ifr) == -1)/* error during the retrieve of index */
......@@ -87,7 +92,7 @@ struct eth_int_t* eth_open(const char* eth_int_name)
/* copy the interface index into the eth interface struct */
tmp_eth->index = ifr.ifr_ifindex;
printf("Successfully got our MAC address: %02X:%02X:%02X:%02X:%02X:%02X\n",
tmp_eth->mac_adr[0],tmp_eth->mac_adr[1],tmp_eth->mac_adr[2],tmp_eth->mac_adr[3],tmp_eth->mac_adr[4],tmp_eth->mac_adr[5]);
tmp_eth->mac_adr.ether_addr_octet[0],tmp_eth->mac_adr.ether_addr_octet[1],tmp_eth->mac_adr.ether_addr_octet[2],tmp_eth->mac_adr.ether_addr_octet[3],tmp_eth->mac_adr.ether_addr_octet[4],tmp_eth->mac_adr.ether_addr_octet[5]);
printf("Successfully got interface index for %s: %i\n",eth_int_name, tmp_eth->index);
}
}
......@@ -130,7 +135,7 @@ int eth_close(struct eth_int_t* eth_int)
/***
Returns the MAC address of the Ethernet Interface
***/
int eth_getMACadr(const struct eth_int_t* eth_int, unsigned char* mac_adr)
int eth_getMACadr(const struct eth_int_t* eth_int, struct ether_addr * mac_adr)
{
int ret = 0;
......@@ -143,7 +148,7 @@ int eth_getMACadr(const struct eth_int_t* eth_int, unsigned char* mac_adr)
else
{
/* TO-DO: introduce a validity flag to be check before accessing to eth_int (better a crc) */
memcpy(mac_adr, eth_int->mac_adr, ETH_ALEN);
memcpy(mac_adr, &eth_int->mac_adr, sizeof(mac_adr));
}
return(ret);
}
......@@ -170,11 +175,6 @@ int eth_send(const struct eth_int_t* eth_int, const unsigned char* eth_frame, un
/*prepare sockaddr_ll (address structure for PACKET_SOCKET) */
socket_address.sll_family = AF_PACKET;
socket_address.sll_protocol = htons(ETH_P_IP); /* Physical layer protocol */
socket_address.sll_ifindex = eth_int->index; /* Ethernet Interface index */
socket_address.sll_hatype = ARPHRD_ETHER; /* ARP hardware identifier: Ethernet */
socket_address.sll_pkttype = PACKET_OTHERHOST; /* Packet type: Another host */
socket_address.sll_halen = ETH_ALEN; /* Length of the MAC address */
socket_address.sll_addr[0] = eth_header->h_dest[0];
socket_address.sll_addr[1] = eth_header->h_dest[1];
socket_address.sll_addr[2] = eth_header->h_dest[2];
......@@ -183,6 +183,16 @@ int eth_send(const struct eth_int_t* eth_int, const unsigned char* eth_frame, un
socket_address.sll_addr[5] = eth_header->h_dest[5];
socket_address.sll_addr[6] = 0x00; /* not used */
socket_address.sll_addr[7] = 0x00; /* not used */
socket_address.sll_halen = ETH_ALEN; /* Length of the MAC address */
socket_address.sll_ifindex = eth_int->index; /* Ethernet Interface index */
// The rest should be zero for sending, and are set by the system for receiving.
socket_address.sll_hatype = 0;
socket_address.sll_protocol = 0;
socket_address.sll_pkttype = 0;
//socket_address.sll_protocol = htons(ETH_P_IP); /* Physical layer protocol */
//socket_address.sll_hatype = ARPHRD_ETHER; /* ARP hardware identifier: Ethernet */
//socket_address.sll_pkttype = PACKET_OTHERHOST; /* Packet type: Another host */
/*send the Ethernet frame */
ret = sendto(eth_int->socket_id, eth_frame, length, 0, (struct sockaddr*)&socket_address, sizeof(socket_address));
......
lib/c/experimental/ThrottleDrv/ethernet_drv.h → lib/c/2014/experimental/ThrottleDrv/ethernet_drv.h
View file @ d3921882
#ifndef _ETHERNET_DRV_H_
#define _ETHERNET_DRV_H_
#include <net/ethernet.h>
struct eth_int_t;
struct eth_int_t* eth_open(const char* eth_int_name);
int eth_close(struct eth_int_t* eth_int);
int eth_getMACadr(const struct eth_int_t* eth_int, unsigned char* mac_adr);
int eth_getMACadr(const struct eth_int_t* eth_int, struct ether_addr *mac_adr);
int eth_send(const struct eth_int_t* eth_int, const unsigned char* eth_frame, unsigned short length);
int eth_receive (const struct eth_int_t* eth_int, unsigned char* eth_frame, unsigned short length);
......
lib/c/experimental/ThrottleDrv/throttle_drv.c → lib/c/2014/experimental/ThrottleDrv/throttle_drv.c
View file @ d3921882
......@@ -5,10 +5,9 @@
#include "stdlib.h"
#include <string.h>
#include <time.h>
#include <arpa/inet.h>
// #include <arpa/inet.h>
#define THROTTLENET_PROTO 0x544e
#define ETH_ADR_LEN 6
#define THR_DST_ADR_POS 0
#define THR_SRC_ADR_POS (THR_DST_ADR_POS + sizeof(((thr_header_t*)0)->dst_adr)) //6
......@@ -20,8 +19,8 @@
#define THR_PAYLOAD_POS (THR_FRAG_LEN_POS + sizeof(((thr_header_t*)0)->frag_len)) //21
#define THR_MSG_HEADER_LEN THR_PAYLOAD_POS
#define THR_MSG_DST_ADR(thr_msg) (unsigned char*)(&thr_msg[THR_DST_ADR_POS])
#define THR_MSG_SRC_ADR(thr_msg) (unsigned char*)(&thr_msg[THR_SRC_ADR_POS])
#define THR_MSG_DST_ADR(thr_msg) (struct ether_addr*)(&thr_msg[THR_DST_ADR_POS])
#define THR_MSG_SRC_ADR(thr_msg) (struct ether_addr*)(&thr_msg[THR_SRC_ADR_POS])
#define THR_MSG_ETH_TYP(thr_msg) *(unsigned short*)(&thr_msg[THR_ETH_TYP_POS])
#define THR_MSG_CHN_ID(thr_msg) *(unsigned char*)(&thr_msg[THR_CHN_ID_POS])
#define THR_MSG_FRAG_NUM(thr_msg) *(unsigned short*)(&thr_msg[THR_FRAG_NUM_POS])
......@@ -33,20 +32,21 @@
/* local type for the Throttle Channel structure */
struct thr_chn_t
{
unsigned char dst_adr[ETH_ADR_LEN];/* destination MAC address */
struct ether_addr dst_adr; /* destination MAC address */
unsigned char id; /* Channel id */
unsigned short frag_size; /* Fragment size */
unsigned short freq; /* Message transmission frequency */
thr_msg_handler_t funct; /* Callback function invoked at the reception */
unsigned short msg_length;
unsigned char* p_msg;
struct ether_addr last_sender_adr;/* src MAC address of last message */
};
/* Type for the Throttle message */
typedef struct
{
unsigned char dst_adr[ETH_ADR_LEN]; /* destination MAC address */
unsigned char src_adr[ETH_ADR_LEN]; /* source MAC address */
struct ether_addr dst_adr; /* destination MAC address */
struct ether_addr src_adr; /* source MAC address */
unsigned short eth_type; /* ethernet packet type */
unsigned char chn_id; /* channel identification */
unsigned short frag_num; /* fragment number */
......@@ -104,7 +104,7 @@ int thr_init(const char* eth_int_name)
* @retval struct thr_chn_t*: pointer to the Channel structure. NULL on error and errno is set appropriately.
*
*******************************************************************************/
struct thr_chn_t* thr_open_chn(const unsigned char* dst_adr, unsigned char chn_id, unsigned char frag_size, unsigned short freq, const thr_msg_handler_t funct)
struct thr_chn_t* thr_open_chn(const struct ether_addr* dst_adr, unsigned char chn_id, unsigned char frag_size, unsigned short freq, const thr_msg_handler_t funct)
{
struct thr_chn_t* tmp_chn = NULL; /* pointer to Channel structure */
......@@ -127,7 +127,7 @@ struct thr_chn_t* thr_open_chn(const unsigned char* dst_adr, unsigned char chn_i
else
{
/* Update the Channel structure */
memcpy(tmp_chn->dst_adr, dst_adr, sizeof(tmp_chn->dst_adr));
memcpy(&tmp_chn->dst_adr, dst_adr, sizeof(tmp_chn->dst_adr));
tmp_chn->id = chn_id;
tmp_chn->frag_size = frag_size;
tmp_chn->freq = freq;
......@@ -142,6 +142,9 @@ struct thr_chn_t* thr_open_chn(const unsigned char* dst_adr, unsigned char chn_i
return(tmp_chn);
}
void thr_close_chn(struct thr_chn_t* c){
free(c);
}
/**
* @fn int thr_send(const struct thr_chn_t* thr_chn, const char* data, unsigned int length)
......@@ -188,7 +191,7 @@ int thr_send(const struct thr_chn_t* thr_chn, const char* data, unsigned int len
else
{
/* Compose the Ethernet Frame to be sent */
memcpy(THR_MSG_DST_ADR(thr_msg), &thr_chn->dst_adr[0], ETH_ADR_LEN); /* Destiantion MAC Address */
memcpy(THR_MSG_DST_ADR(thr_msg), &thr_chn->dst_adr, sizeof(thr_chn->dst_adr)); /* Destiantion MAC Address */
eth_getMACadr(eth_int, THR_MSG_SRC_ADR(thr_msg)); /* Source MAC Address */
THR_MSG_ETH_TYP(thr_msg) = htons(THROTTLENET_PROTO); /* Ethernet Packet Type */
THR_MSG_CHN_ID(thr_msg) = thr_chn->id; /* Channel identification */
......@@ -317,6 +320,7 @@ int thr_receive(struct thr_chn_t* thr_chn, unsigned char* data, void* param)
#endif
thr_chn->msg_length = ret;
memcpy(thr_chn->p_msg, data, ret); /* copy the msg into the thr structure */
memcpy(&thr_chn->last_sender_adr, THR_MSG_SRC_ADR(thr_msg), 6); /* ... and the address of the sender */
#ifdef DEBUG
printf("thr_receive: calling %x\n", thr_chn->funct);
#endif
......@@ -395,3 +399,11 @@ int thr_read(struct thr_chn_t* thr_chn, unsigned char* data, int length)
}
return(ret);
}
struct ether_addr* get_sender_addr(struct thr_chn_t* ch) {
return &ch->last_sender_adr;
}
unsigned char get_channel(struct thr_chn_t* ch) {
return ch->id;
}
lib/c/experimental/ThrottleDrv/throttle_drv.h → lib/c/2014/experimental/ThrottleDrv/throttle_drv.h
View file @ d3921882
#ifndef _THROTTLE_DRV_H_
#define _THROTTLE_DRV_H_
#define ETH_ADR_SIZE 6
//#define ETH_ADR_SIZE 6
#include <net/ethernet.h>
/* typedef of the callback used to manage the received Ethernet Frame (the User Data)*/
typedef int (*thr_msg_handler_t)(void* data);
......@@ -9,9 +13,12 @@ struct thr_chn_t;
int thr_init(const char* eth_int);
struct thr_chn_t* thr_open_chn(const unsigned char* dst_adr, unsigned char chn_id, unsigned char frag_size, unsigned short freq, thr_msg_handler_t funct);
struct thr_chn_t* thr_open_chn(const struct ether_addr* dst_adr, unsigned char chn_id, unsigned char frag_size, unsigned short freq, thr_msg_handler_t funct);
void thr_close_chn(struct thr_chn_t* c);
int thr_receive (struct thr_chn_t* thr_chn, unsigned char* data, void* param);
int thr_send(const struct thr_chn_t* thr_chn, const char* data, unsigned int length);
int thr_read(struct thr_chn_t* thr_chn, unsigned char* data, int length);
struct ether_addr * get_sender_addr(struct thr_chn_t* ch);
unsigned char get_channel(struct thr_chn_t* ch);
#endif
lib/c/experimental/ethaddr.c → lib/c/2014/experimental/ethaddr.c
View file @ d3921882
#include <stdio.h>
#include "ethaddr.h"
// Some projects can not use stdio.h.
#ifndef LABCOMM_NO_STDIO
#include <stdio.h>
#endif
#if ETH_ALEN != 6
#warning "Assumption that ETH_ALEN == 6 appears false. Here be dragons."
#endif
/* parse a string on the format 00:01:02:0d:0e:0f into a char array
* the mac_addr argument must be at least six bytes.
* returns 0 on success, or -1 on error
*/
int parse_MAC_address(const char *str, unsigned char mac_addr[])
int parse_MAC_address(const char *str, struct ether_addr *mac_addr)
{
int res = sscanf(str, "%x:%x:%x:%x:%x:%x", &mac_addr[0], &mac_addr[1],
&mac_addr[2], &mac_addr[3], &mac_addr[4], &mac_addr[5]);
int res = sscanf(str, "%x:%x:%x:%x:%x:%x", &mac_addr->ether_addr_octet[0],
&mac_addr->ether_addr_octet[1],
&mac_addr->ether_addr_octet[2],
&mac_addr->ether_addr_octet[3],
&mac_addr->ether_addr_octet[4],
&mac_addr->ether_addr_octet[5]);
return (res == 6? 0 : -1);
}
......
lib/c/experimental/ethaddr.h → lib/c/2014/experimental/ethaddr.h
View file @ d3921882
#ifndef ETHADDR_H
#define ETHADDR_H
#include <net/ethernet.h>
/* parse a string on the format 00:01:02:0d:0e:0f into a char array
* the mac_addr argument must be at least six bytes.
* returns 0 on success, or -1 on error
*/
int parse_MAC_address(const char *str, unsigned char mac_addr[]);
int parse_MAC_address(const char *str, struct ether_addr *mac_addr);
#endif
lib/c/2014/experimental/labcomm2014_sig_parser.c 0 → 100644
View file @ d3921882
/* labcomm2014_sig_parser.c:
* an example parser for labcomm signatures, illustrating how to skip samples
* based on their signature. Intended as an embryo for introducing this
* functionality into the lib to allow a channel to survive types with no
* registered handler.
*/
/* TODO, and notes about strange quirks
*
* - the return values for the accept_ functions are not really used anymore
* as the parser "peeks" and calls the correct accept function instead.
* This should be refactored
*
* - The RETURN_STRINGS and where/if to allocate strings is to be decided, it
* is currently not used
*
* - The dynamic allocation of the parser is not quite dynamic, the sizes are
* set through the init function, and are then static.
* This should be adapted when allocation is parameterized/user-definable
* for the entire lib.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "labcomm2014_sig_parser.h"
static void error(char *s) {
fprintf(stderr, "ERROR: %s", s);
fprintf(stderr, "\nexiting\n");
exit(1);
}
/* aux method for reading a big endian uint32 from a char* (i.e. ntohl but for explicit char*) */
static int unpack32(unsigned char *c, int idx) {
int b0=(c[idx]) << 3 ;
int b1=(c[idx+1]) << 2 ;
int b2=(c[idx+2]) << 1 ;
int b3=c[idx+3];
return b0 | b1 | b2 | b3;
}
static inline int get32(labcomm2014_sig_parser_t *b) {
int res = unpack32(b->c, b->idx);
b->idx+=4;
return res;
}
/* aux method for reading labcomm varint from a char*
size is an out parameter: if not NULL the number of bytes read will be written here
*/
static int unpack_varint(unsigned char *buf,
int idx,
size_t *size)
{
int res = 0;
unsigned int i=0;
unsigned char cont = LABCOMM2014_TRUE;
do {
unsigned char c = buf[idx+i];
res = (res << 7) | (c & 0x7f);
cont = c & 0x80;
i++;
} while(cont);
if(size != NULL)
*size = i;
return res;
}
void dumpValStack(labcomm2014_sig_parser_t *b) {
printf("=== value stack: ");
#ifdef DEBUG_STACK_VERBOSE
int i;
for(i=0; i<STACK_SIZE; i++) { //HERE BE DRAGONS
printf("%2.2x ", b->val_stack[i]);
}
#endif
printf(" top==%d\n", b->val_top);
}
void dumpPtrStack(labcomm2014_sig_parser_t *b) {
printf("=== pointer stack: ");
#ifdef DEBUG_STACK_VERBOSE
int i;
for(i=0; i<STACK_SIZE; i++) { //HERE BE DRAGONS
printf("%2.2x ", b->ptr_stack[i]);
}
#endif
printf(" top==%d\n", b->ptr_top);
}
void push_val(labcomm2014_sig_parser_t *b, unsigned int e) {
b->val_stack[b->val_top]=e;
b->val_top=b->val_top-1;
if(b->val_top<0) error("value stack overrun");
#if defined DEBUG && !defined QUIET_STACK
dumpValStack(b);
#endif
}
unsigned int pop_val(labcomm2014_sig_parser_t *b) {
b->val_top=b->val_top+1;
if(b->val_top>b->stacksize) error("value stack underrun");
#if defined DEBUG && !defined QUIET_STACK
dumpValStack(b);
#endif
return b->val_stack[b->val_top];
}
void push_ptr(labcomm2014_sig_parser_t *b, void* e) {
b->ptr_stack[b->ptr_top]=e;
b->ptr_top=b->ptr_top-1;
if(b->ptr_top<0) error("pointer stack overrun");
#ifdef DEBUG
dumpPtrStack(b);
#endif
}
void* pop_ptr(labcomm2014_sig_parser_t *b) {
b->ptr_top=b->ptr_top+1;
if(b->ptr_top>b->stacksize) error("pointer stack underrun");
#ifdef DEBUG
dumpPtrStack(b);
#endif
return b->ptr_stack[b->ptr_top];
}
int labcomm2014_sig_parser_init(labcomm2014_sig_parser_t *b, size_t buffer_size,
size_t stacksize, size_t num_signatures,
size_t max_name_len, size_t max_sig_len)
{
b->c = malloc(buffer_size);
b->capacity = buffer_size;
b->size = 0;
b->idx = 0;
b->stacksize = stacksize;
b->val_stack = calloc(stacksize, sizeof(b->val_stack));
b->val_top = stacksize-1;
b->ptr_stack = calloc(stacksize, sizeof(b->ptr_stack));
b->ptr_top = stacksize-1;
b->max_signatures = num_signatures;
b->max_name_len = max_name_len;
b->max_sig_len = max_sig_len;
#ifdef STATIC_ALLOCATION
printf("warning: labcomm2014_sig_parser_t_init: size params ignored, using defaults from .h file \n");
#else
b->sig_ts=calloc(num_signatures, sizeof(struct labcomm2014_signature));
b->signatures_length=calloc(num_signatures, sizeof(int));
b->signatures_name_length=calloc(num_signatures, sizeof(int));
b->signatures_name=calloc(num_signatures, sizeof(void *)); //HERE BE DRAGONS: add range checks
b->signatures=calloc(num_signatures, sizeof(void *));
int i;
for(i = 0; i<num_signatures; i++) {
b->signatures[i] = calloc(b->max_sig_len, sizeof(char));
b->signatures_name[i] = calloc(b->max_name_len, sizeof(char));
}
#endif
return b->c == NULL || b->val_stack == NULL || b->ptr_stack == NULL;
}
/* free the objects allocated by labcomm_sig_parser_init(b)
* NB! does not free b itself */
void labcomm2014_sig_parser_free(labcomm2014_sig_parser_t *b)
{
int i;
free(b->c);
free(b->val_stack);
free(b->ptr_stack);
#ifndef STATIC_ALLOCATION
for(i = 0; i<b->max_signatures; i++) {
free(b->signatures[i]);
free(b->signatures_name[i]);
}
free(b->signatures);
free(b->signatures_name);
free(b->signatures_name_length);
free(b->signatures_length);
free(b->sig_ts);
#endif
}
int labcomm2014_sig_parser_read_file(labcomm2014_sig_parser_t *b, FILE *f) {
int s = fread(b->c, sizeof(char), b->capacity, f);
b->size = s;
b->idx=0;
return s;
}
int more(labcomm2014_sig_parser_t *b)
{
return b->idx < b->size;
}
unsigned char get(labcomm2014_sig_parser_t *b) {
return b->c[b->idx++];
}
unsigned char peek(labcomm2014_sig_parser_t *b) {
return b->c[b->idx];
}
void advance(labcomm2014_sig_parser_t *b) {
b->idx++;
}
void advancen(labcomm2014_sig_parser_t *b, size_t n) {
b->idx+=n;
}
int peek_varint(labcomm2014_sig_parser_t *b, size_t *size) {
return unpack_varint(b->c, b->idx, size);
}
int get_varint(labcomm2014_sig_parser_t *b) {
size_t size;
int res = peek_varint(b, &size);
advancen(b, size);
return res;
}
int get_varint_size(labcomm2014_sig_parser_t *b, size_t *size) {
unsigned int res = peek_varint(b, size);
advancen(b, *size);
return res;
}
void getStr(labcomm2014_sig_parser_t *b, unsigned char *dest, size_t size) {
int rem = b->size - b->idx;
if( size > rem )
size = rem;
strncpy((char *)dest, (char *)&b->c[b->idx], size);
dest[size] = 0;
b->idx += size;
}
struct labcomm2014_signature *get_sig_t(labcomm2014_sig_parser_t *p, unsigned int uid)
{
return &(p->sig_ts[uid-LABCOMM_USER]);
}
unsigned int get_signature_len(labcomm2014_sig_parser_t *p, unsigned int uid){
//return signatures_length[uid-LABCOMM_USER];
return p->sig_ts[uid-LABCOMM_USER].size;
}
unsigned char* get_signature(labcomm2014_sig_parser_t *p, unsigned int uid){
//return signatures[uid-LABCOMM_USER];
return p->sig_ts[uid-LABCOMM_USER].signature;
}
//is this needed?
//unsigned int get_signature_name_len(labcomm2014_sig_parser_t *p, unsigned int uid){
// return signatures_name_length[uid-LABCOMM_USER];
//}
char* get_signature_name(labcomm2014_sig_parser_t *p, unsigned int uid){
//return signatures_name[uid-LABCOMM_USER];
return p->sig_ts[uid-LABCOMM_USER].name;
}
void dump_signature(labcomm2014_sig_parser_t *p, unsigned int uid){
int i;
unsigned int len = get_signature_len(p, uid);
printf("signature for uid %x : %s (len=%d):\n", uid, get_signature_name(p, uid), len);
unsigned char* sig = get_signature(p, uid);
for(i=0; i<len; i++) {
printf("%2.2x ",sig[i]);
if( i < len-1 && (i+1)%8==0 ) printf("\n");
}
printf("\n");
}
static inline void labcomm2014_sig_parser_t_set_varsize(labcomm2014_sig_parser_t *b)
{
b->current_decl_is_varsize = LABCOMM2014_TRUE;
}
static size_t labcomm2014_sizeof_primitive(unsigned int type)
{
switch(type) {
case TYPE_BOOLEAN :
case TYPE_BYTE :
return 1;
case TYPE_SHORT :
return 2;
case TYPE_INTEGER :
case TYPE_FLOAT :
case TYPE_SAMPLE_REF :
return 4;
case TYPE_LONG :
case TYPE_DOUBLE :
return 8;
default:
printf("labcomm2014_sizeof_primitive(%x)\n", type);
error("labcomm2014_sizeof_primitive should only be called for primitive types");
return 0;
}
}
//these are inlined in do_accept_packet
//static int accept_type_decl(labcomm2014_sig_parser_t *d);
//static int accept_sample_decl(labcomm2014_sig_parser_t *d);
static int accept_user_id(labcomm2014_sig_parser_t *d);
static int accept_string(labcomm2014_sig_parser_t *d);
static int accept_type(labcomm2014_sig_parser_t *d);
static int accept_array_decl(labcomm2014_sig_parser_t *d);
static int accept_intentions(labcomm2014_sig_parser_t *d);
#if 0
// UNUSED declarations
static int accept_string_length(labcomm2014_sig_parser_t *d);
static int accept_char(labcomm2014_sig_parser_t *d);
static int accept_number_of_indices(labcomm2014_sig_parser_t *d);
static int accept_indices(labcomm2014_sig_parser_t *d);
static int accept_variable_index(labcomm2014_sig_parser_t *d);
static int accept_fixed_index(labcomm2014_sig_parser_t *d);
static int accept_number_of_fields(labcomm2014_sig_parser_t *d);
#endif
static int accept_struct_decl(labcomm2014_sig_parser_t *d);
static int accept_field(labcomm2014_sig_parser_t *d);
static int accept_sample_data(labcomm2014_sig_parser_t *d);
static unsigned char labcomm2014_varint_sizeof(unsigned int i)
{
if(i < 128) {
return 1;
} else {
unsigned char res = 1;
while (i >>= 7) ++res;
return res;
}
}
int encoded_size_static(struct labcomm2014_signature *sig, void *unused)
{
#ifdef LABCOMM_EXPERIMENTAL_CACHED_ENCODED_SIZE
if(sig->cached_encoded_size == -1) {
error("encoded_size_static called for var_size sample or uninitialized signature");
}
return sig->cached_encoded_size;
#else
printf("Warning: encoded_size_static currently broken\n");
return -1;
#endif
}
/* This function probably never will be implemented, as it would be
similar to skip_packed_sample_data. And if unregistered variable size
samples is to be handled, the proper way is to generate and register
a handler. Thus, the most probable use of the encoded_size function
on the receiver side, is to skip unhandled samples.
*/
int encoded_size_parse_sig(struct labcomm2014_signature *sig, void *sample)
{
printf("Warning: encoded_size_parse_sig not implemented\n");
return -1;
}
static int accept_signature(labcomm2014_sig_parser_t *d,
labcomm2014_type type,
unsigned int start,
unsigned int uid, char *name)
{
get_varint(d); // ignore sig len
VERBOSE_PRINTF("\ntype = ");
accept_type(d);
//printf(" : ");
//unsigned int dt = pop(d);
#ifdef USE_TYPE_AND_SIZE
unsigned int type = pop_val(d);
unsigned int enc_size = pop_val(d);
#else
pop_val(d); // unsigned int type
pop_val(d); // unsigned int enc_size
#endif
if(type != PKG_SAMPLE_DECL) {
if(type == PKG_SAMPLE_REF) {
INFO_PRINTF("accept_signature: ignoring sample ref\n");
return LABCOMM2014_TRUE;
} else if (type == PKG_TYPE_DECL) {
INFO_PRINTF("accept_signature: ignoring typedef\n");
return LABCOMM2014_TRUE;
} else {
error("decl is neither sample, ref, or typedef???");
return LABCOMM2014_FALSE;
}
}
unsigned int end = d->idx;
unsigned int len = end-start;
struct labcomm2014_signature *newsig = get_sig_t(d, uid);
// newsig->type = type;
if(len <= d->max_sig_len) {
d->signatures_length[uid-LABCOMM_USER] = len;
memcpy(d->signatures[uid-LABCOMM_USER], &d->c[start], len);
newsig->size = len;
newsig->signature = d->signatures[uid-LABCOMM_USER];
newsig->name = name;
} else {
error("sig longer than max length (this ought to be dynamic...)");
}
VERBOSE_PRINTF("signature for uid %x: %s (start=%x,end=%x,len=%d)\n", uid, get_signature_name(d, uid), start,end, len);
INFO_PRINTF("accept_signature: %s\n", newsig->name);
#ifdef LABCOMM_EXPERIMENTAL_CACHED_ENCODED_SIZE
if(! d->current_decl_is_varsize) {
newsig->cached_encoded_size = enc_size;
newsig->encoded_size = encoded_size_static;
INFO_PRINTF(".... is static size = %d\n", enc_size);
} else {
newsig->cached_encoded_size = -1;
newsig->encoded_size = encoded_size_parse_sig;
INFO_PRINTF(".... is variable size\n");
}
#endif
return LABCOMM2014_TRUE;
}
static int accept_decl(labcomm2014_sig_parser_t *d, labcomm2014_type type)
{
if(accept_user_id(d)) {
unsigned int uid = pop_val(d);
VERBOSE_PRINTF(", intentions = ");
accept_intentions(d);
unsigned int start = d->idx;
unsigned int nstart = pop_val(d);
unsigned int nlen = pop_val(d);
#ifdef RETURN_STRINGS
char *str = (char *) pop_ptr(d);
free(str);
#endif
unsigned char lenlen = labcomm2014_varint_sizeof(nlen);
if(type != PKG_SAMPLE_DECL) {
// don't record typedefs and samplerefs (for now)
// to avoid number clashes with sample defs
// in the parser struct
return accept_signature(d, type, start, uid, (char *) &d->c[nstart+lenlen]);
}
if(nlen < d->max_name_len) { // leave 1 byte for terminating NULL
char *name;
d->signatures_name_length[uid-LABCOMM_USER] = nlen;
memcpy(d->signatures_name[uid-LABCOMM_USER], &d->c[nstart+lenlen], nlen);
d->signatures_name[uid-LABCOMM_USER][nlen]=0;
name = d->signatures_name[uid-LABCOMM_USER];
return accept_signature(d, type, start, uid, name);
} else {
error("sig name longer than max length (this ought to be dynamic...");
return LABCOMM2014_FALSE;
}
} else {
error("sample_decl with uid < LABCOMM_USER");
return LABCOMM2014_FALSE;
}
}
// HERE BE DRAGONS! what does the return value mean?
int accept_packet(labcomm2014_sig_parser_t *d) {
size_t nbytes;
unsigned int type = peek_varint(d, &nbytes) ;
if(type == PKG_VERSION ) {
advancen(d, nbytes);//consume type field
get_varint(d); //ignore length field
VERBOSE_PRINTF("got version.\n");
accept_string(d);
pop_val(d); // ignore length, for now
#ifdef RETURN_STRINGS
char *str = (char *) pop_ptr(d);
free(str);
#endif
} else if (type == PKG_SAMPLE_DECL) {
d->current_decl_is_varsize = LABCOMM2014_FALSE; // <-- a conveniance flag in labcomm2014_sig_parser_t
advancen(d, nbytes);
VERBOSE_PRINTF("sample_decl ");
get_varint(d); //ignore length field
accept_decl(d, type);
} else if (type == PKG_SAMPLE_REF) {
d->current_decl_is_varsize = LABCOMM2014_FALSE; // <-- a conveniance flag in labcomm2014_sig_parser_t
advancen(d, nbytes);
VERBOSE_PRINTF("sample_ref ");
get_varint(d); //ignore length field
accept_decl(d, type);
}else if(type == PKG_TYPE_DECL ) {
d->current_decl_is_varsize = LABCOMM2014_FALSE; // <-- a conveniance flag in labcomm2014_sig_parser_t
advancen(d, nbytes);//consume type field
VERBOSE_PRINTF("type_decl ");
get_varint(d); //ignore length field
accept_decl(d, type);
} else if (type == PKG_TYPE_BINDING) {
VERBOSE_PRINTF("type_binding ");
advancen(d, nbytes);
get_varint(d); //ignore length field
#ifdef VERBOSE
int sid =
#endif
get_varint(d); //ignore sample id field
#ifdef VERBOSE
int tid =
#endif
get_varint(d); //ignore type id field
VERBOSE_PRINTF("sid=0x%x, tid=0x%x\n ", sid, tid);
} else if(type >= LABCOMM_USER) {
#ifdef EXIT_WHEN_RECEIVING_DATA
printf("*** got sample data, exiting\n");
exit(0);
#else
accept_sample_data(d);
#endif
} else {
#ifdef EXIT_ON_UNKNOWN_TAG
error("got unknown type (<LABCOMM_USER)");
exit(1);
#else
int len = get_varint(d); // length field
printf("got unknown tag: 0x%x, skipping %d bytes\n",type, len);
advancen(d, len);
#endif
}
return LABCOMM2014_TRUE;
}
static int accept_user_id(labcomm2014_sig_parser_t *d){
size_t nbytes;
int uid = peek_varint(d, &nbytes);
if(uid >= LABCOMM_USER) {
advancen(d, nbytes);
VERBOSE_PRINTF("uid = 0x%x ", uid);
push_val(d, uid);
return LABCOMM2014_TRUE;
} else {
error("uid < LABCOMM_USER");
return LABCOMM2014_FALSE;
}
}
/** pushes (index in stream of name) and (length of name) */
static int accept_intentions(labcomm2014_sig_parser_t *d){
unsigned int num = get_varint(d);
int i;
int npos = 0;
int nlen = 0;
for(i=0; i<num; i++) {
int klen, vlen;
printf("( ");
#ifdef RETURN_STRINGS
char *key;
char *val;
#endif
accept_string(d);
klen = pop_val(d);
if(klen==0) {
npos = d->idx;
}
#ifdef RETURN_STRINGS
key = (char *) pop_ptr(d);
if(klen!=0) {
printf("%s] : ",key);
}
free(key);
#else
if(klen!=0) {
printf(": ");
} else {
printf("name: ");
}
#endif
accept_string(d);
printf(" ");
vlen = pop_val(d);
if(klen==0) {
nlen = vlen;
}
#ifdef RETURN_STRINGS
val = (char *) pop_ptr(d);
printf("%s %s",(klen?",val : ":""), val);
free(val);
#endif
printf(") ");
}
push_val(d, nlen);
push_val(d, npos);
return LABCOMM2014_TRUE;
}
static int accept_string(labcomm2014_sig_parser_t *d){
unsigned int len = get_varint(d);
unsigned char *str=malloc(len+1); // len is without terminating null
getStr(d, str, len);
VERBOSE_PRINTF("%s", str);
#ifdef RETURN_STRINGS
push_ptr(d, str);
#else
free(str);
#endif
push_val(d, len);
return LABCOMM2014_TRUE;
}
/* pushes size and type id */
static int accept_type(labcomm2014_sig_parser_t *d){
size_t nbytes;
unsigned int type = peek_varint(d, &nbytes) ;
switch(type) {
case TYPE_BOOLEAN :
VERBOSE_PRINTF("boolean\n");
advancen(d, nbytes);
push_val(d, 1);
break;
case TYPE_BYTE :
VERBOSE_PRINTF("byte\n");
advancen(d, nbytes);
push_val(d, 1);
break;
case TYPE_SHORT :
VERBOSE_PRINTF("short\n");
advancen(d, nbytes);
push_val(d, 2);
break;
case TYPE_INTEGER :
VERBOSE_PRINTF("integer\n");
advancen(d, nbytes);
push_val(d, 4);
break;
case TYPE_LONG :
VERBOSE_PRINTF("long\n");
advancen(d, nbytes);
push_val(d, 8);
break;
case TYPE_FLOAT :
VERBOSE_PRINTF("float\n");
advancen(d, nbytes);
push_val(d, 4);
break;
case TYPE_DOUBLE :
VERBOSE_PRINTF("double\n");
advancen(d, nbytes);
push_val(d, 8);
break;
case TYPE_STRING :
VERBOSE_PRINTF("string\n");
advancen(d, nbytes);
labcomm2014_sig_parser_t_set_varsize(d);
push_val(d, 0);
break;
case TYPE_SAMPLE_REF :
VERBOSE_PRINTF("sample\n");
advancen(d, nbytes);
push_val(d, 4);
break;
case ARRAY_DECL :
accept_array_decl(d);
pop_val(d); // ignore element type
// push(d, pop(d) is a NOP --> leave size on stack
break;
case STRUCT_DECL :
accept_struct_decl(d);
// push(d, pop(d) is a NOP --> leave size on stack
break;
default :
//should we distinguish between SAMPLE_DEF and TYPE_DEF here?
//printf("accept_type default (type==%x) should not happen\n", type);
VERBOSE_PRINTF("user type 0x%x\n",type);
advancen(d, nbytes);
push_val(d, 0);
push_val(d, type);
return LABCOMM2014_FALSE;
}
push_val(d, type);
return LABCOMM2014_TRUE;
}
/* pushes size and element type */
static int accept_array_decl(labcomm2014_sig_parser_t *d){
size_t nbytes;
int tid = peek_varint(d, &nbytes) ;
if(tid == ARRAY_DECL) {
advancen(d, nbytes);
unsigned int nidx = get_varint(d);
VERBOSE_PRINTF("%d dim array", nidx);
int i;
unsigned int numVar=0;
unsigned int size=1;
for(i=0; i<nidx; i++) {
unsigned int idx = get_varint(d);
if(idx == 0) {
numVar++;
VERBOSE_PRINTF("[_] ");
labcomm2014_sig_parser_t_set_varsize(d);
} else {
VERBOSE_PRINTF("[%d] ", idx);
size*=idx;
}
}
VERBOSE_PRINTF(" of ");
accept_type(d);
unsigned int et= pop_val(d); // type
unsigned int es= pop_val(d); // (encoded) size
#ifdef DEBUG
printf("accept_array_decl: et = %x\n", et);
#endif
if(numVar == 0) {
#ifdef DEBUG
printf("size=%d, es=%d\n", size, es);
#endif
push_val(d, (size*es));
} else {
//HERE BE DRAGONS! push a (non-) size for variable size arrays?
push_val(d, 0);
}
push_val(d, et);
return LABCOMM2014_TRUE;
} else {
printf("accept_array_decl: type=%x, should not happen\n",tid);
push_val(d, 0);
push_val(d, tid);
return LABCOMM2014_FALSE;
}
}
/* pushes size */
static int accept_struct_decl(labcomm2014_sig_parser_t *d){
size_t nbytes;
int tid = peek_varint(d, &nbytes) ;
if(tid == STRUCT_DECL) {
advancen(d, nbytes);
unsigned int nf = get_varint(d);
if(nf == 0) {
VERBOSE_PRINTF("void\n");
} else {
VERBOSE_PRINTF("%d field struct:\n", nf);
}
int i;
#ifdef USE_UNUSED_VARS
int numVar=0;
int size=0;
#endif
unsigned int fieldsizes=0;
for(i=0; i<nf; i++) {
accept_field(d);
fieldsizes += pop_val(d);
}
push_val(d, fieldsizes);
return LABCOMM2014_TRUE;
} else {
printf("accept_struct_decl: type=%x, should not happen\n",tid);
push_val(d, 0);
return LABCOMM2014_FALSE;
}
}
/* pushes field size */
static int accept_field(labcomm2014_sig_parser_t *d){
VERBOSE_PRINTF("\tfield: ");
accept_intentions(d);
pop_val(d); // ignore name pos, for now
pop_val(d); // ignore name length, for now
#ifdef RETURN_STRINGS
char *str = (char *) pop_ptr(d);
free(str);
#endif
VERBOSE_PRINTF("\n\ttype: ");
accept_type(d);
pop_val(d); // ignore type, for now
// push(pop() is really a NOP , leave size on the stack when debugging done
VERBOSE_PRINTF("\n");
return LABCOMM2014_TRUE;
}
static int accept_sample_data(labcomm2014_sig_parser_t *d){
accept_user_id(d);
unsigned int uid = pop_val(d);
printf("sample data... uid=0x%x\n", uid);
int len = get_varint(d); //length field
#ifdef DEBUG
dump_signature(d, uid);
#endif
#ifdef SKIP_BY_PARSING
struct labcomm2014_signature *sigt = get_sig_t(d, uid);
int encoded_size = sigt->encoded_size(NULL);
INFO_PRINTF("encoded_size from sig: %d\n", encoded_size);
struct labcomm2014_signature *sig = get_sig_t(d, uid);
skip_packed_sample_data(d, sig);
#else
advancen(d, len);
#endif
return LABCOMM2014_TRUE;
}
static int skip_type(unsigned int,labcomm2014_sig_parser_t*,unsigned char*,unsigned int,int*) ;
static int skip_array(labcomm2014_sig_parser_t *d, unsigned char *sig, int len, int *pos) {
unsigned int skip = 0;
unsigned int tot_nbr_elem_tmp = 1;
size_t nbytes;
unsigned int nIdx = unpack_varint(sig, *pos, &nbytes);
VERBOSE_PRINTF("skip_array: nIdx = %d (from sig)\n", nIdx);
*pos +=nbytes;
unsigned int idx[nIdx];
unsigned int nVar=0;
unsigned int i;
for(i=0; i<nIdx; i++) {
idx[i] = unpack_varint(sig, *pos, &nbytes);
*pos += nbytes;
VERBOSE_PRINTF("skip_array: idx[%d]=%d (from sig)\n", i, idx[i]);
if(idx[i] == 0) {
nVar++;
} else {
tot_nbr_elem_tmp *= idx[i];
}
}
int var[nVar];
unsigned char varSize=0; // total number of bytes required for var size fields
for(i=0; i<nVar; i++) {
var[i] = get_varint_size(d, &nbytes);
varSize += nbytes;
VERBOSE_PRINTF("skip_array: var[%d]=%d (from sample)\n", i, var[i]);
tot_nbr_elem_tmp *= var[i];
}
int type = unpack_varint(sig, *pos, &nbytes);
*pos+=nbytes;
unsigned int elemSize = labcomm2014_sizeof_primitive(type);
skip = elemSize * tot_nbr_elem_tmp;
VERBOSE_PRINTF("skip_array: skip: %d * %d = %d\n", tot_nbr_elem_tmp, elemSize ,skip);
advancen(d, skip);
//return skip + 4*nVar;
return skip + varSize;
}
int skip_struct(labcomm2014_sig_parser_t *d, unsigned char *sig, unsigned int len, int *pos) {
size_t nbytes;
int nFields = unpack_varint(sig,*pos, &nbytes);
*pos += nbytes;
unsigned int i;
unsigned int skipped=0;
VERBOSE_PRINTF("skip_struct (%d fields)\n", nFields);
for(i=0; i<nFields; i++) {
//skip name
unsigned int namelen = unpack_varint(sig, *pos, &nbytes);
#ifdef DEBUG
VERBOSE_PRINTF("field #%d:\n----namelen==%d\n",i,namelen);
char name[namelen+1]; //HERE BE DRAGONS. alloca?
strncpy(name, (const char *)sig+*pos+nbytes, namelen);
name[namelen]=0;
VERBOSE_PRINTF("----name = %s\n",name);
#endif
*pos += (nbytes+namelen); // 32bit len + actual string
unsigned int type = unpack_varint(sig, *pos, &nbytes);
*pos += nbytes;
#ifdef DEBUG
VERBOSE_PRINTF("----type == %x\n", type);
#endif
skipped += skip_type(type, d, sig, len, pos);
}
return skipped;
}
#ifndef QUIET
/* print and skip */
int skip_type(unsigned int type, labcomm2014_sig_parser_t *d,
unsigned char *sig, unsigned int len, int *pos)
{
int skipped=0;
printf("skip_type %x:", type);
switch(type) {
case TYPE_BOOLEAN :
printf("boolean [%d]\n", get(d));
skipped++;
break;
case TYPE_BYTE :
printf("byte [%d]\n", get(d));
skipped++;
break;
case TYPE_SHORT :
//XXX not supported
advancen(d,2);
skipped+=2;
break;
case TYPE_INTEGER :
printf("integer [%d]\n", get32(d));
skipped +=4;
break;
case TYPE_FLOAT :
//XXX not supported
advancen(d,4);
skipped+=4;
break;
case TYPE_LONG :
case TYPE_DOUBLE :
//XXX not supported
advancen(d,8);
skipped+=8;
break;
case TYPE_STRING :
{
size_t nbytes;
int len = get_varint_size(d, &nbytes);
int i;
printf("string [");
for(i=0; i<len; i++)
printf("%c", get(d));
printf("]\n");
skipped+=len+nbytes;
break;}
case ARRAY_DECL :
printf("array\n");
skipped += skip_array(d, sig, len, pos);
break;
case STRUCT_DECL :
printf("struct\n");
skipped += skip_struct(d, sig, len, pos);
break;
default:
printf("ERROR: skip_type: type = %x\n", type);
exit(1);
}
return skipped;
}
#else
int skip_type(unsigned int type, labcomm2014_sig_parser_t *d,
const char *sig, unsigned int len, int *pos)
{
int skipped=0;
VERBOSE_PRINTF("skip_type %x\n", type);
switch(type) {
case TYPE_BOOLEAN :
case TYPE_BYTE :
advancen(d,1);
skipped++;
break;
case TYPE_SHORT :
advancen(d,2);
skipped+=2;
break;
case TYPE_INTEGER :
case TYPE_FLOAT :
advancen(d,4);
skipped+=4;
break;
case TYPE_LONG :
case TYPE_DOUBLE :
advancen(d,8);
skipped+=8;
break;
case TYPE_STRING :
{
size_t nbytes;
int len = get_varint_size(d, &nbytes);
advancen(d,len);
skipped+=len+nbytes;
break;}
case ARRAY_DECL :
skipped += skip_array(d, sig, len, pos);
break;
case STRUCT_DECL :
skipped += skip_struct(d, sig, len, pos);
break;
default:
printf("ERROR: skip_type: type = %x\n", type);
exit(1);
}
return skipped;
}
#endif
/* parse signature and skip the corresponding bytes in the labcomm2014_sig_parser_t
*/
int skip_packed_sample_data(labcomm2014_sig_parser_t *d, struct labcomm2014_signature *sig) {
int pos = 0; //current position in signature
unsigned int skipped = 0; //skipped byte counter
while(pos < sig->size) {
size_t nbytes;
int type = unpack_varint(sig->signature,pos, &nbytes);
pos+=nbytes;
skipped += skip_type(type, d, sig->signature, sig->size, &pos);
}
printf("skipped %d bytes\n", skipped);
return LABCOMM2014_TRUE;
}