protomsg 0.5.0 → 0.6.0

data/README.rdoc

@@ -2,7 +2,7 @@
 
 Protocol Message Buffers for C. This gem generates C socket code for reading and writing messages described in the protomsg DSL.
 
-== Example
+== Overview
 Input for a 'request' message:
 
     request {
@@ -57,5 +57,73 @@ All message type and attribute names must be valid C identifiers. Valid attribut
     string  C string
     raw     Raw bytes
 
+== Example
+Once you have defined your message types, sending and receiving messages is easy. For example, given the following message type:
+
+    # ping_message.protomsg
+    ping {
+        int     number
+        string  message
+    }
+    
+    response {
+        int     code
+    }
+
+Use the protomsg script:
+
+    $ protomsg ping_message.protomsg
+    Created protomsg.h
+    Created ping_message.h
+    Creates response_message.h
+
+A number of utility macros are defined that make it easy to write clients and servers. An example client could be written as:
+
+    #include "response_message.h"
+    #include "ping_message.h"
+    
+    int main(void) {
+        int error, server;
+        response *r;
+        ping *p;
+    
+        // create the ping message
+        init_ping(p);
+        set_ping_number(p, 1);
+        set_ping_message(p, "Hello World!");
+    
+        // connect to the server and send the message
+        connect_to_server("localhost", 9000, server, error);
+        write_ping(p, server, error);
+    
+        // read a response message
+        read_response(r, server, error);
+        printf("Response code was: %llu\n", get_response_code(r));
+    }
+
+And the corresponding server could be:
+
+    #include "response_message.h"
+    #include "ping_message.h"
+    
+    int main(void) {
+        int error, server, client;
+        response *r;
+        ping *p;
+    
+        // start a server and wait for a ping message
+        create_server_socket(9000, 1, server, error);
+        accept_client(server, client);
+        read_ping(p, client, error);
+        printf("Received ping: %llu, %s\n", get_ping_number(p), get_ping_message(p));
+    
+        // create a response message and send
+        init_response(r);
+        set_response_code(r, 1);
+        write_response(r, client, error);
+    }
+
+It's not necessary to use the included socket helper macros - you can use protomsg's over any socket - but for simple client/server applications like this they help reduce the amount of code required to get something running quickly.
+
 == Known Issues
 All clients are servers are assumed to be on machines of the same endianess.

data/lib/templates/getters/string_getter.h

@@ -1 +1 @@
-#define get_<%= @message_type.name %>_<%= @name %>(msg) (msg-><%= @name %>)
+#define get_<%= @message_type.name %>_<%= @name %>(msg) ((char *)msg-><%= @name %>)

data/lib/templates/io.h

@@ -1,4 +1,5 @@
 #define write_<%= @name %>(msg, sock, error) {\
+  error = 0;\
   ssize_t written = writev(sock, (const struct iovec *)msg, <%= variable_attributes.size + 1 %>);\
   if(written != <%= @name %>_length(msg)){\
     error = errno;\
@@ -10,9 +11,13 @@
   msg->header_length = sizeof(<%= @name %>_header);\
   msg->header = (<%= @name %>_header *)malloc(sizeof(<%= @name %>_header));\
   read_struct(sock, msg->header, sizeof(<%= @name %>_header), error);\
-  if(error == 0) {\
-    <% variable_attributes.each do |attr| %>msg-><%= attr.name %>_length = msg->header-><%= attr.name %>_length;\
-    msg-><%= attr.name %> = malloc(msg->header-><%= attr.name %>_length);\
-    <% end %>readv(sock, (const struct iovec *)msg + 1, <%= variable_attributes.size %>);\
+  if(!error) {\
+    if(msg->header->_version == PROTO_MESSAGE_VERSION && msg->header->_type == <%= @name.upcase %>_MESSAGE_TYPE) {\
+      <% variable_attributes.each do |attr| %>msg-><%= attr.name %>_length = msg->header-><%= attr.name %>_length;\
+      msg-><%= attr.name %> = malloc(msg->header-><%= attr.name %>_length);\
+      <% end %>readv(sock, (const struct iovec *)msg + 1, <%= variable_attributes.size %>);\
+    } else {\
+      error = INVALID_PROTOMSG_HEADER;\
+    }\
   }\
 }

data/lib/templates/lengths.h

@@ -1,2 +1,2 @@
 <% variable_attributes.each do |attr| %>#define <%= @name %>_<%= attr.name %>_length(msg) (msg-><%= attr.name %>_length)
-<% end %>#define <%= @name %>_length(msg) (msg->header_length + <%= variable_attributes.collect {|attr| "msg->#{attr.name}_length"}.join(" + ") %>)
+<% end %>#define <%= @name %>_length(msg) (msg->header_length <%= variable_attributes.size > 0 ? ("+ " + variable_attributes.collect {|attr| "msg->#{attr.name}_length"}.join(" + ")) : '' %>)

data/lib/templates/message_type.h

@@ -9,6 +9,9 @@
 #include <unistd.h>
 #include "protomsg.h"
 
+#ifndef __protomsg_<%= @name %>__
+#define __protomsg_<%= @name %>__
+
 #define <%= @name.upcase %>_MESSAGE_TYPE  <%= @type_number %>
 
 <%= header %>
@@ -23,3 +26,5 @@
 <%= memory %>
 // io
 <%= io %>
+
+#endif

data/lib/templates/protomsg.h

@@ -1,21 +1,77 @@
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <arpa/inet.h>
+#include <netdb.h>
 #include <stdio.h>
+#include <errno.h>
 
 #ifndef __protomsg__
 #define __protomsg__
 
-#define PROTO_MESSAGE_VERSION 1
+#define PROTO_MESSAGE_VERSION   1
+#define INVALID_PROTOMSG_HEADER 1
+
 #define read_struct(sock, structure, size, error) {\
-  ssize_t bytes_read = 0, bytes_total = 0;\
   error = 0;\
-  while(bytes_total < size) {\
-    bytes_read = read(sock, structure + bytes_total, size - bytes_total);\
-    if(bytes_read != -1) {\
-      bytes_total += bytes_read;\
+  ssize_t _bytes_read = 0, _bytes_total = 0;\
+  while(_bytes_total < size) {\
+    _bytes_read = read(sock, structure + _bytes_total, size - _bytes_total);\
+    if(_bytes_read != -1) {\
+      _bytes_total += _bytes_read;\
     } else {\
       error = errno;\
-      bytes_total = size;\
+      _bytes_total = size;\
+    }\
+  }\
+}
+
+#define create_server_socket(port, queue, sock, error) {\
+  error = 0;\
+  sock = socket(AF_INET, SOCK_STREAM, 0);\
+  struct sockaddr_in _servaddr;\
+  memset(&_servaddr, 0, sizeof(_servaddr));\
+  _servaddr.sin_family      = AF_INET;\
+  _servaddr.sin_addr.s_addr = htonl(INADDR_ANY);\
+  _servaddr.sin_port        = htons(port);\
+  error = bind(sock, (const struct sockaddr *)&_servaddr, sizeof(_servaddr));\
+  if(error) {\
+    error = errno;\
+  } else {\
+    error = listen(sock, queue);\
+    if(error) {\
+      error = errno;\
     }\
   }\
 }
 
+#define accept_client(sock, client) {\
+  client = accept(sock, NULL, NULL);\
+}
+
+#define connect_to_server(address, port, sock, error) {\
+  error = 0;\
+  sock = socket(AF_INET, SOCK_STREAM, 0);\
+  struct sockaddr _servaddr;\
+  socklen_t _servaddr_length;\
+  get_socket_addr_from_hostname(address, _servaddr, _servaddr_length, error);\
+  if(!error) {\
+    ((struct sockaddr_in *) &_servaddr)->sin_port = htons(port);\
+    error = connect(sock, (struct sockaddr *) &_servaddr, sizeof(_servaddr));\
+  }\
+}
+
+#define get_socket_addr_from_hostname(host, servaddr, length, error) {\
+  struct addrinfo _hints, *_result;\
+  memset(&_hints, 0, sizeof(_hints));\
+  _hints.ai_family   = AF_INET;\
+  _hints.ai_socktype = SOCK_STREAM;\
+  _hints.ai_protocol = IPPROTO_TCP;\
+  error = getaddrinfo(host, NULL, &_hints, &_result);\
+  if(!error) {\
+    length = _result->ai_addrlen;\
+    memcpy(&servaddr, _result->ai_addr, length);\
+    freeaddrinfo(_result);\
+  }\
+}
+
 #endif

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 5
+  - 6
   - 0
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Will Cannings