[ragel-users] Work On Binary datagrams

Thu Dec 16 20:02:00 UTC 2010

Thanks. I'll be keeping an eye out for this and try to contribute if I come
up with any compelling ideas.

In the meantime, let me drone about my current state machine... looking at
the output from graphviz, it looks like the complexity is greater in the
graph output than what I expected (indeed I'm trying to sell my team on the
ragel approach, with one metric being that the state machines are
understandable via the graphviz output). This makes me think I've specified
my machine poorly.

At a high-level my data looks like:

open xml-like tag with parameters type and info
length
binary blog of length bytes
close xml-like tag

I'm hoping someone can increase my wisdom on matters of this sort.

BR,

-joe

On Thu, Dec 16, 2010 at 1:34 PM, Adrian Thurston <
adrian.thurston at esentire.com> wrote:

> Right now there is no 'right' way. There are actually are many different
> ways each with their own ups and downs. There is some work I want to do on
> conditions to ease length processing (comes up at work a lot) and I'm hoping
> to soon be able to prescribe a recommended way of dealing with lengths that
> is general enough to apply to the majority of cases that I see.
>
>
> On 10-12-16 06:24 AM, Joseph Stewart wrote:
>
>> Adrian,
>>
>> Do you have any tips or small examples for dealing with lengths? While I
>> have something that works, it doesn't feel right and I don't have the
>> experience with Ragel to know if I'm doing this right.
>>
>> Below is a shell I've started to parse/validate binary chunks out of
>> XML-like tags (BTW, I did not create the format... I'm just the victim).
>> Eventually I need to parse data inside the Bin chunks.
>>
>> The graphviz output for this is so gigantic that I think I'm doing
>> something fundamentally wrong.
>>
>> Suggestions are greatly appreciated!
>>
>> -joe
>>
>> --- code follows ---
>>
>> #include <stdio.h>
>>
>> /*
>>
>> chunks in file look like
>>
>> <XRNDATA08192020001>LenData</XRNDATA>
>> where "08192" is an ASCII type designator (can expect other types)
>> where "020001" is an ASCII information field
>> where Len is a 4-byte little endian length designator
>> where Data is binary data of Len length
>>
>> */
>>
>> #define XRN 'X', 'R', 'N', 'D', 'A', 'T', 'A'
>> #define T1 '0', '8', '1', '9', '2'
>> #define T2 '0', '0', '0', '1', '6'
>> #define T3 '0', '0', '0', '0', '8'
>> #define T4 '0', '0', '0', '0', '1'
>> #define I1 '0', '2', '0', '0', '0', '1'
>>
>> %%{
>> machine tds;
>> write data;
>> }%%
>>
>> int main() {
>> int len = 0;
>> unsigned char buf[] = {
>> '<', XRN, T1, I1, '>', 0, 0, 0, 5, 48,49,50,51,52, '<', '/', XRN, '>',
>> '<', XRN, T2, I1, '>', 0, 0, 0, 1, 10, '<', '/', XRN, '>',
>> '<', XRN, T3, I1, '>', 0, 0, 0, 1, 10, '<', '/', XRN, '>',
>> '<', XRN, T4, I1, '>', 0, 0, 0, 1, 10, '<', '/', XRN, '>',
>> '<', XRN, T1, I1, '>', 0, 0, 0, 0, '<', '/', XRN, '>',
>> };
>> int cs, r = 0;
>> unsigned char *p = (unsigned char *)&buf;
>> unsigned char *pe = p + sizeof(buf);
>> printf("len=%d\n", len);
>> %%{
>> t1 = '08192' @{ printf("t1\n"); };
>> t2 = '00016' @{ printf("t2\n"); };
>> t3 = '00008' @{ printf("t3\n"); };
>> t4 = '00001' @{ printf("t4\n"); };
>> type = (t1 | t2 | t3 | t4);
>> info = '020001';
>> open = '<XRNDATA' type info '>' @{ printf("begin XRNDATA\n"); len = 0; };
>> len = extend{4} @{ printf("len = %d\n", (int)*p); len = (len*256) + (*p);
>> };
>> buffer = (extend when {len--})* @{ printf("[%d]:%d\n", len, *p); };
>> close = '</XRNDATA>' @{ printf("end XRNDATA\n"); };
>> expr = open len buffer close;
>> main := expr*;
>> write init;
>> write exec;
>> }%%
>> return 0;
>> }
>>
>>
>>
>> On Mon, Dec 6, 2010 at 1:16 PM, Adrian Thurston
>> <adrian.thurston at esentire.com <mailto:adrian.thurston at esentire.com>>
>> wrote:
>>
>>    I use ragel to parse binary protocols at work. Often, the most
>>    difficult part is dealing with lengths, or counts of things. A good
>>    example is the DNS protocol. There are several sections of N blocks
>>    of questions and resource records items. Inside the blocks you must
>>    also deal with lengths in names.
>>
>>    Unfortunately, there are not many open examples of parsing this way.
>>    Start by looking in the manual. I would like to improve Ragel's
>>    support for this kind of parsing.
>>
>>    -Adrian
>>
>>
>>    On 10-12-03 02:53 AM, Vitaly V. Ch wrote:
>>
>>        Hi!
>>
>>        I'm interested in any tips or examples of using ragel on binary
>>        datagrams.
>>
>>        \\wbr Vitaly Chernooky
>>
>>        _______________________________________________
>>        ragel-users mailing list
>>        ragel-users at complang.org <mailto:ragel-users at complang.org>
>>
>>        http://www.complang.org/mailman/listinfo/ragel-users
>>
>>
>>    _______________________________________________
>>    ragel-users mailing list
>>    ragel-users at complang.org <mailto:ragel-users at complang.org>
>>
>>    http://www.complang.org/mailman/listinfo/ragel-users
>>
>>
>>
>>
>> _______________________________________________
>> ragel-users mailing list
>> ragel-users at complang.org
>> http://www.complang.org/mailman/listinfo/ragel-users
>>
>
> _______________________________________________
> ragel-users mailing list
> ragel-users at complang.org
> http://www.complang.org/mailman/listinfo/ragel-users
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.colm.net/pipermail/ragel-users/attachments/20101216/6802815c/attachment-0001.html>
-------------- next part --------------
_______________________________________________
ragel-users mailing list
ragel-users at complang.org
http://www.complang.org/mailman/listinfo/ragel-users