gnat -xdr flag confusion.

gnat -xdr flag confusion.

[magardner2010]

I'm still working on the p2p one-to-many data streaming protocol thing 
(at https://github.com/smeagolthellama/szakdolgozat-notes/tree/main/ada) 
and I'm trying to get it to communicate with a C thing via the xdr 
protocol. I'm trying to transfer a Child_Set, where
```
     type Child_Number is range 0 .. 2;
     subtype Child_Index is Child_Number range 1 .. Child_Number'Last;

     type Child_Set is array (Child_Index) of GNAT.Sockets.Sock_Addr_Type;
```
With the help of chatGPT, I wrote the following xdr spec file:
```
const CHILD_NUMBER = 2;

typedef unsigned int uint32;
typedef unsigned char uint8;

enum family_type {
   FAMILY_INET = 0,
   FAMILY_INET6 = 1,
   FAMILY_UNIX = 2,
   FAMILY_UNSPEC = 3
};

union inet_addr_type switch (family_type family) {
   case FAMILY_INET:
     opaque sin_v4[4];
   case FAMILY_INET6:
     opaque sin_v6[16];
   default:
     void;
};

struct address_and_port{
   inet_addr_type addr;
   unsigned int port;
};

union sock_addr_type switch (family_type family) {
   case FAMILY_UNIX:
     string name<>;
   case FAMILY_INET:
     address_and_port anp4;
   case FAMILY_INET6:
     address_and_port anp6;
   case FAMILY_UNSPEC:
     void;
};

struct child_set {
   sock_addr_type child_set_array[CHILD_NUMBER];
};
```
and using rpcgen, generated a C thing to encode/decode the messages the 
ada program is sending.

However, if the ada code encodes the object with 'write, then it creates 
something about 4 bytes too short, and if I use 'output, it is parsed as 
starting with family_type 256, which is not a member of the enum. Given 
that the gnat documentation for the -xdr flag is literally two lines, I 
don't really know where to look for more information on what I'm doing 
wrong. My current hypotheses include the C code having the family type 
recorded too many times (but I don't know how to check or fix that in 
the .x file) or the ada code not encoding the data according to the xdr 
standard correctly (but I am using the flag, and neither 'write or 
'output fixes it).

Re: gnat -xdr flag confusion.

[Dmitry A. Kazakov]

On 2023-07-04 12:56, magardner2010 wrote:

> However, if the ada code encodes the object with 'write, then it creates 
> something about 4 bytes too short, and if I use 'output, it is parsed as 
> starting with family_type 256, which is not a member of the enum. Given 
> that the gnat documentation for the -xdr flag is literally two lines, I 
> don't really know where to look for more information on what I'm doing 
> wrong.

You never defined the protocol and implemented it in the first place. 
You used some code generation tools which, if ever worked, will bite you 
in the end.

To summarize the problem. The stream attribute 'Write writes the 
constrained object. 'Output adds the constraints. Ada is capable to have 
variable length records. C cannot do this. In short, it means that XDR's 
discriminated union can be mapped onto Ada's variant record with no 
default discriminant, but it cannot be directly mapped onto C's union. I 
presume that GNAT implements XDR correctly and the C side does not cope.

Which is one of thousand reasons not to implement a communication 
protocol by deriving representation from some language objects. Cutting 
corners will not help you.

Define the (application level [*]) protocol. Implement it in Ada. 
Implement it in C. Done.

---------------------
*  XDR or ASN.1 or whatever are not application level!

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: gnat -xdr flag confusion.

[magardner2010]

On 04/07/2023 14:39, Dmitry A. Kazakov wrote:
> On 2023-07-04 12:56, magardner2010 wrote:
> 
>> ...
> 
> You never defined the protocol and implemented it in the first place. 
> You used some code generation tools which, if ever worked, will bite you 
> in the end.

With regards to the code generation tool (which I'm assuming refers to 
chtGPT, for which I don't have enough creatively insulting backronyms), 
I spent a good half a day getting the output to actually be accepted by 
rpcgen. I then rewrote most of it from scratch.

With regards to the protocol implementation, I would like to point at 
the function that begins at 
https://github.com/smeagolthellama/szakdolgozat-notes/blob/f0b5143855f75354d41509845b0a41f0902d2928/ada/src/network_tree.adb#L29 
, which has successfully communicated with other instances of itself, 
albeit using 'write and 'read to handle anything more complicated than 
"is the first character of the message a '?', a 'j', or a '>'?". My 
question was about how to get C to understand the language Ada is 
talking to itself in, given that that language should be at least 
related to XDR.

> 
> To summarize the problem. The stream attribute 'Write writes the 
> constrained object. 'Output adds the constraints. Ada is capable to have 
> variable length records. C cannot do this. In short, it means that XDR's 
> discriminated union can be mapped onto Ada's variant record with no 
> default discriminant, but it cannot be directly mapped onto C's union. I 
> presume that GNAT implements XDR correctly and the C side does not cope.
> 

I'm not sure I understand what you're saying here. Given that rpcgen 
(which generates functions for xdr, as well as rpc, a superset thereof) 
was a part of GNU's libc for a while, and still is on some ubuntu boxes, 
along with the fact that a number of Linux's favourite protocols (such 
as NFS) are implemented using it, I don't think the issue is the C side 
implementing the encoder/decoder in a way that doesn't match my spec. I 
expect either an Ada issue, a spec issue, or both.

> Which is one of thousand reasons not to implement a communication 
> protocol by deriving representation from some language objects. Cutting 
> corners will not help you.

I suppose there is wisdom in that, especially when attempting to 
communicate across architectures, but I was working under the assumption 
that the -xdr flag would remove the issue, as XDR is an 
architecture-and-programming-language-agnostic data encoding/decoding 
standard (or whatever an RFC counts as).

> 
> Define the (application level [*]) protocol. Implement it in Ada. 
> Implement it in C. Done.
> 
> ---------------------
> *  XDR or ASN.1 or whatever are not application level!
> 

I wouldn't have called XDR a protocol in the first place, except as a 
simplification. I would like to use it as a *part* of my protocol, not 
dissimilar to how NFS does, or programs that use G*ogle's protobuf thingie.

Specifically, when a peer receives a query (in the form of a message 
starting with '?'), it should respond with a lump of data (current idea 
is the Child_Set type from my previous post, encoded in the XDR format, 
hence the difficulties) saying how many peers it has (in range 0..2), 
and who they are (address-port combinations, where address can be IPv4 
or 6), so that the querying party can find out if there is space for it 
on this peer, or if it should look elsewhere. There are a couple of edge 
cases, but this if you are curious you can look at my code.