luarpc_rpc.h

#include "cexcept.h"
#include "type.h"
#include "serial.h"

#include "platform_conf.h"
/****************************************************************************/
// Parameters

#define NUM_FUNCNAME_CHARS 20 // Maximum function name length

#define MAX_LINK_ERRS ( 2 ) // Maximum number of framing errors before connection reset

#if defined( LUARPC_ENABLE_SERIAL )
#define LUARPC_MODE "serial"
#define tpt_handler ser_handler
#elif defined( LUARPC_ENABLE_SOCKET )
#define LUARPC_MODE "tcpip"
typedef int tpt_handler;
#define MAXCON ( 1 )
#else
#error "No RPC mode Selected.."
#endif

// a kind of silly way to get the maximum int, but oh well ...
#define MAXINT ((int)((((unsigned int)(-1)) << 1) >> 1))

/****************************************************************************/
// Debug Error Handling

// allow special handling for GCC compiler
#ifdef __GNUC__
#define DOGCC(x) x
#else
#define DOGCC(x) /* */
#endif

// Assertions for debug mode
#ifdef LUARPC_DEBUG
#ifdef __GNUC__
#define MYASSERT(a) if (!(a)) rpcdebug ( \
  "assertion \"" #a "\" failed in %s() [%s]",__FUNCTION__,__FILE__);
#else
#define MYASSERT(a) if (!(a)) rpcdebug ( \
  "assertion \"" #a "\" failed in %s:%d",__FILE__,__LINE__);
#endif
#else
#define MYASSERT(a) ;
#endif

//****************************************************************************
// Error Messages & Exceptions

#ifdef WIN32_BUILD
#include "windows.h"
#define transport_strerror strerror
#define transport_errno (GetLastError())
#else
#define transport_errno errno
#define transport_strerror strerror
#endif

// error numbers passed around are normal system "errno" error numbers
//  (normally generated by transport operations), except when they have the
//  following values:

enum {
  ERR_EOF       = MAXINT - 100,  // reached end of file on transport
  ERR_CLOSED    = MAXINT - 101,  // attempted operation on closed transport
  ERR_PROTOCOL  = MAXINT - 102,  // some error in the received protocol
  ERR_NODATA    = MAXINT - 103,
  ERR_COMMAND   = MAXINT - 106,
  ERR_HEADER    = MAXINT - 107,
  ERR_LONGFNAME = MAXINT - 108
};

enum exception_type { done, nonfatal, fatal };

struct exception {
  enum exception_type type;
	int errnum;
};

define_exception_type(struct exception);

extern struct exception_context the_exception_context[ 1 ];

//****************************************************************************
// LuaRPC Structures

// Transport Connection Structure
typedef struct _Transport Transport;
struct _Transport 
{
  tpt_handler fd;
  unsigned tmr_id;
  u32    loc_little: 1,               // Local is little endian?
         loc_armflt: 1,               // local float representation is arm float?
         loc_intnum: 1,               // Local is integer only?
         net_little: 1,               // Network is little endian?
         net_intnum: 1,               // Network is integer only?
         mode: 2;                     // read (0) or write (1)
  u8     lnum_bytes;
};

typedef struct _Handle Handle;
struct _Handle 
{
  Transport tpt;                      // the handle socket
  int error_handler;                  // function reference
  int async;                          // nonzero if async mode being used
  int read_reply_count;               // number of async call return values to read
};

typedef struct _Helper Helper;
struct _Helper {
  Handle *handle;                     // pointer to handle object
	Helper *parent;                     // parent helper
  int pref;                           // Parent reference idx in registry
	u8 nparents;                        // number of parents
  char funcname[NUM_FUNCNAME_CHARS];  // name of the function
};

typedef struct _ServerHandle ServerHandle;
struct _ServerHandle {
  Transport ltpt;   // listening transport, always valid if no error
  Transport atpt;   // accepting transport, valid if connection established
	int link_errs;
};


// Connection State Checking
#ifdef WIN32_BUILD
#define INVALID_TRANSPORT (INVALID_HANDLE_VALUE)
#else
#define INVALID_TRANSPORT (-1)
#endif

#define TRANSPORT_VERIFY_OPEN \
	if (tpt->fd == INVALID_TRANSPORT) \
	{ \
		e.errnum = ERR_CLOSED; \
		e.type = fatal; \
		Throw( e ); \
	}

#define TRANSPORT_VERIFY_READ \
	if (tpt->mode != 0) \
	{ \
		e.errnum = ERR_EOF; \
		e.type = fatal; \
		Throw( e ); \
	}

#define TRANSPORT_VERIFY_WRITE \
	if (tpt->mode != 1) \
	{ \
		e.errnum = ERR_EOF; \
		e.type = fatal; \
		Throw( e ); \
	}


// Arg & Error Checking Provided to Transport Mechanisms 
int check_num_args (lua_State *L, int desired_n);
void deal_with_error (lua_State *L, Handle *h, const char *error_string);
void my_lua_error( lua_State *L, const char *errmsg );

// TRANSPORT API 

// Setup Transport 
void transport_init (Transport *tpt);

// Open Listener / Server 
void transport_open_listener(lua_State *L, ServerHandle *handle);

// Open Connection / Client 
int transport_open_connection(lua_State *L, Handle *handle);

// Accept Connection 
void transport_accept (Transport *tpt, Transport *atpt);

// Read & Write to Transport 
void transport_read_buffer (Transport *tpt, u8 *buffer, int length);
void transport_write_buffer (Transport *tpt, const u8 *buffer, int length);

// Check if data is available on connection without reading:
// 		- 1 = data available, 0 = no data available
int transport_readable (Transport *tpt);

// Check if transport is open:
//		- 1 = connection open, 0 = connection closed
int transport_is_open (Transport *tpt);

// Shut down connection
void transport_close (Transport *tpt);


// added by edo

// luagoodies
void my_lua_error( lua_State *L, const char *errmsg );
int check_num_args( lua_State *L, int desired_n );
int ismetatable_type( lua_State *L, int ud, const char *tname );

// transport
void transport_set_mode( Transport *tpt, int mode);
#define TRANSPORT_START_READING(t) transport_set_mode((t),0)
#define TRANSPORT_START_WRITING(t) transport_set_mode((t),1)
#define TRANSPORT_STOP(t) transport_set_mode((t),2)
void transport_read_string( Transport *tpt, const char *buffer, int length );
void transport_write_string( Transport *tpt, const char *buffer, int length );
u8 transport_read_u8( Transport *tpt );
void transport_write_u8( Transport *tpt, u8 x );
u32 transport_read_u32( Transport *tpt );
void transport_write_u32( Transport *tpt, u32 x );
lua_Number transport_read_number( Transport *tpt );
void transport_write_number( Transport *tpt, lua_Number x );
void write_variable( Transport *tpt, lua_State *L, int var_index );
int read_variable( Transport *tpt, lua_State *L );

// luarpc
void server_negotiate( Transport *tpt );
void helper_remote_index( Helper *helper ); //?!?
int global_error_handler;

// client
void register_client(lua_State *L);

// server
int rpc_dispatch( lua_State *L );
void rpc_dispatch_helper( lua_State *L, ServerHandle *handle );
ServerHandle *server_handle_create( lua_State *L );
void server_handle_shutdown( ServerHandle *h );
void server_handle_destroy( ServerHandle *h );